Fix issue that cause false alarm corruption report (#12626)

Summary:
The state of `saved_seq_for_penul_check_` is not correctly maintained with the current flow. It's supposed to store the original sequence number for a `kTypeValuePreferredSeqno` entry for use in the `DecideOutputLevel` function. However, it's not always properly cleared.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/12626

Test Plan:
Added unit test that would fail before the fix
./tiered_compaction_test --gtest_filter="*InterleavedTimedPutAndPut*"

Reviewed By: pdillinger

Differential Revision: D57123469

Pulled By: jowlyzhang

fbshipit-source-id: 8d73214b3b6dc152daf19b6bd6ee9063581dc277

.github/workflows/benchmark-linux.yml

@@ -1,13 +1,13 @@
 name: facebook/rocksdb/benchmark-linux
 on: workflow_dispatch
-permissions: {}
-  # FIXME: Disabled temporarily
-  # schedule:
-  # - cron: 7 */2 * * *  # At minute 7 past every 2nd hour
 jobs:
+  # FIXME: when this job is fixed, it should be given a cron schedule like
+  # schedule:
+  # - cron: 0 * * * *
+  # workflow_dispatch:
   benchmark-linux:
     if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: ubuntu-latest # FIXME: change this back to self-hosted when ready
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/build-for-benchmarks"

.github/workflows/nightly-candidate.yml

@@ -1,6 +1,5 @@
 name: facebook/rocksdb/nightly
 on: workflow_dispatch
-permissions: {}
 jobs:
   # These jobs would be in nightly but are failing or otherwise broken for
   # some reason.

.github/workflows/nightly.yml

@@ -3,7 +3,6 @@ on:
   schedule:
   - cron: 0 9 * * *
   workflow_dispatch:
-permissions: {}
 jobs:
   build-format-compatible:
     if: ${{ github.repository_owner == 'facebook' }}
@@ -60,15 +59,12 @@ jobs:
     container:
       image: zjay437/rocksdb:0.6
       options: --shm-size=16gb
-    env:
-      CC: clang-13
-      CXX: clang++-13
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
     - uses: "./.github/actions/setup-folly"
     - uses: "./.github/actions/build-folly"
-    - run: LIB_MODE=static USE_CLANG=1 USE_FOLLY=1 COMPILE_WITH_UBSAN=1 COMPILE_WITH_ASAN=1 make -j32 check
+    - run: CC=clang-13 CXX=clang++-13 LIB_MODE=static USE_CLANG=1 USE_FOLLY=1 COMPILE_WITH_UBSAN=1 COMPILE_WITH_ASAN=1 make -j32 check
     - uses: "./.github/actions/post-steps"
   build-linux-valgrind:
     if: ${{ github.repository_owner == 'facebook' }}
@@ -80,7 +76,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
-    - run: make V=1 -j32 valgrind_test
+    - run: PORTABLE=1 make V=1 -j32 valgrind_test
     - uses: "./.github/actions/post-steps"
   build-windows-vs2022-avx2:
     if: ${{ github.repository_owner == 'facebook' }}

.github/workflows/pr-jobs-candidate.yml

@@ -1,6 +1,5 @@
 name: facebook/rocksdb/pr-jobs-candidate
 on: workflow_dispatch
-permissions: {}
 jobs:
   # These jobs would be in pr-jobs but are failing or otherwise broken for
   # some reason.

.github/workflows/pr-jobs.yml

@@ -1,6 +1,5 @@
 name: facebook/rocksdb/pr-jobs
 on: [push, pull_request]
-permissions: {}
 jobs:
   # NOTE: multiple workflows would be recommended, but the current GHA UI in
   # PRs doesn't make it clear when there's an overall error with a workflow,
@@ -91,9 +90,6 @@ jobs:
     container:
       image: zjay437/rocksdb:0.6
       options: --shm-size=16gb
-    env:
-      CC: gcc-10
-      CXX: g++-10
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
@@ -108,47 +104,38 @@ jobs:
     container:
       image: zjay437/rocksdb:0.6
       options: --shm-size=16gb
-    env:
-      CC: gcc-10
-      CXX: g++-10
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
     - uses: "./.github/actions/setup-folly"
     - run: "(mkdir build && cd build && cmake -DUSE_FOLLY_LITE=1 -DWITH_GFLAGS=1 .. && make V=1 -j20)"
     - uses: "./.github/actions/post-steps"
-  build-linux-make-with-folly:
+  build-linux-gcc-7-with-folly:
     if: ${{ github.repository_owner == 'facebook' }}
     runs-on:
       labels: 16-core-ubuntu
     container:
       image: zjay437/rocksdb:0.6
       options: --shm-size=16gb
-    env:
-      CC: gcc-10
-      CXX: g++-10
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
     - uses: "./.github/actions/setup-folly"
     - uses: "./.github/actions/build-folly"
-    - run: USE_FOLLY=1 LIB_MODE=static V=1 make -j32 check
+    - run: USE_FOLLY=1 LIB_MODE=static CC=gcc-7 CXX=g++-7 V=1 make -j32 check
     - uses: "./.github/actions/post-steps"
-  build-linux-make-with-folly-lite-no-test:
+  build-linux-gcc-7-with-folly-lite-no-test:
     if: ${{ github.repository_owner == 'facebook' }}
     runs-on:
       labels: 16-core-ubuntu
     container:
       image: zjay437/rocksdb:0.6
       options: --shm-size=16gb
-    env:
-      CC: gcc-10
-      CXX: g++-10
     steps:
     - uses: actions/checkout@v4.1.0
     - uses: "./.github/actions/pre-steps"
     - uses: "./.github/actions/setup-folly"
-    - run: USE_FOLLY_LITE=1 V=1 make -j32 all
+    - run: USE_FOLLY_LITE=1 CC=gcc-7 CXX=g++-7 V=1 make -j32 all
     - uses: "./.github/actions/post-steps"
   build-linux-cmake-with-folly-coroutines:
     if: ${{ github.repository_owner == 'facebook' }}

.gitignore

@@ -47,9 +47,6 @@ package/
 unity.a
 tags
 etags
-GPATH
-GRTAGS
-GTAGS
 rocksdb_dump
 rocksdb_undump
 db_test2

CMakeLists.txt

@@ -267,8 +267,8 @@ endif(CMAKE_SYSTEM_PROCESSOR MATCHES "s390x")
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
   CHECK_C_COMPILER_FLAG("-march=loongarch64" HAS_LOONGARCH64)
   if(HAS_LOONGARCH64)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=loongarch64 -mtune=loongarch64")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=loongarch64 -mtune=loongarch64")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mcpu=loongarch64 -mtune=loongarch64")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=loongarch64 -mtune=loongarch64")
   endif(HAS_LOONGARCH64)
 endif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
 
@@ -488,8 +488,6 @@ if(CMAKE_SYSTEM_NAME MATCHES "Cygwin")
   add_definitions(-fno-builtin-memcmp -DCYGWIN)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_definitions(-DOS_MACOSX)
-elseif(CMAKE_SYSTEM_NAME MATCHES "iOS")
-  add_definitions(-DOS_MACOSX -DIOS_CROSS_COMPILE)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
   add_definitions(-DOS_LINUX)
 elseif(CMAKE_SYSTEM_NAME MATCHES "SunOS")
@@ -617,7 +615,7 @@ if(USE_FOLLY)
     FMT_INST_PATH)
     exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../gflags* OUTPUT_VARIABLE
     GFLAGS_INST_PATH)
-    set(Boost_DIR ${BOOST_INST_PATH}/lib/cmake/Boost-1.83.0)
+    set(Boost_DIR ${BOOST_INST_PATH}/lib/cmake/Boost-1.78.0)
     if(EXISTS ${FMT_INST_PATH}/lib64)
       set(fmt_DIR ${FMT_INST_PATH}/lib64/cmake/fmt)
     else()
@@ -693,7 +691,6 @@ set(SOURCES
         db/db_impl/db_impl_write.cc
         db/db_impl/db_impl_compaction_flush.cc
         db/db_impl/db_impl_files.cc
-        db/db_impl/db_impl_follower.cc
         db/db_impl/db_impl_open.cc
         db/db_impl/db_impl_debug.cc
         db/db_impl/db_impl_experimental.cc
@@ -751,7 +748,6 @@ set(SOURCES
         env/env_encryption.cc
         env/file_system.cc
         env/file_system_tracer.cc
-        env/fs_on_demand.cc
         env/fs_remap.cc
         env/mock_env.cc
         env/unique_id_gen.cc
@@ -939,7 +935,6 @@ set(SOURCES
         utilities/persistent_cache/volatile_tier_impl.cc
         utilities/simulator_cache/cache_simulator.cc
         utilities/simulator_cache/sim_cache.cc
-        utilities/table_properties_collectors/compact_for_tiering_collector.cc
         utilities/table_properties_collectors/compact_on_deletion_collector.cc
         utilities/trace/file_trace_reader_writer.cc
         utilities/trace/replayer_impl.cc
@@ -1042,8 +1037,10 @@ endif()
 
 else()
   list(APPEND SOURCES
+    db/db_impl/db_impl_follower.cc
     port/port_posix.cc
     env/env_posix.cc
+    env/fs_on_demand.cc
     env/fs_posix.cc
     env/io_posix.cc)
 endif()
@@ -1052,7 +1049,6 @@ if(USE_FOLLY_LITE)
   list(APPEND SOURCES
     third-party/folly/folly/container/detail/F14Table.cpp
     third-party/folly/folly/detail/Futex.cpp
-    third-party/folly/folly/lang/Exception.cpp
     third-party/folly/folly/lang/SafeAssert.cpp
     third-party/folly/folly/lang/ToAscii.cpp
     third-party/folly/folly/ScopeGuard.cpp
@@ -1060,12 +1056,6 @@ if(USE_FOLLY_LITE)
     third-party/folly/folly/synchronization/DistributedMutex.cpp
     third-party/folly/folly/synchronization/ParkingLot.cpp)
   include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
-  exec_program(python3 ${PROJECT_SOURCE_DIR}/third-party/folly ARGS
-  build/fbcode_builder/getdeps.py show-source-dir boost OUTPUT_VARIABLE
-  BOOST_SOURCE_PATH)
-  exec_program(ls ARGS -d ${BOOST_SOURCE_PATH}/boost* OUTPUT_VARIABLE
-  BOOST_INCLUDE_DIR)
-  include_directories(${BOOST_INCLUDE_DIR})
   add_definitions(-DUSE_FOLLY -DFOLLY_NO_CONFIG)
   list(APPEND THIRDPARTY_LIBS glog)
 endif()
@@ -1489,7 +1479,6 @@ if(WITH_TESTS)
         utilities/persistent_cache/persistent_cache_test.cc
         utilities/simulator_cache/cache_simulator_test.cc
         utilities/simulator_cache/sim_cache_test.cc
-        utilities/table_properties_collectors/compact_for_tiering_collector_test.cc
         utilities/table_properties_collectors/compact_on_deletion_collector_test.cc
         utilities/transactions/optimistic_transaction_test.cc
         utilities/transactions/transaction_test.cc

HISTORY.md

@@ -1,135 +1,10 @@
 # Rocksdb Change Log
 > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`
 
-## 9.7.4 (10/31/2024)
-### Bug Fixes
-* Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
-
-## 9.7.3 (10/16/2024)
-### Behavior Changes
-* OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
-
-## 9.7.2 (10/08/2024)
-### Bug Fixes
-* Fix a bug for surfacing write unix time: `Iterator::GetProperty("rocksdb.iterator.write-time")` for non-L0 files.
-
-## 9.7.1 (09/26/2024)
-### Bug Fixes
-* Several DB option settings could be lost through `GetOptionsFromString()`, possibly elsewhere as well. Affected options, now fixed:`background_close_inactive_wals`, `write_dbid_to_manifest`, `write_identity_file`, `prefix_seek_opt_in_only`
-* Fix under counting of allocated memory in the compressed secondary cache due to looking at the compressed block size rather than the actual memory allocated, which could be larger due to internal fragmentation.
-* Skip insertion of compressed blocks in the secondary cache if the lowest_used_cache_tier DB option is kVolatileTier.
-
-## 9.7.0 (09/20/2024)
-### New Features
-* Make Cache a customizable class that can be instantiated by the object registry.
-* Add new option `prefix_seek_opt_in_only` that makes iterators generally safer when you might set a `prefix_extractor`. When `prefix_seek_opt_in_only=true`, which is expected to be the future default, prefix seek is only used when `prefix_same_as_start` or `auto_prefix_mode` are set. Also, `prefix_same_as_start` and `auto_prefix_mode` now allow prefix filtering even with `total_order_seek=true`.
-* Add a new table property "rocksdb.key.largest.seqno" which records the largest sequence number of all keys in file. It is verified to be zero during SST file ingestion.
-
-### Behavior Changes
-* Changed the semantics of the BlobDB configuration option `blob_garbage_collection_force_threshold` to define a threshold for the overall garbage ratio of all blob files currently eligible for garbage collection (according to `blob_garbage_collection_age_cutoff`). This can provide better control over space amplification at the cost of slightly higher write amplification.
-* Set `write_dbid_to_manifest=true` by default. This means DB ID will now be preserved through backups, checkpoints, etc. by default. Also add `write_identity_file` option which can be set to false for anticipated future behavior.
-* In FIFO compaction, compactions for changing file temperature (configured by option `file_temperature_age_thresholds`) will compact one file at a time, instead of merging multiple eligible file together (#13018).
-* Support ingesting db generated files using hard link, i.e. IngestExternalFileOptions::move_files/link_files and IngestExternalFileOptions::allow_db_generated_files.
-* Add a new file ingestion option `IngestExternalFileOptions::link_files` to hard link input files and preserve original files links after ingestion.
-* DB::Close now untracks files in SstFileManager, making avaialble any space used
-by them. Prior to this change they would be orphaned until the DB is re-opened.
-
-### Bug Fixes
-* Fix a bug in CompactRange() where result files may not be compacted in any future compaction. This can only happen when users configure CompactRangeOptions::change_level to true and the change level step of manual compaction fails (#13009).
-* Fix handling of dynamic change of `prefix_extractor` with memtable prefix filter. Previously, prefix seek could mix different prefix interpretations between memtable and SST files. Now the latest `prefix_extractor` at the time of iterator creation or refresh is respected.
-* Fix a bug with manual_wal_flush and auto error recovery from WAL failure that may cause CFs to be inconsistent (#12995). The fix will set potential WAL write failure as fatal error when manual_wal_flush is true, and disables auto error recovery from these errors.
-
-## 9.6.0 (08/19/2024)
-### New Features
-* *Best efforts recovery supports recovering to incomplete Version with a clean seqno cut that presents a valid point in time view from the user's perspective, if versioning history doesn't include atomic flush.
-* New option `BlockBasedTableOptions::decouple_partitioned_filters` should improve efficiency in serving read queries because filter and index partitions can consistently target the configured `metadata_block_size`. This option is currently opt-in.
-* Introduce a new mutable CF option `paranoid_memory_checks`. It enables additional validation on data integrity during reads/scanning. Currently, skip list based memtable will validate key ordering during look up and scans.
-
+## 9.2.1 (05/03/2024)
 ### Public API Changes
-* Add ticker stats to count file read retries due to checksum mismatch
-* Adds optional installation callback function for remote compaction
-
-### Behavior Changes
-* There may be less intra-L0 compaction triggered by total L0 size being too small. We now use compensated file size (tombstones are assigned some value size) when calculating L0 size and reduce the threshold for L0 size limit. This is to avoid accumulating too much data/tombstones in L0.
-
-### Bug Fixes
-* *Make DestroyDB supports slow deletion when it's configured in `SstFileManager`. The slow deletion is subject to the configured `rate_bytes_per_sec`, but not subject to the `max_trash_db_ratio`.
-* Fixed a bug where we set unprep_seqs_ even when WriteImpl() fails. This was caught by stress test write fault injection in WriteImpl(). This may have incorrectly caused iteration creation failure for unvalidated writes or returned wrong result for WriteUnpreparedTxn::GetUnpreparedSequenceNumbers().
-* Fixed a bug where successful write right after error recovery for last failed write finishes causes duplicate WAL entries
-* Fixed a data race involving the background error status in `unordered_write` mode.
-* *Fix a bug where file snapshot functions like backup, checkpoint may attempt to copy a non-existing manifest file. #12882
-* Fix a bug where per kv checksum corruption may be ignored in MultiGet().
-* Fix a race condition in pessimistic transactions that could allow multiple transactions with the same name to be registered simultaneously, resulting in a crash or other unpredictable behavior.
-
-## 9.5.0 (07/19/2024)
-### Public API Changes
-* Introduced new C API function rocksdb_writebatch_iterate_cf for column family-aware iteration over the contents of a WriteBatch
-* Add support to ingest SST files generated by a DB instead of SstFileWriter. This can be enabled with experimental option `IngestExternalFileOptions::allow_db_generated_files`.
-
-### Behavior Changes
-* When calculating total log size for the `log_size_for_flush` argument in `CreateCheckpoint` API, the size of the archived log will not be included to avoid unnecessary flush
-
-### Bug Fixes
-* Fix a major bug in which an iterator using prefix filtering and SeekForPrev might miss data when the DB is using `whole_key_filtering=false` and `partition_filters=true`.
-* Fixed a bug where `OnErrorRecoveryBegin()` is not called before auto recovery starts.
-* Fixed a bug where event listener reads ErrorHandler's `bg_error_` member without holding db mutex(#12803).
-* Fixed a bug in handling MANIFEST write error that caused the latest valid MANIFEST file to get deleted, resulting in the DB being unopenable.
-* Fixed a race between error recovery due to manifest sync or write failure and external SST file ingestion. Both attempt to write a new manifest file, which causes an assertion failure.
-
-### Performance Improvements
-* Fix an issue where compactions were opening table files and reading table properties while holding db mutex_.
-* Reduce unnecessary filesystem queries and DB mutex acquires in creating backups and checkpoints.
-
-## 9.4.0 (06/23/2024)
-### New Features
-* Added a `CompactForTieringCollectorFactory` to auto trigger compaction for tiering use case.
-* Optimistic transactions and pessimistic transactions with the WriteCommitted policy now support the `GetEntityForUpdate` API.
-* Added a new "count" command to the ldb repl shell. By default, it prints a count of keys in the database from start to end. The options --from=<key> and/or --to=<key> can be specified to limit the range.
-* Add `rocksdb_writebatch_update_timestamps`, `rocksdb_writebatch_wi_update_timestamps` in C API.
-* Add `rocksdb_iter_refresh` in C API.
-* Add `rocksdb_writebatch_create_with_params`, `rocksdb_writebatch_wi_create_with_params` to create WB and WBWI with all options in C API
-
-### Public API Changes
-* Deprecated names `LogFile` and `VectorLogPtr` in favor of new names `WalFile` and `VectorWalPtr`.
-* Introduce a new universal compaction option CompactionOptionsUniversal::max_read_amp which allows user to define the limit on the number of sorted runs separately from the trigger for compaction (`level0_file_num_compaction_trigger`) #12477.
-
-### Behavior Changes
-* Inactive WALs are immediately closed upon being fully sync-ed rather than in a background thread. This is to ensure LinkFile() is not called on files still open for write, which might not be supported by some FileSystem implementations. This should not be a performance issue, but an opt-out is available with with new DB option `background_close_inactive_wals`.
-
-### Bug Fixes
-* Fix a rare case in which a hard-linked WAL in a Checkpoint is not fully synced (so might lose data on power loss).
-* Fixed the output of the `ldb dump_wal` command for `PutEntity` records so it prints the key and correctly resets the hexadecimal formatting flag after printing the wide-column entity.
-* Fixed an issue where `PutEntity` records were handled incorrectly while rebuilding transactions during recovery.
-* Various read operations could ignore various ReadOptions that might be relevant. Fixed many such cases, which can result in behavior change but a better reflection of specified options.
-
-### Performance Improvements
-* Improved write throughput to memtable when there's a large number of concurrent writers and allow_concurrent_memtable_write=true(#12545)
-
-## 9.3.0 (05/17/2024)
-### New Features
-* Optimistic transactions and pessimistic transactions with the WriteCommitted policy now support the `GetEntity` API.
-* Added new `Iterator` property, "rocksdb.iterator.is-value-pinned", for checking whether the `Slice` returned by `Iterator::value()` can be used until the `Iterator` is destroyed.
-* Optimistic transactions and WriteCommitted pessimistic transactions now support the `MultiGetEntity` API.
-* Optimistic transactions and pessimistic transactions with the WriteCommitted policy now support the `PutEntity` API. Support for read APIs and other write policies (WritePrepared, WriteUnprepared) will be added later.
-
-### Public API Changes
-* Exposed block based metadata cache options via C API
-* Exposed compaction pri via c api.
 * Add a kAdmPolicyAllowAll option to TieredAdmissionPolicy that admits all blocks evicted from the primary block cache into the compressed secondary cache.
 
-### Behavior Changes
-* CompactRange() with change_level=true on a CF with FIFO compaction will return Status::NotSupported().
-* External file ingestion with FIFO compaction will always ingest to L0.
-
-### Bug Fixes
-* Fixed a bug for databases using `DBOptions::allow_2pc == true` (all `TransactionDB`s except `OptimisticTransactionDB`) that have exactly one column family. Due to a missing WAL sync, attempting to open the DB could have returned a `Status::Corruption` with a message like "SST file is ahead of WALs".
-* Fix a bug in CreateColumnFamilyWithImport() where if multiple CFs are imported, we were not resetting files' epoch number and L0 files can have overlapping key range but the same epoch number.
-* Fixed race conditions when `ColumnFamilyOptions::inplace_update_support == true` between user overwrites and reads on the same key.
-* Fix a bug where `CompactFiles()` can compact files of range conflict with other ongoing compactions' when `preclude_last_level_data_seconds > 0` is used
-* Fixed a false positive `Status::Corruption` reported when reopening a DB that used `DBOptions::recycle_log_file_num > 0` and `DBOptions::wal_compression != kNoCompression`.
-* While WAL is locked with LockWAL(), some operations like Flush() and IngestExternalFile() are now blocked as they should have been.
-* Fixed a bug causing stale memory access when using the TieredSecondaryCache with an NVM secondary cache, and a file system that supports return an FS allocated buffer for MultiRead (FSSupportedOps::kFSBuffer is set).
-
 ## 9.2.0 (05/01/2024)
 ### New Features
 * Added two options `deadline` and `max_size_bytes` for CacheDumper to exit early

Makefile

@@ -103,7 +103,6 @@ dummy := $(shell (export ROCKSDB_ROOT="$(CURDIR)"; \
                   export LIB_MODE="$(LIB_MODE)"; \
 		  export ROCKSDB_CXX_STANDARD="$(ROCKSDB_CXX_STANDARD)"; \
 		  export USE_FOLLY="$(USE_FOLLY)"; \
-		  export USE_FOLLY_LITE="$(USE_FOLLY_LITE)"; \
                   "$(CURDIR)/build_tools/build_detect_platform" "$(CURDIR)/make_config.mk"))
 # this file is generated by the previous line to set build flags and sources
 include make_config.mk
@@ -501,17 +500,6 @@ endif
 ifeq ($(USE_FOLLY_LITE),1)
 	# Path to the Folly source code and include files
 	FOLLY_DIR = ./third-party/folly
-ifneq ($(strip $(BOOST_SOURCE_PATH)),)
-	BOOST_INCLUDE = $(shell (ls -d $(BOOST_SOURCE_PATH)/boost*/))
-	# AIX: pre-defined system headers are surrounded by an extern "C" block
-	ifeq ($(PLATFORM), OS_AIX)
-		PLATFORM_CCFLAGS += -I$(BOOST_INCLUDE)
-		PLATFORM_CXXFLAGS += -I$(BOOST_INCLUDE)
-	else
-		PLATFORM_CCFLAGS += -isystem $(BOOST_INCLUDE)
-		PLATFORM_CXXFLAGS += -isystem $(BOOST_INCLUDE)
-	endif
-endif  # BOOST_SOURCE_PATH
 	# AIX: pre-defined system headers are surrounded by an extern "C" block
 	ifeq ($(PLATFORM), OS_AIX)
 		PLATFORM_CCFLAGS += -I$(FOLLY_DIR)
@@ -630,11 +618,6 @@ VALGRIND_VER := $(join $(VALGRIND_VER),valgrind)
 VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full
 # Not yet supported: --show-leak-kinds=definite,possible,reachable --errors-for-leak-kinds=definite,possible,reachable
 
-# Work around valgrind hanging on systems with limited internet access
-ifneq ($(shell which git 2>/dev/null && git config --get https.proxy),)
-  export DEBUGINFOD_URLS=
-endif
-
 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))
@@ -653,37 +636,26 @@ TESTS = $(patsubst %.cc, %, $(notdir $(TEST_MAIN_SOURCES)))
 TESTS += $(patsubst %.c, %, $(notdir $(TEST_MAIN_SOURCES_C)))
 TESTS += $(PLUGIN_TESTS)
 
-# `make check-headers` to verify that each header file includes its own deps
-# and that public headers do not depend on internal headers
+# `make check-headers` to very that each header file includes its own
+# dependencies
 ifneq ($(filter check-headers, $(MAKECMDGOALS)),)
 # TODO: add/support JNI headers
 	DEV_HEADER_DIRS := $(sort include/ $(dir $(ALL_SOURCES)))
 # Some headers like in port/ are platform-specific
-	DEV_HEADERS_TO_CHECK := $(shell $(FIND) $(DEV_HEADER_DIRS) -type f -name '*.h' | grep -E -v 'port/|plugin/|lua/|range_tree/')
-	PUBLIC_HEADERS_TO_CHECK := $(shell $(FIND) include/ -type f -name '*.h' | grep -E -v 'lua/')
+	DEV_HEADERS := $(shell $(FIND) $(DEV_HEADER_DIRS) -type f -name '*.h' | grep -E -v 'port/|plugin/|lua/|range_tree/')
 else
-	DEV_HEADERS_TO_CHECK :=
-	PUBLIC_HEADERS_TO_CHECK :=
+	DEV_HEADERS :=
 endif
-HEADER_OK_FILES = $(patsubst %.h, %.h.ok, $(DEV_HEADERS_TO_CHECK)) \
-	$(patsubst %.h, %.h.pub, $(PUBLIC_HEADERS_TO_CHECK))
+HEADER_OK_FILES = $(patsubst %.h, %.h.ok, $(DEV_HEADERS))
 
 AM_V_CCH = $(am__v_CCH_$(V))
 am__v_CCH_ = $(am__v_CCH_$(AM_DEFAULT_VERBOSITY))
 am__v_CCH_0 = @echo "  CC.h    " $<;
 am__v_CCH_1 =
 
-# verify headers include their own dependencies, under dev build settings
 %.h.ok: %.h # .h.ok not actually created, so re-checked on each invocation
 # -DROCKSDB_NAMESPACE=42 ensures the namespace header is included
-	$(AM_V_CCH) echo '#include "$<"' | $(CXX) $(CXXFLAGS) \
-	  -DROCKSDB_NAMESPACE=42 -x c++ -c - -o /dev/null
-
-# verify public headers do not depend on internal headers, under typical
-# user build settings
-%.h.pub: %.h # .h.pub not actually created, so re-checked on each invocation
-	$(AM_V_CCH) cd include/ && echo '#include "$(patsubst include/%,%,$<)"' | \
-	  $(CXX) -I. -DROCKSDB_NAMESPACE=42 -x c++ -c - -o /dev/null
+	$(AM_V_CCH) echo '#include "$<"' | $(CXX) $(CXXFLAGS) -DROCKSDB_NAMESPACE=42 -x c++ -c - -o /dev/null
 
 check-headers: $(HEADER_OK_FILES)
 
@@ -1169,16 +1141,16 @@ ubsan_crash_test_with_best_efforts_recovery: clean
 	$(MAKE) clean
 
 full_valgrind_test:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check
+	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
 
 full_valgrind_test_some:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check_some
+	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some
 
 valgrind_test:
-	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check
+	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
 
 valgrind_test_some:
-	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 PORTABLE=1 $(MAKE) valgrind_check_some
+	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some
 
 valgrind_check: $(TESTS)
 	$(MAKE) DRIVER="$(VALGRIND_VER) $(VALGRIND_OPTS)" gen_parallel_tests
@@ -1659,9 +1631,6 @@ compaction_job_stats_test: $(OBJ_DIR)/db/compaction/compaction_job_stats_test.o
 compaction_service_test: $(OBJ_DIR)/db/compaction/compaction_service_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-compact_for_tiering_collector_test: $(OBJ_DIR)/utilities/table_properties_collectors/compact_for_tiering_collector_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 compact_on_deletion_collector_test: $(OBJ_DIR)/utilities/table_properties_collectors/compact_on_deletion_collector_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -2144,8 +2113,8 @@ ZLIB_DOWNLOAD_BASE ?= http://zlib.net
 BZIP2_VER ?= 1.0.8
 BZIP2_SHA256 ?= ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269
 BZIP2_DOWNLOAD_BASE ?= http://sourceware.org/pub/bzip2
-SNAPPY_VER ?= 1.2.1
-SNAPPY_SHA256 ?= 736aeb64d86566d2236ddffa2865ee5d7a82d26c9016b36218fcc27ea4f09f86
+SNAPPY_VER ?= 1.1.8
+SNAPPY_SHA256 ?= 16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f
 SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
 LZ4_VER ?= 1.9.4
 LZ4_SHA256 ?= 0b0e3aa07c8c063ddf40b082bdf7e37a1562bda40a0ff5272957f3e987e0e54b
@@ -2242,7 +2211,7 @@ libsnappy.a: snappy-$(SNAPPY_VER).tar.gz
 	-rm -rf snappy-$(SNAPPY_VER)
 	tar xvzf snappy-$(SNAPPY_VER).tar.gz
 	mkdir snappy-$(SNAPPY_VER)/build
-	cd snappy-$(SNAPPY_VER)/build && CFLAGS='$(ARCHFLAG) ${JAVA_STATIC_DEPS_CCFLAGS} ${EXTRA_CFLAGS}' CXXFLAGS='$(ARCHFLAG) ${JAVA_STATIC_DEPS_CXXFLAGS} ${EXTRA_CXXFLAGS}' LDFLAGS='${JAVA_STATIC_DEPS_LDFLAGS} ${EXTRA_LDFLAGS}' cmake -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DSNAPPY_BUILD_BENCHMARKS=OFF -DSNAPPY_BUILD_TESTS=OFF --compile-no-warning-as-error ${PLATFORM_CMAKE_FLAGS} .. && $(MAKE) ${SNAPPY_MAKE_TARGET}
+	cd snappy-$(SNAPPY_VER)/build && CFLAGS='$(ARCHFLAG) ${JAVA_STATIC_DEPS_CCFLAGS} ${EXTRA_CFLAGS}' CXXFLAGS='$(ARCHFLAG) ${JAVA_STATIC_DEPS_CXXFLAGS} ${EXTRA_CXXFLAGS}' LDFLAGS='${JAVA_STATIC_DEPS_LDFLAGS} ${EXTRA_LDFLAGS}' cmake -DCMAKE_POSITION_INDEPENDENT_CODE=ON ${PLATFORM_CMAKE_FLAGS} .. && $(MAKE) ${SNAPPY_MAKE_TARGET}
 	cp snappy-$(SNAPPY_VER)/build/libsnappy.a .
 
 lz4-$(LZ4_VER).tar.gz:
@@ -2489,13 +2458,14 @@ checkout_folly:
 	fi
 	@# Pin to a particular version for public CI, so that PR authors don't
 	@# need to worry about folly breaking our integration. Update periodically
-	cd third-party/folly && git reset --hard 03041f014b6e6ebb6119ffae8b7a37308f52e913
+	cd third-party/folly && git reset --hard beacd86d63cd71c904632262e6c36f60874d78ba
+	@# A hack to remove boost dependency.
+	@# NOTE: this hack is only needed if building using USE_FOLLY_LITE
+	perl -pi -e 's/^(#include <boost)/\/\/$$1/' third-party/folly/folly/functional/Invoke.h
 	@# NOTE: this hack is required for clang in some cases
 	perl -pi -e 's/int rv = syscall/int rv = (int)syscall/' third-party/folly/folly/detail/Futex.cpp
 	@# NOTE: this hack is required for gcc in some cases
 	perl -pi -e 's/(__has_include.<experimental.memory_resource>.)/__cpp_rtti && $$1/' third-party/folly/folly/memory/MemoryResource.h
-	@# NOTE: boost source will be needed for any build including `USE_FOLLY_LITE` builds as those depend on boost headers
-	cd third-party/folly && $(PYTHON) build/fbcode_builder/getdeps.py fetch boost
 
 CXX_M_FLAGS = $(filter -m%, $(CXXFLAGS))
 
@@ -2507,6 +2477,8 @@ build_folly:
 		echo "Please run checkout_folly first"; \
 		false; \
 	fi
+	# Restore the original version of Invoke.h with boost dependency
+	cd third-party/folly && ${GIT_COMMAND} checkout folly/functional/Invoke.h
 	cd third-party/folly && \
 		CXXFLAGS=" $(CXX_M_FLAGS) -DHAVE_CXX11_ATOMIC " $(PYTHON) build/fbcode_builder/getdeps.py build --no-tests
 

TARGETS

@@ -4,7 +4,6 @@
 # This file is a Facebook-specific integration for buck builds, so can
 # only be validated by Facebook employees.
 load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrapper","cpp_binary_wrapper","cpp_unittest_wrapper","fancy_bench_wrapper","add_c_test_wrapper")
-load("@fbcode_macros//build_defs:export_files.bzl", "export_file")
 
 
 cpp_library_wrapper(name="rocksdb_lib", srcs=[
@@ -317,7 +316,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "utilities/persistent_cache/volatile_tier_impl.cc",
         "utilities/simulator_cache/cache_simulator.cc",
         "utilities/simulator_cache/sim_cache.cc",
-        "utilities/table_properties_collectors/compact_for_tiering_collector.cc",
         "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
         "utilities/trace/file_trace_reader_writer.cc",
         "utilities/trace/replayer_impl.cc",
@@ -362,9 +360,9 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "//folly/experimental/coro:coroutine",
         "//folly/experimental/coro:task",
         "//folly/synchronization:distributed_mutex",
-    ], headers=glob(["**/*.h"]), link_whole=False, extra_test_libs=False)
+    ], headers=None, link_whole=False, extra_test_libs=False)
 
-cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[], deps=[":rocksdb_lib"], headers=[], link_whole=True, extra_test_libs=False)
+cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[], deps=[":rocksdb_lib"], headers=None, link_whole=True, extra_test_libs=False)
 
 cpp_library_wrapper(name="rocksdb_test_lib", srcs=[
         "db/db_test_util.cc",
@@ -378,7 +376,7 @@ cpp_library_wrapper(name="rocksdb_test_lib", srcs=[
         "tools/trace_analyzer_tool.cc",
         "utilities/agg_merge/test_agg_merge.cc",
         "utilities/cassandra/test_utils.cc",
-    ], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=True)
+    ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=True)
 
 cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[
         "test_util/testutil.cc",
@@ -386,16 +384,15 @@ cpp_library_wrapper(name="rocksdb_tools_lib", srcs=[
         "tools/db_bench_tool.cc",
         "tools/simulated_hybrid_file_system.cc",
         "tools/trace_analyzer_tool.cc",
-    ], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=False)
+    ], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)
 
-cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=[], link_whole=False, extra_test_libs=False)
+cpp_library_wrapper(name="rocksdb_cache_bench_tools_lib", srcs=["cache/cache_bench_tool.cc"], deps=[":rocksdb_lib"], headers=None, link_whole=False, extra_test_libs=False)
 
 rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
         "db_stress_tool/batched_ops_stress.cc",
         "db_stress_tool/cf_consistency_stress.cc",
         "db_stress_tool/db_stress_common.cc",
         "db_stress_tool/db_stress_driver.cc",
-        "db_stress_tool/db_stress_filters.cc",
         "db_stress_tool/db_stress_gflags.cc",
         "db_stress_tool/db_stress_listener.cc",
         "db_stress_tool/db_stress_shared_state.cc",
@@ -410,15 +407,11 @@ rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
         "test_util/testutil.cc",
         "tools/block_cache_analyzer/block_cache_trace_analyzer.cc",
         "tools/trace_analyzer_tool.cc",
-    ], headers=[])
+    ], headers=None)
 
 
-cpp_binary_wrapper(name="ldb", srcs=["tools/ldb.cc"], deps=[":rocksdb_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
-
 cpp_binary_wrapper(name="db_stress", srcs=["db_stress_tool/db_stress.cc"], deps=[":rocksdb_stress_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
 
-cpp_binary_wrapper(name="db_bench", srcs=["tools/db_bench.cc"], deps=[":rocksdb_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
-
 cpp_binary_wrapper(name="cache_bench", srcs=["cache/cache_bench.cc"], deps=[":rocksdb_cache_bench_tools_lib"], extra_preprocessor_flags=[], extra_bench_libs=False)
 
 cpp_binary_wrapper(name="ribbon_bench", srcs=["microbench/ribbon_bench.cc"], deps=[], extra_preprocessor_flags=[], extra_bench_libs=True)
@@ -4630,12 +4623,6 @@ cpp_unittest_wrapper(name="compact_files_test",
             extra_compiler_flags=[])
 
 
-cpp_unittest_wrapper(name="compact_for_tiering_collector_test",
-            srcs=["utilities/table_properties_collectors/compact_for_tiering_collector_test.cc"],
-            deps=[":rocksdb_test_lib"],
-            extra_compiler_flags=[])
-
-
 cpp_unittest_wrapper(name="compact_on_deletion_collector_test",
             srcs=["utilities/table_properties_collectors/compact_on_deletion_collector_test.cc"],
             deps=[":rocksdb_test_lib"],
@@ -5026,7 +5013,7 @@ cpp_unittest_wrapper(name="dynamic_bloom_test",
             extra_compiler_flags=[])
 
 
-cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=[], link_whole=False, extra_test_libs=True)
+cpp_library_wrapper(name="env_basic_test_lib", srcs=["env/env_basic_test.cc"], deps=[":rocksdb_test_lib"], headers=None, link_whole=False, extra_test_libs=True)
 
 cpp_unittest_wrapper(name="env_basic_test",
             srcs=["env/env_basic_test.cc"],

buckifier/buckify_rocksdb.py

@@ -11,7 +11,7 @@ import json
 import os
 import sys
 
-from targets_builder import TARGETSBuilder, LiteralValue
+from targets_builder import TARGETSBuilder
 
 from util import ColorString
 
@@ -150,7 +150,6 @@ def generate_targets(repo_path, deps_map):
             "//folly/experimental/coro:task",
             "//folly/synchronization:distributed_mutex",
         ],
-        headers=LiteralValue("glob([\"**/*.h\"])")
     )
     # rocksdb_whole_archive_lib
     TARGETS.add_library(
@@ -159,6 +158,7 @@ def generate_targets(repo_path, deps_map):
         deps=[
             ":rocksdb_lib",
         ],
+        headers=None,
         extra_external_deps="",
         link_whole=True,
     )
@@ -193,18 +193,10 @@ def generate_targets(repo_path, deps_map):
         + src_mk.get("STRESS_LIB_SOURCES", [])
         + ["test_util/testutil.cc"],
     )
-    # ldb binary
-    TARGETS.add_binary(
-        "ldb", ["tools/ldb.cc"], [":rocksdb_tools_lib"]
-    )
     # db_stress binary
     TARGETS.add_binary(
         "db_stress", ["db_stress_tool/db_stress.cc"], [":rocksdb_stress_lib"]
     )
-    # db_bench binary
-    TARGETS.add_binary(
-        "db_bench", ["tools/db_bench.cc"], [":rocksdb_tools_lib"]
-    )
     # cache_bench binary
     TARGETS.add_binary(
         "cache_bench", ["cache/cache_bench.cc"], [":rocksdb_cache_bench_tools_lib"]

buckifier/targets_builder.py

@@ -9,28 +9,17 @@ import pprint
 
 import targets_cfg
 
-class LiteralValue:
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return str(self.value)
-
-def smart_quote_value(val):
-    if isinstance(val, LiteralValue):
-        return str(val)
-    return '"%s"' % val
 
 def pretty_list(lst, indent=8):
     if lst is None or len(lst) == 0:
         return ""
 
     if len(lst) == 1:
-        return smart_quote_value(lst[0])
+        return '"%s"' % lst[0]
 
-    separator = ',\n%s' % (" " * indent)
-    res = separator.join(sorted(map(smart_quote_value, lst)))
-    res = "\n" + (" " * indent) + res + ',\n' + (" " * (indent - 4))
+    separator = '",\n%s"' % (" " * indent)
+    res = separator.join(sorted(lst))
+    res = "\n" + (" " * indent) + '"' + res + '",\n' + (" " * (indent - 4))
     return res
 
 
@@ -59,12 +48,7 @@ class TARGETSBuilder:
         extra_test_libs=False,
     ):
         if headers is not None:
-            if isinstance(headers, LiteralValue):
-                headers = str(headers)
-            else:
-                headers = "[" + pretty_list(headers) + "]"
-        else:
-            headers = "[]"
+            headers = "[" + pretty_list(headers) + "]"
         with open(self.path, "ab") as targets_file:
             targets_file.write(
                 targets_cfg.library_template.format(
@@ -81,7 +65,8 @@ class TARGETSBuilder:
         self.total_lib = self.total_lib + 1
 
     def add_rocksdb_library(self, name, srcs, headers=None, external_dependencies=None):
-        headers = "[" + pretty_list(headers) + "]"
+        if headers is not None:
+            headers = "[" + pretty_list(headers) + "]"
         with open(self.path, "ab") as targets_file:
             targets_file.write(
                 targets_cfg.rocksdb_library_template.format(

buckifier/targets_cfg.py

@@ -7,7 +7,6 @@ rocksdb_target_header_template = """# This file \100generated by:
 # This file is a Facebook-specific integration for buck builds, so can
 # only be validated by Facebook employees.
 load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrapper","cpp_binary_wrapper","cpp_unittest_wrapper","fancy_bench_wrapper","add_c_test_wrapper")
-load("@fbcode_macros//build_defs:export_files.bzl", "export_file")
 
 """
 

build_tools/build_detect_platform

@@ -585,7 +585,7 @@ EOF
             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbenchmark"
         fi
     fi
-    if test $USE_FOLLY || test $USE_FOLLY_LITE; then
+    if test $USE_FOLLY; then
         # Test whether libfolly library is installed
         $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <folly/synchronization/DistributedMutex.h>
@@ -751,11 +751,6 @@ if [ "$USE_FOLLY" ]; then
     FOLLY_PATH=`cd $FOLLY_DIR && $PYTHON build/fbcode_builder/getdeps.py show-inst-dir folly`
   fi
 fi
-if [ "$USE_FOLLY_LITE" ]; then
-  if [ "$FOLLY_DIR" ]; then
-    BOOST_SOURCE_PATH=`cd $FOLLY_DIR && $PYTHON build/fbcode_builder/getdeps.py show-source-dir boost`
-  fi
-fi
 
 PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"
@@ -797,7 +792,6 @@ echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
 echo "FIND=$FIND" >> "$OUTPUT"
 echo "WATCH=$WATCH" >> "$OUTPUT"
 echo "FOLLY_PATH=$FOLLY_PATH" >> "$OUTPUT"
-echo "BOOST_SOURCE_PATH=$BOOST_SOURCE_PATH" >> "$OUTPUT"
 
 # This will enable some related identifiers for the preprocessor
 if test -n "$JEMALLOC"; then

cache/cache.cc

@@ -133,23 +133,19 @@ Status Cache::CreateFromString(const ConfigOptions& config_options,
                                std::shared_ptr<Cache>* result) {
   Status status;
   std::shared_ptr<Cache> cache;
-  if (value.find("://") == std::string::npos) {
-    if (value.find('=') == std::string::npos) {
-      cache = NewLRUCache(ParseSizeT(value));
-    } else {
-      LRUCacheOptions cache_opts;
-      status = OptionTypeInfo::ParseStruct(config_options, "",
-                                           &lru_cache_options_type_info, "",
-                                           value, &cache_opts);
-      if (status.ok()) {
-        cache = NewLRUCache(cache_opts);
-      }
-    }
-    if (status.ok()) {
-      result->swap(cache);
-    }
+  if (value.find('=') == std::string::npos) {
+    cache = NewLRUCache(ParseSizeT(value));
   } else {
-    status = LoadSharedObject<Cache>(config_options, value, result);
+    LRUCacheOptions cache_opts;
+    status = OptionTypeInfo::ParseStruct(config_options, "",
+                                         &lru_cache_options_type_info, "",
+                                         value, &cache_opts);
+    if (status.ok()) {
+      cache = NewLRUCache(cache_opts);
+    }
+  }
+  if (status.ok()) {
+    result->swap(cache);
   }
   return status;
 }

cache/cache_test.cc

@@ -18,7 +18,6 @@
 #include "cache/lru_cache.h"
 #include "cache/typed_cache.h"
 #include "port/stack_trace.h"
-#include "table/block_based/block_cache.h"
 #include "test_util/secondary_cache_test_util.h"
 #include "test_util/testharness.h"
 #include "util/coding.h"
@@ -886,32 +885,6 @@ TEST_P(CacheTest, ApplyToAllEntriesDuringResize) {
   ASSERT_EQ(special_count, kSpecialCount);
 }
 
-TEST_P(CacheTest, ApplyToHandleTest) {
-  std::string callback_state;
-  const auto callback = [&](const Slice& key, Cache::ObjectPtr value,
-                            size_t charge,
-                            const Cache::CacheItemHelper* helper) {
-    callback_state = std::to_string(DecodeKey(key)) + "," +
-                     std::to_string(DecodeValue(value)) + "," +
-                     std::to_string(charge);
-    assert(helper == &CacheTest::kHelper);
-  };
-
-  std::vector<std::string> inserted;
-
-  for (int i = 0; i < 10; ++i) {
-    Insert(i, i * 2, i + 1);
-    inserted.push_back(std::to_string(i) + "," + std::to_string(i * 2) + "," +
-                       std::to_string(i + 1));
-  }
-  for (int i = 0; i < 10; ++i) {
-    Cache::Handle* handle = cache_->Lookup(EncodeKey(i));
-    cache_->ApplyToHandle(cache_.get(), handle, callback);
-    EXPECT_EQ(inserted[i], callback_state);
-    cache_->Release(handle);
-  }
-}
-
 TEST_P(CacheTest, DefaultShardBits) {
   // Prevent excessive allocation (to save time & space)
   estimated_value_size_ = 100000;
@@ -1044,63 +1017,6 @@ INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest,
                         testing::Values(secondary_cache_test_util::kLRU));
 
-TEST(MiscBlockCacheTest, UncacheAggressivenessAdvisor) {
-  // Aggressiveness to a sequence of Report() calls (as string of 0s and 1s)
-  // exactly until the first ShouldContinue() == false.
-  const std::vector<std::pair<uint32_t, Slice>> expectedTraces{
-      // Aggressiveness 1 aborts on first unsuccessful erasure.
-      {1, "0"},
-      {1, "11111111111111111111110"},
-      // For sufficient evidence, aggressiveness 2 requires a minimum of two
-      // unsuccessful erasures.
-      {2, "00"},
-      {2, "0110"},
-      {2, "1100"},
-      {2, "011111111111111111111111111111111111111111111111111111111111111100"},
-      {2, "0111111111111111111111111111111111110"},
-      // For sufficient evidence, aggressiveness 3 and higher require a minimum
-      // of three unsuccessful erasures.
-      {3, "000"},
-      {3, "01010"},
-      {3, "111000"},
-      {3, "00111111111111111111111111111111111100"},
-      {3, "00111111111111111111110"},
-
-      {4, "000"},
-      {4, "01010"},
-      {4, "111000"},
-      {4, "001111111111111111111100"},
-      {4, "0011111111111110"},
-
-      {6, "000"},
-      {6, "01010"},
-      {6, "111000"},
-      {6, "00111111111111100"},
-      {6, "0011111110"},
-
-      // 69 -> 50% threshold, now up to minimum of 4
-      {69, "0000"},
-      {69, "010000"},
-      {69, "01010000"},
-      {69, "101010100010101000"},
-
-      // 230 -> 10% threshold, appropriately higher minimum
-      {230, "000000000000"},
-      {230, "0000000000010000000000"},
-      {230, "00000000000100000000010000000000"}};
-  for (const auto& [aggressiveness, t] : expectedTraces) {
-    SCOPED_TRACE("aggressiveness=" + std::to_string(aggressiveness) + " with " +
-                 t.ToString());
-    UncacheAggressivenessAdvisor uaa(aggressiveness);
-    for (size_t i = 0; i < t.size(); ++i) {
-      SCOPED_TRACE("i=" + std::to_string(i));
-      ASSERT_TRUE(uaa.ShouldContinue());
-      uaa.Report(t[i] & 1);
-    }
-    ASSERT_FALSE(uaa.ShouldContinue());
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

cache/clock_cache.cc

@@ -1444,22 +1444,6 @@ const Cache::CacheItemHelper* BaseHyperClockCache<Table>::GetCacheItemHelper(
   return h->helper;
 }
 
-template <class Table>
-void BaseHyperClockCache<Table>::ApplyToHandle(
-    Cache* cache, Handle* handle,
-    const std::function<void(const Slice& key, Cache::ObjectPtr value,
-                             size_t charge, const CacheItemHelper* helper)>&
-        callback) {
-  BaseHyperClockCache<Table>* cache_ptr =
-      static_cast<BaseHyperClockCache<Table>*>(cache);
-  auto h = static_cast<const typename Table::HandleImpl*>(handle);
-  UniqueId64x2 unhashed;
-  auto hash_seed = cache_ptr->GetShard(h->GetHash()).GetTable().GetHashSeed();
-  callback(
-      ClockCacheShard<Table>::ReverseHash(h->hashed_key, &unhashed, hash_seed),
-      h->value, h->GetTotalCharge(), h->helper);
-}
-
 namespace {
 
 // For each cache shard, estimate what the table load factor would be if

cache/clock_cache.h

@@ -1128,12 +1128,6 @@ class BaseHyperClockCache : public ShardedCache<ClockCacheShard<Table>> {
 
   const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
 
-  void ApplyToHandle(
-      Cache* cache, Handle* handle,
-      const std::function<void(const Slice& key, Cache::ObjectPtr obj,
-                               size_t charge, const CacheItemHelper* helper)>&
-          callback) override;
-
   void ReportProblems(
       const std::shared_ptr<Logger>& /*info_log*/) const override;
 };

cache/compressed_secondary_cache.cc

@@ -79,11 +79,7 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
     data_ptr = GetVarint32Ptr(data_ptr, data_ptr + 1,
                               static_cast<uint32_t*>(&source_32));
     source = static_cast<CacheTier>(source_32);
-    uint64_t data_size = 0;
-    data_ptr = GetVarint64Ptr(data_ptr, ptr->get() + handle_value_charge,
-                              static_cast<uint64_t*>(&data_size));
-    assert(handle_value_charge > data_size);
-    handle_value_charge = data_size;
+    handle_value_charge -= (data_ptr - ptr->get());
   }
   MemoryAllocator* allocator = cache_options_.memory_allocator.get();
 
@@ -173,15 +169,13 @@ Status CompressedSecondaryCache::InsertInternal(
   }
 
   auto internal_helper = GetHelper(cache_options_.enable_custom_split_merge);
-  char header[20];
+  char header[10];
   char* payload = header;
   payload = EncodeVarint32(payload, static_cast<uint32_t>(type));
   payload = EncodeVarint32(payload, static_cast<uint32_t>(source));
-  size_t data_size = (*helper->size_cb)(value);
-  char* data_size_ptr = payload;
-  payload = EncodeVarint64(payload, data_size);
 
   size_t header_size = payload - header;
+  size_t data_size = (*helper->size_cb)(value);
   size_t total_size = data_size + header_size;
   CacheAllocationPtr ptr =
       AllocateBlock(total_size, cache_options_.memory_allocator.get());
@@ -216,8 +210,6 @@ Status CompressedSecondaryCache::InsertInternal(
 
     val = Slice(compressed_val);
     data_size = compressed_val.size();
-    payload = EncodeVarint64(data_size_ptr, data_size);
-    header_size = payload - header;
     total_size = header_size + data_size;
     PERF_COUNTER_ADD(compressed_sec_cache_compressed_bytes, data_size);
 
@@ -230,21 +222,14 @@ Status CompressedSecondaryCache::InsertInternal(
 
   PERF_COUNTER_ADD(compressed_sec_cache_insert_real_count, 1);
   if (cache_options_.enable_custom_split_merge) {
-    size_t split_charge{0};
-    CacheValueChunk* value_chunks_head = SplitValueIntoChunks(
-        val, cache_options_.compression_type, split_charge);
-    return cache_->Insert(key, value_chunks_head, internal_helper,
-                          split_charge);
+    size_t charge{0};
+    CacheValueChunk* value_chunks_head =
+        SplitValueIntoChunks(val, cache_options_.compression_type, charge);
+    return cache_->Insert(key, value_chunks_head, internal_helper, charge);
   } else {
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-    size_t charge = malloc_usable_size(ptr.get());
-#else
-    size_t charge = total_size;
-#endif
     std::memcpy(ptr.get(), header, header_size);
     CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    charge += sizeof(CacheAllocationPtr);
-    return cache_->Insert(key, buf, internal_helper, charge);
+    return cache_->Insert(key, buf, internal_helper, total_size);
   }
 }
 
@@ -413,21 +398,6 @@ const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
   }
 }
 
-size_t CompressedSecondaryCache::TEST_GetCharge(const Slice& key) {
-  Cache::Handle* lru_handle = cache_->Lookup(key);
-  if (lru_handle == nullptr) {
-    return 0;
-  }
-
-  size_t charge = cache_->GetCharge(lru_handle);
-  if (cache_->Value(lru_handle) != nullptr &&
-      !cache_options_.enable_custom_split_merge) {
-    charge -= 10;
-  }
-  cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  return charge;
-}
-
 std::shared_ptr<SecondaryCache>
 CompressedSecondaryCacheOptions::MakeSharedSecondaryCache() const {
   return std::make_shared<CompressedSecondaryCache>(*this);

cache/compressed_secondary_cache.h

@@ -139,8 +139,6 @@ class CompressedSecondaryCache : public SecondaryCache {
                         const Cache::CacheItemHelper* helper,
                         CompressionType type, CacheTier source);
 
-  size_t TEST_GetCharge(const Slice& key);
-
   // TODO: clean up to use cleaner interfaces in typed_cache.h
   const Cache::CacheItemHelper* GetHelper(bool enable_custom_split_merge) const;
   std::shared_ptr<Cache> cache_;

cache/compressed_secondary_cache_test.cc

@@ -39,8 +39,6 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
  protected:
   void BasicTestHelper(std::shared_ptr<SecondaryCache> sec_cache,
                        bool sec_cache_is_compressed) {
-    CompressedSecondaryCache* comp_sec_cache =
-        static_cast<CompressedSecondaryCache*>(sec_cache.get());
     get_perf_context()->Reset();
     bool kept_in_sec_cache{true};
     // Lookup an non-existent key.
@@ -68,8 +66,6 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
     ASSERT_OK(sec_cache->Insert(key1, &item1, GetHelper(), false));
     ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 1);
 
-    ASSERT_GT(comp_sec_cache->TEST_GetCharge(key1), 1000);
-
     std::unique_ptr<SecondaryCacheResultHandle> handle1_2 =
         sec_cache->Lookup(key1, GetHelper(), this, true, /*advise_erase=*/true,
                           /*stats=*/nullptr, kept_in_sec_cache);

cache/lru_cache.cc

@@ -677,17 +677,6 @@ const Cache::CacheItemHelper* LRUCache::GetCacheItemHelper(
   return h->helper;
 }
 
-void LRUCache::ApplyToHandle(
-    Cache* cache, Handle* handle,
-    const std::function<void(const Slice& key, ObjectPtr value, size_t charge,
-                             const CacheItemHelper* helper)>& callback) {
-  auto cache_ptr = static_cast<LRUCache*>(cache);
-  auto h = static_cast<const LRUHandle*>(handle);
-  callback(h->key(), h->value,
-           h->GetCharge(cache_ptr->GetShard(0).metadata_charge_policy_),
-           h->helper);
-}
-
 size_t LRUCache::TEST_GetLRUSize() {
   return SumOverShards([](LRUCacheShard& cs) { return cs.TEST_GetLRUSize(); });
 }

cache/lru_cache.h

@@ -452,12 +452,6 @@ class LRUCache
   size_t GetCharge(Handle* handle) const override;
   const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
 
-  void ApplyToHandle(
-      Cache* cache, Handle* handle,
-      const std::function<void(const Slice& key, ObjectPtr obj, size_t charge,
-                               const CacheItemHelper* helper)>& callback)
-      override;
-
   // Retrieves number of elements in LRU, for unit test purpose only.
   size_t TEST_GetLRUSize();
   // Retrieves high pri pool ratio.

cache/secondary_cache_adapter.cc

@@ -271,8 +271,7 @@ Status CacheWithSecondaryAdapter::Insert(const Slice& key, ObjectPtr value,
   // Warm up the secondary cache with the compressed block. The secondary
   // cache may choose to ignore it based on the admission policy.
   if (value != nullptr && !compressed_value.empty() &&
-      adm_policy_ == TieredAdmissionPolicy::kAdmPolicyThreeQueue &&
-      helper->IsSecondaryCacheCompatible()) {
+      adm_policy_ == TieredAdmissionPolicy::kAdmPolicyThreeQueue) {
     Status status = secondary_cache_->InsertSaved(key, compressed_value, type);
     assert(status.ok() || status.IsNotSupported());
   }

cache/tiered_secondary_cache_test.cc

@@ -253,7 +253,6 @@ TEST_F(DBTieredSecondaryCacheTest, BasicTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   // Disable paranoid_file_checks so that flush will not read back the newly
@@ -365,7 +364,6 @@ TEST_F(DBTieredSecondaryCacheTest, BasicMultiGetTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   options.paranoid_file_checks = false;
@@ -508,7 +506,6 @@ TEST_F(DBTieredSecondaryCacheTest, WaitAllTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   options.paranoid_file_checks = false;
@@ -609,7 +606,6 @@ TEST_F(DBTieredSecondaryCacheTest, ReadyBeforeWaitAllTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
   options.statistics = CreateDBStatistics();
 
@@ -721,7 +717,6 @@ TEST_F(DBTieredSecondaryCacheTest, IterateTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   options.paranoid_file_checks = false;
@@ -765,54 +760,6 @@ TEST_F(DBTieredSecondaryCacheTest, IterateTest) {
   Destroy(options);
 }
 
-TEST_F(DBTieredSecondaryCacheTest, VolatileTierTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  // We want a block cache of size 5KB, and a compressed secondary cache of
-  // size 5KB. However, we specify a block cache size of 256KB here in order
-  // to take into account the cache reservation in the block cache on
-  // behalf of the compressed cache. The unit of cache reservation is 256KB.
-  // The effective block cache capacity will be calculated as 256 + 5 = 261KB,
-  // and 256KB will be reserved for the compressed cache, leaving 5KB for
-  // the primary block cache. We only have to worry about this here because
-  // the cache size is so small.
-  table_options.block_cache = NewCache(256 * 1024, 5 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  // Disable paranoid_file_checks so that flush will not read back the newly
-  // written file
-  options.paranoid_file_checks = false;
-  options.lowest_used_cache_tier = CacheTier::kVolatileTier;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  // Since lowest_used_cache_tier is the volatile tier, nothing should be
-  // inserted in the secondary cache.
-  std::string v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 0u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 0u);
-
-  Destroy(options);
-}
-
 class DBTieredAdmPolicyTest
     : public DBTieredSecondaryCacheTest,
       public testing::WithParamInterface<TieredAdmissionPolicy> {};
@@ -837,7 +784,6 @@ TEST_P(DBTieredAdmPolicyTest, CompressedOnlyTest) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
@@ -890,7 +836,6 @@ TEST_P(DBTieredAdmPolicyTest, CompressedCacheAdmission) {
   table_options.cache_index_and_filter_blocks = false;
   Options options = GetDefaultOptions();
   options.create_if_missing = true;
-  options.compression = kLZ4Compression;
   options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
@@ -928,112 +873,6 @@ TEST_P(DBTieredAdmPolicyTest, CompressedCacheAdmission) {
   Destroy(options);
 }
 
-TEST_F(DBTieredSecondaryCacheTest, FSBufferTest) {
-  class WrapFS : public FileSystemWrapper {
-   public:
-    explicit WrapFS(const std::shared_ptr<FileSystem>& _target)
-        : FileSystemWrapper(_target) {}
-    ~WrapFS() override {}
-    const char* Name() const override { return "WrapFS"; }
-
-    IOStatus NewRandomAccessFile(const std::string& fname,
-                                 const FileOptions& opts,
-                                 std::unique_ptr<FSRandomAccessFile>* result,
-                                 IODebugContext* dbg) override {
-      class WrappedRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
-       public:
-        explicit WrappedRandomAccessFile(
-            std::unique_ptr<FSRandomAccessFile>& file)
-            : FSRandomAccessFileOwnerWrapper(std::move(file)) {}
-
-        IOStatus MultiRead(FSReadRequest* reqs, size_t num_reqs,
-                           const IOOptions& options,
-                           IODebugContext* dbg) override {
-          for (size_t i = 0; i < num_reqs; ++i) {
-            FSReadRequest& req = reqs[i];
-            FSAllocationPtr buffer(new char[req.len], [](void* ptr) {
-              delete[] static_cast<char*>(ptr);
-            });
-            req.fs_scratch = std::move(buffer);
-            req.status = Read(req.offset, req.len, options, &req.result,
-                              static_cast<char*>(req.fs_scratch.get()), dbg);
-          }
-          return IOStatus::OK();
-        }
-      };
-
-      std::unique_ptr<FSRandomAccessFile> file;
-      IOStatus s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
-      EXPECT_OK(s);
-      result->reset(new WrappedRandomAccessFile(file));
-
-      return s;
-    }
-
-    void SupportedOps(int64_t& supported_ops) override {
-      supported_ops = 1 << FSSupportedOps::kAsyncIO;
-      supported_ops |= 1 << FSSupportedOps::kFSBuffer;
-    }
-  };
-
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  std::shared_ptr<WrapFS> wrap_fs =
-      std::make_shared<WrapFS>(env_->GetFileSystem());
-  std::unique_ptr<Env> wrap_env(new CompositeEnvWrapper(env_, wrap_fs));
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(250 * 1024, 20 * 1024, 256 * 1024,
-                                       TieredAdmissionPolicy::kAdmPolicyAuto,
-                                       /*ready_before_wait=*/true);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.compression = kLZ4Compression;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.statistics = CreateDBStatistics();
-  options.env = wrap_env.get();
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  std::string v = Get(Key(12));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 4u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 4u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 4u);
-
-  Close();
-  Destroy(options);
-}
-
 INSTANTIATE_TEST_CASE_P(
     DBTieredAdmPolicyTest, DBTieredAdmPolicyTest,
     ::testing::Values(TieredAdmissionPolicy::kAdmPolicyAuto,

db/arena_wrapped_db_iter.cc

@@ -45,23 +45,20 @@ void ArenaWrappedDBIter::Init(
     const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration,
     uint64_t version_number, ReadCallback* read_callback,
     ColumnFamilyHandleImpl* cfh, bool expose_blob_index, bool allow_refresh) {
+  auto mem = arena_.AllocateAligned(sizeof(DBIter));
+  db_iter_ = new (mem) DBIter(
+      env, read_options, ioptions, mutable_cf_options, ioptions.user_comparator,
+      /* iter */ nullptr, version, sequence, true,
+      max_sequential_skip_in_iteration, read_callback, cfh, expose_blob_index);
+  sv_number_ = version_number;
   read_options_ = read_options;
+  allow_refresh_ = allow_refresh;
+  memtable_range_tombstone_iter_ = nullptr;
+
   if (!CheckFSFeatureSupport(env->GetFileSystem().get(),
                              FSSupportedOps::kAsyncIO)) {
     read_options_.async_io = false;
   }
-  read_options_.total_order_seek |= ioptions.prefix_seek_opt_in_only;
-
-  auto mem = arena_.AllocateAligned(sizeof(DBIter));
-  db_iter_ = new (mem) DBIter(env, read_options_, ioptions, mutable_cf_options,
-                              ioptions.user_comparator,
-                              /* iter */ nullptr, version, sequence, true,
-                              max_sequential_skip_in_iteration, read_callback,
-                              cfh, expose_blob_index);
-
-  sv_number_ = version_number;
-  allow_refresh_ = allow_refresh;
-  memtable_range_tombstone_iter_ = nullptr;
 }
 
 Status ArenaWrappedDBIter::Refresh() { return Refresh(nullptr); }
@@ -141,10 +138,10 @@ Status ArenaWrappedDBIter::Refresh(const Snapshot* snapshot) {
             reinit_internal_iter();
             break;
           } else {
-            *memtable_range_tombstone_iter_ =
-                std::make_unique<TruncatedRangeDelIterator>(
-                    std::unique_ptr<FragmentedRangeTombstoneIterator>(t),
-                    &cfd->internal_comparator(), nullptr, nullptr);
+            delete *memtable_range_tombstone_iter_;
+            *memtable_range_tombstone_iter_ = new TruncatedRangeDelIterator(
+                std::unique_ptr<FragmentedRangeTombstoneIterator>(t),
+                &cfd->internal_comparator(), nullptr, nullptr);
           }
         }
         db_impl->ReturnAndCleanupSuperVersion(cfd, sv);

db/arena_wrapped_db_iter.h

@@ -55,8 +55,7 @@ class ArenaWrappedDBIter : public Iterator {
     db_iter_->SetIter(iter);
   }
 
-  void SetMemtableRangetombstoneIter(
-      std::unique_ptr<TruncatedRangeDelIterator>* iter) {
+  void SetMemtableRangetombstoneIter(TruncatedRangeDelIterator** iter) {
     memtable_range_tombstone_iter_ = iter;
   }
 
@@ -111,8 +110,7 @@ class ArenaWrappedDBIter : public Iterator {
   bool allow_refresh_ = true;
   // If this is nullptr, it means the mutable memtable does not contain range
   // tombstone when added under this DBIter.
-  std::unique_ptr<TruncatedRangeDelIterator>* memtable_range_tombstone_iter_ =
-      nullptr;
+  TruncatedRangeDelIterator** memtable_range_tombstone_iter_ = nullptr;
 };
 
 // Generate the arena wrapped iterator class.

db/blob/blob_file_cache.cc

@@ -42,7 +42,6 @@ Status BlobFileCache::GetBlobFileReader(
   assert(blob_file_reader);
   assert(blob_file_reader->IsEmpty());
 
-  // NOTE: sharing same Cache with table_cache
   const Slice key = GetSliceForKey(&blob_file_number);
 
   assert(cache_);
@@ -99,13 +98,4 @@ Status BlobFileCache::GetBlobFileReader(
   return Status::OK();
 }
 
-void BlobFileCache::Evict(uint64_t blob_file_number) {
-  // NOTE: sharing same Cache with table_cache
-  const Slice key = GetSliceForKey(&blob_file_number);
-
-  assert(cache_);
-
-  cache_.get()->Erase(key);
-}
-
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_cache.h

@@ -36,15 +36,6 @@ class BlobFileCache {
                            uint64_t blob_file_number,
                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
 
-  // Called when a blob file is obsolete to ensure it is removed from the cache
-  // to avoid effectively leaking the open file and assicated memory
-  void Evict(uint64_t blob_file_number);
-
-  // Used to identify cache entries for blob files (not normally useful)
-  static const Cache::CacheItemHelper* GetHelper() {
-    return CacheInterface::GetBasicHelper();
-  }
-
  private:
   using CacheInterface =
       BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;

db/builder.cc

@@ -64,7 +64,7 @@ Status BuildTable(
     std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
         range_del_iters,
     FileMetaData* meta, std::vector<BlobFileAddition>* blob_file_additions,
-    std::vector<SequenceNumber> snapshots, SequenceNumber earliest_snapshot,
+    std::vector<SequenceNumber> snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
     SequenceNumber job_snapshot, SnapshotChecker* snapshot_checker,
     bool paranoid_file_checks, InternalStats* internal_stats,
@@ -195,7 +195,7 @@ Status BuildTable(
 
     const std::atomic<bool> kManualCompactionCanceledFalse{false};
     CompactionIterator c_iter(
-        iter, ucmp, &merge, kMaxSequenceNumber, &snapshots, earliest_snapshot,
+        iter, ucmp, &merge, kMaxSequenceNumber, &snapshots,
         earliest_write_conflict_snapshot, job_snapshot, snapshot_checker, env,
         ShouldReportDetailedTime(env, ioptions.stats),
         true /* internal key corruption is not ok */, range_del_agg.get(),

db/builder.h

@@ -57,7 +57,7 @@ Status BuildTable(
     std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
         range_del_iters,
     FileMetaData* meta, std::vector<BlobFileAddition>* blob_file_additions,
-    std::vector<SequenceNumber> snapshots, SequenceNumber earliest_snapshot,
+    std::vector<SequenceNumber> snapshots,
     SequenceNumber earliest_write_conflict_snapshot,
     SequenceNumber job_snapshot, SnapshotChecker* snapshot_checker,
     bool paranoid_file_checks, InternalStats* internal_stats,

db/c.cc

@@ -231,7 +231,6 @@ struct rocksdb_livefiles_t {
 };
 struct rocksdb_column_family_handle_t {
   ColumnFamilyHandle* rep;
-  bool immortal;  /* only true for default cf */
 };
 struct rocksdb_column_family_metadata_t {
   ColumnFamilyMetaData rep;
@@ -532,42 +531,6 @@ struct rocksdb_universal_compaction_options_t {
   ROCKSDB_NAMESPACE::CompactionOptionsUniversal* rep;
 };
 
-struct rocksdb_callback_logger_t : public Logger {
-  static const ssize_t STACK_BUFSZ = 512;
-  rocksdb_callback_logger_t(InfoLogLevel log_level,
-                            void (*logv_cb)(void*, unsigned, char*, size_t),
-                            void* priv)
-      : Logger(log_level), logv_cb_(logv_cb), priv_(priv) {}
-
-  using Logger::Logv;
-  void Logv(const InfoLogLevel level, const char* fmt, va_list ap0) override {
-    char stack_buf[STACK_BUFSZ];
-    char* alloc_buf = nullptr;
-    char* buf = stack_buf;
-    int len = 0;
-    va_list ap1;
-    if (!logv_cb_) return;
-    va_copy(ap1, ap0);
-    len = vsnprintf(buf, STACK_BUFSZ, fmt, ap0);
-    if (len <= 0)
-      goto cleanup;
-    else if (len >= STACK_BUFSZ) {
-      buf = alloc_buf = reinterpret_cast<char*>(malloc(len + 1));
-      if (!buf) goto cleanup;
-      len = vsnprintf(buf, len + 1, fmt, ap1);
-      if (len <= 0) goto cleanup;
-    }
-    logv_cb_(priv_, unsigned(level), buf, size_t(len));
-  cleanup:
-    va_end(ap1);
-    free(alloc_buf);
-  }
-
- private:
-  void (*logv_cb_)(void*, unsigned, char*, size_t) = nullptr;
-  void* priv_ = nullptr;
-};
-
 static bool SaveError(char** errptr, const Status& s) {
   assert(errptr != nullptr);
   if (s.ok()) {
@@ -583,7 +546,6 @@ static bool SaveError(char** errptr, const Status& s) {
   return true;
 }
 
-// Copies str to a new malloc()-ed buffer. The buffer is not NUL terminated.
 static char* CopyString(const std::string& str) {
   char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
   memcpy(result, str.data(), sizeof(char) * str.size());
@@ -944,7 +906,6 @@ rocksdb_t* rocksdb_open_and_trim_history(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -975,7 +936,6 @@ rocksdb_t* rocksdb_open_column_families(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -1011,7 +971,6 @@ rocksdb_t* rocksdb_open_column_families_with_ttl(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -1045,7 +1004,6 @@ rocksdb_t* rocksdb_open_for_read_only_column_families(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -1077,7 +1035,6 @@ rocksdb_t* rocksdb_open_as_secondary_column_families(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_t* result = new rocksdb_t;
@@ -1115,7 +1072,6 @@ rocksdb_column_family_handle_t* rocksdb_create_column_family(
   SaveError(errptr, db->rep->CreateColumnFamily(
                         ColumnFamilyOptions(column_family_options->rep),
                         std::string(column_family_name), &(handle->rep)));
-  handle->immortal = false;
   return handle;
 }
 
@@ -1139,7 +1095,6 @@ rocksdb_column_family_handle_t** rocksdb_create_column_families(
   for (size_t i = 0; i != handles.size(); ++i) {
     c_handles[i] = new rocksdb_column_family_handle_t;
     c_handles[i]->rep = handles[i];
-    c_handles[i]->immortal = false;
   }
 
   return c_handles;
@@ -1159,7 +1114,6 @@ rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl(
   SaveError(errptr, db_with_ttl->CreateColumnFamilyWithTtl(
                         ColumnFamilyOptions(column_family_options->rep),
                         std::string(column_family_name), &(handle->rep), ttl));
-  handle->immortal = false;
   return handle;
 }
 
@@ -1181,19 +1135,9 @@ char* rocksdb_column_family_handle_get_name(
   return CopyString(name);
 }
 
-rocksdb_column_family_handle_t* rocksdb_get_default_column_family_handle(
-    rocksdb_t* db) {
-  rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
-  handle->rep = db->rep->DefaultColumnFamily();
-  handle->immortal = true;
-  return handle;
-}
-
 void rocksdb_column_family_handle_destroy(
     rocksdb_column_family_handle_t* handle) {
-  if (!handle->immortal) {
-    delete handle->rep;
-  }
+  delete handle->rep;
   delete handle;
 }
 
@@ -1429,18 +1373,6 @@ char* rocksdb_get_cf_with_ts(rocksdb_t* db,
   return result;
 }
 
-char* rocksdb_get_db_identity(rocksdb_t* db, size_t* id_len) {
-  std::string identity_tmp;
-  Status s = db->rep->GetDbIdentity(identity_tmp);
-  if (!s.ok()) {
-    *id_len = 0;
-    return nullptr;
-  }
-
-  *id_len = identity_tmp.size();
-  return CopyString(identity_tmp);
-}
-
 void rocksdb_multi_get(rocksdb_t* db, const rocksdb_readoptions_t* options,
                        size_t num_keys, const char* const* keys_list,
                        const size_t* keys_list_sizes, char** values_list,
@@ -1838,26 +1770,6 @@ void rocksdb_approximate_sizes_cf(
   delete[] ranges;
 }
 
-extern ROCKSDB_LIBRARY_API void rocksdb_approximate_sizes_cf_with_flags(
-    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
-    int num_ranges, const char* const* range_start_key,
-    const size_t* range_start_key_len, const char* const* range_limit_key,
-    const size_t* range_limit_key_len, uint8_t include_flags, uint64_t* sizes,
-    char** errptr) {
-  Range* ranges = new Range[num_ranges];
-  for (int i = 0; i < num_ranges; i++) {
-    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
-    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
-  }
-  Status s = db->rep->GetApproximateSizes(
-      column_family->rep, ranges, num_ranges, sizes,
-      static_cast<DB::SizeApproximationFlags>(include_flags));
-  if (!s.ok()) {
-    SaveError(errptr, s);
-  }
-  delete[] ranges;
-}
-
 void rocksdb_delete_file(rocksdb_t* db, const char* name) {
   db->rep->DeleteFile(name);
 }
@@ -2035,10 +1947,6 @@ void rocksdb_iter_get_error(const rocksdb_iterator_t* iter, char** errptr) {
   SaveError(errptr, iter->rep->status());
 }
 
-void rocksdb_iter_refresh(const rocksdb_iterator_t* iter, char** errptr) {
-  SaveError(errptr, iter->rep->Refresh());
-}
-
 rocksdb_writebatch_t* rocksdb_writebatch_create() {
   return new rocksdb_writebatch_t;
 }
@@ -2050,15 +1958,6 @@ rocksdb_writebatch_t* rocksdb_writebatch_create_from(const char* rep,
   return b;
 }
 
-rocksdb_writebatch_t* rocksdb_writebatch_create_with_params(
-    size_t reserved_bytes, size_t max_bytes, size_t protection_bytes_per_key,
-    size_t default_cf_ts_sz) {
-  rocksdb_writebatch_t* b = new rocksdb_writebatch_t;
-  b->rep = WriteBatch(reserved_bytes, max_bytes, protection_bytes_per_key,
-                      default_cf_ts_sz);
-  return b;
-}
-
 void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) { delete b; }
 
 void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); }
@@ -2286,32 +2185,6 @@ class H : public WriteBatch::Handler {
   }
 };
 
-class HCF : public WriteBatch::Handler {
- public:
-  void* state_;
-  void (*put_cf_)(void*, uint32_t cfid, const char* k, size_t klen,
-                  const char* v, size_t vlen);
-  void (*deleted_cf_)(void*, uint32_t cfid, const char* k, size_t klen);
-  void (*merge_cf_)(void*, uint32_t cfid, const char* k, size_t klen,
-                    const char* v, size_t vlen);
-  Status PutCF(uint32_t column_family_id, const Slice& key,
-               const Slice& value) override {
-    (*put_cf_)(state_, column_family_id, key.data(), key.size(), value.data(),
-               value.size());
-    return Status::OK();
-  }
-  Status DeleteCF(uint32_t column_family_id, const Slice& key) override {
-    (*deleted_cf_)(state_, column_family_id, key.data(), key.size());
-    return Status::OK();
-  }
-  Status MergeCF(uint32_t column_family_id, const Slice& key,
-                 const Slice& value) override {
-    (*merge_cf_)(state_, column_family_id, key.data(), key.size(), value.data(),
-                 value.size());
-    return Status::OK();
-  }
-};
-
 void rocksdb_writebatch_iterate(rocksdb_writebatch_t* b, void* state,
                                 void (*put)(void*, const char* k, size_t klen,
                                             const char* v, size_t vlen),
@@ -2324,21 +2197,6 @@ void rocksdb_writebatch_iterate(rocksdb_writebatch_t* b, void* state,
   b->rep.Iterate(&handler);
 }
 
-void rocksdb_writebatch_iterate_cf(
-    rocksdb_writebatch_t* b, void* state,
-    void (*put_cf)(void*, uint32_t cfid, const char* k, size_t klen,
-                   const char* v, size_t vlen),
-    void (*deleted_cf)(void*, uint32_t cfid, const char* k, size_t klen),
-    void (*merge_cf)(void*, uint32_t cfid, const char* k, size_t klen,
-                     const char* v, size_t vlen)) {
-  HCF handler;
-  handler.state_ = state;
-  handler.put_cf_ = put_cf;
-  handler.deleted_cf_ = deleted_cf;
-  handler.merge_cf_ = merge_cf;
-  b->rep.Iterate(&handler);
-}
-
 const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) {
   *size = b->rep.GetDataSize();
   return b->rep.Data().c_str();
@@ -2365,35 +2223,6 @@ rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(
   return b;
 }
 
-rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create_with_params(
-    rocksdb_comparator_t* backup_index_comparator, size_t reserved_bytes,
-    unsigned char overwrite_key, size_t max_bytes,
-    size_t protection_bytes_per_key) {
-  rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t;
-  b->rep = new WriteBatchWithIndex(backup_index_comparator, reserved_bytes,
-                                   overwrite_key, max_bytes,
-                                   protection_bytes_per_key);
-  return b;
-}
-
-void rocksdb_writebatch_update_timestamps(
-    rocksdb_writebatch_t* wb, const char* ts, size_t tslen, void* state,
-    size_t (*get_ts_size)(void*, uint32_t), char** errptr) {
-  SaveError(errptr, wb->rep.UpdateTimestamps(
-                        Slice(ts, tslen), [&get_ts_size, &state](uint32_t cf) {
-                          return (*get_ts_size)(state, cf);
-                        }));
-}
-
-void rocksdb_writebatch_wi_update_timestamps(
-    rocksdb_writebatch_wi_t* wb, const char* ts, size_t tslen, void* state,
-    size_t (*get_ts_size)(void*, uint32_t), char** errptr) {
-  SaveError(errptr, wb->rep->GetWriteBatch()->UpdateTimestamps(
-                        Slice(ts, tslen), [&get_ts_size, &state](uint32_t cf) {
-                          return (*get_ts_size)(state, cf);
-                        }));
-}
-
 void rocksdb_writebatch_wi_destroy(rocksdb_writebatch_wi_t* b) {
   if (b->rep) {
     delete b->rep;
@@ -2916,24 +2745,6 @@ void rocksdb_options_set_block_based_table_factory(
   }
 }
 
-void rocksdb_block_based_options_set_top_level_index_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.top_level_index_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
-
-void rocksdb_block_based_options_set_partition_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.partition_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
-
-void rocksdb_block_based_options_set_unpartitioned_pinning_tier(
-    rocksdb_block_based_table_options_t* options, int v) {
-  options->rep.metadata_cache_options.unpartitioned_pinning =
-      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
-}
-
 rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create() {
   return new rocksdb_cuckoo_table_options_t;
 }
@@ -3134,15 +2945,6 @@ rocksdb_logger_t* rocksdb_logger_create_stderr_logger(int log_level,
   return logger;
 }
 
-rocksdb_logger_t* rocksdb_logger_create_callback_logger(
-    int log_level, void (*callback)(void*, unsigned, char*, size_t),
-    void* priv) {
-  rocksdb_logger_t* logger = new rocksdb_logger_t;
-  logger->rep = std::make_shared<rocksdb_callback_logger_t>(
-      static_cast<InfoLogLevel>(log_level), callback, priv);
-  return logger;
-}
-
 void rocksdb_logger_destroy(rocksdb_logger_t* logger) { delete logger; }
 
 void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) {
@@ -4065,36 +3867,6 @@ void rocksdb_options_set_plain_table_factory(
   opt->rep.table_factory.reset(factory);
 }
 
-unsigned char rocksdb_options_get_write_dbid_to_manifest(
-    rocksdb_options_t* opt) {
-  return opt->rep.write_dbid_to_manifest;
-}
-
-void rocksdb_options_set_write_dbid_to_manifest(
-    rocksdb_options_t* opt, unsigned char write_dbid_to_manifest) {
-  opt->rep.write_dbid_to_manifest = write_dbid_to_manifest;
-}
-
-unsigned char rocksdb_options_get_write_identity_file(rocksdb_options_t* opt) {
-  return opt->rep.write_identity_file;
-}
-
-void rocksdb_options_set_write_identity_file(
-    rocksdb_options_t* opt, unsigned char write_identity_file) {
-  opt->rep.write_identity_file = write_identity_file;
-}
-
-unsigned char rocksdb_options_get_track_and_verify_wals_in_manifest(
-    rocksdb_options_t* opt) {
-  return opt->rep.track_and_verify_wals_in_manifest;
-}
-
-void rocksdb_options_set_track_and_verify_wals_in_manifest(
-    rocksdb_options_t* opt, unsigned char track_and_verify_wals_in_manifest) {
-  opt->rep.track_and_verify_wals_in_manifest =
-      track_and_verify_wals_in_manifest;
-}
-
 void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt,
                                                size_t v) {
   opt->rep.max_successive_merges = v;
@@ -4158,14 +3930,6 @@ void rocksdb_options_set_fifo_compaction_options(
   opt->rep.compaction_options_fifo = fifo->rep;
 }
 
-void rocksdb_options_set_compaction_pri(rocksdb_options_t* opt, int pri) {
-  opt->rep.compaction_pri = static_cast<ROCKSDB_NAMESPACE::CompactionPri>(pri);
-}
-
-int rocksdb_options_get_compaction_pri(rocksdb_options_t* opt) {
-  return opt->rep.compaction_pri;
-}
-
 char* rocksdb_options_statistics_get_string(rocksdb_options_t* opt) {
   ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get();
   if (statistics) {
@@ -4474,8 +4238,13 @@ void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
 
 /*
 TODO:
+DB::OpenForReadOnly
+DB::KeyMayExist
 DB::GetOptions
 DB::GetSortedWalFiles
+DB::GetLatestSequenceNumber
+DB::GetUpdatesSince
+DB::GetDbIdentity
 DB::RunManualCompaction
 custom cache
 table_properties_collectors
@@ -5952,7 +5721,6 @@ rocksdb_column_family_handle_t* rocksdb_transactiondb_create_column_family(
   SaveError(errptr, txn_db->rep->CreateColumnFamily(
                         ColumnFamilyOptions(column_family_options->rep),
                         std::string(column_family_name), &(handle->rep)));
-  handle->immortal = false;
   return handle;
 }
 
@@ -5995,7 +5763,6 @@ rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
@@ -6790,7 +6557,6 @@ rocksdb_optimistictransactiondb_open_column_families(
     rocksdb_column_family_handle_t* c_handle =
         new rocksdb_column_family_handle_t;
     c_handle->rep = handles[i];
-    c_handle->immortal = false;
     column_family_handles[i] = c_handle;
   }
   rocksdb_optimistictransactiondb_t* result =

db/c_test.c

@@ -199,79 +199,6 @@ static void CheckDel(void* ptr, const char* k, size_t klen) {
   (*state)++;
 }
 
-// Callback from rocksdb_writebatch_iterate_cf()
-static void CheckPutCF(void* ptr, uint32_t cfid, const char* k, size_t klen,
-                       const char* v, size_t vlen) {
-  int* state = (int*)ptr;
-  switch (*state) {
-    case 0:
-      CheckEqual("bar", k, klen);
-      CheckEqual("b", v, vlen);
-      CheckCondition(cfid == 1);
-      break;
-    case 1:
-      CheckEqual("box", k, klen);
-      CheckEqual("c", v, vlen);
-      CheckCondition(cfid == 1);
-      break;
-    case 4:
-      CheckEqual("foo", k, klen);
-      CheckEqual("f", v, vlen);
-      CheckCondition(cfid == 0);
-      break;
-    case 6:
-      CheckEqual("baz", k, klen);
-      CheckEqual("a", v, vlen);
-      CheckCondition(cfid == 0);
-      break;
-    default:
-      CheckCondition(false);
-      break;
-  }
-  (*state)++;
-}
-
-// Callback from rocksdb_writebatch_iterate_cf()
-static void CheckDelCF(void* ptr, uint32_t cfid, const char* k, size_t klen) {
-  int* state = (int*)ptr;
-  switch (*state) {
-    case 2:
-      CheckEqual("bar", k, klen);
-      CheckCondition(cfid == 1);
-      break;
-    case 5:
-      CheckEqual("foo", k, klen);
-      CheckCondition(cfid == 0);
-      break;
-    default:
-      CheckCondition(false);
-      break;
-  }
-  (*state)++;
-}
-
-// Callback from rocksdb_writebatch_iterate_cf()
-static void CheckMergeCF(void* ptr, uint32_t cfid, const char* k, size_t klen,
-                         const char* v, size_t vlen) {
-  int* state = (int*)ptr;
-  switch (*state) {
-    case 3:
-      CheckEqual("box", k, klen);
-      CheckEqual("cc", v, vlen);
-      CheckCondition(cfid == 1);
-      break;
-    case 7:
-      CheckEqual("baz", k, klen);
-      CheckEqual("aa", v, vlen);
-      CheckCondition(cfid == 0);
-      break;
-    default:
-      CheckCondition(false);
-      break;
-  }
-  (*state)++;
-}
-
 static void CmpDestroy(void* arg) { (void)arg; }
 
 static int CmpCompare(void* arg, const char* a, size_t alen, const char* b,
@@ -772,17 +699,11 @@ int main(int argc, char** argv) {
   rocksdb_options_set_write_buffer_size(options, 100000);
   rocksdb_options_set_paranoid_checks(options, 1);
   rocksdb_options_set_max_open_files(options, 10);
-  /* Compatibility with how test was written */
-  rocksdb_options_set_write_dbid_to_manifest(options, 0);
 
   table_options = rocksdb_block_based_options_create();
   rocksdb_block_based_options_set_block_cache(table_options, cache);
   rocksdb_block_based_options_set_data_block_index_type(table_options, 1);
   rocksdb_block_based_options_set_data_block_hash_ratio(table_options, 0.75);
-  rocksdb_block_based_options_set_top_level_index_pinning_tier(table_options,
-                                                               1);
-  rocksdb_block_based_options_set_partition_pinning_tier(table_options, 2);
-  rocksdb_block_based_options_set_unpartitioned_pinning_tier(table_options, 3);
   rocksdb_options_set_block_based_table_factory(options, table_options);
 
   rocksdb_options_set_compression(options, rocksdb_no_compression);
@@ -873,11 +794,6 @@ int main(int argc, char** argv) {
     rocksdb_delete(db, woptions, "foo", 3, &err);
     CheckNoError(err);
 
-    // get the identity before the backup
-    size_t before_db_id_len = 0;
-    char* before_db_id = rocksdb_get_db_identity(db, &before_db_id_len);
-    CheckCondition(before_db_id_len == 36);
-
     rocksdb_close(db);
 
     rocksdb_destroy_db(options, dbname, &err);
@@ -898,14 +814,6 @@ int main(int argc, char** argv) {
 
     CheckGet(db, roptions, "foo", "hello");
 
-    // the db_identity after the backup is different
-    size_t after_db_id_len = 0;
-    char* after_db_id = rocksdb_get_db_identity(db, &after_db_id_len);
-    CheckCondition(after_db_id_len == 36);
-    CheckCondition(memcmp(after_db_id, before_db_id, after_db_id_len) != 0);
-    Free(&before_db_id);
-    Free(&after_db_id);
-
     rocksdb_backup_engine_close(be);
   }
 
@@ -921,14 +829,6 @@ int main(int argc, char** argv) {
     rocksdb_checkpoint_create(checkpoint, dbcheckpointname, 0, &err);
     CheckNoError(err);
 
-    rocksdb_checkpoint_object_destroy(checkpoint);
-    checkpoint = NULL;
-
-    // get the identity before the checkpoint
-    size_t before_db_id_len = 0;
-    char* before_db_id = rocksdb_get_db_identity(db, &before_db_id_len);
-    CheckCondition(before_db_id_len == 36);
-
     // start a new database from the checkpoint
     rocksdb_close(db);
     rocksdb_options_set_error_if_exists(options, 0);
@@ -937,13 +837,7 @@ int main(int argc, char** argv) {
 
     CheckGet(db, roptions, "foo", "hello");
 
-    // the db_identity after the checkpoint is different
-    size_t after_db_id_len = 0;
-    char* after_db_id = rocksdb_get_db_identity(db, &after_db_id_len);
-    CheckCondition(after_db_id_len == 36);
-    CheckCondition(memcmp(after_db_id, before_db_id, after_db_id_len) != 0);
-    Free(&before_db_id);
-    Free(&after_db_id);
+    rocksdb_checkpoint_object_destroy(checkpoint);
 
     rocksdb_close(db);
     rocksdb_destroy_db(options, dbcheckpointname, &err);
@@ -954,82 +848,6 @@ int main(int argc, char** argv) {
     rocksdb_options_set_error_if_exists(options, 1);
   }
 
-  StartPhase("checkpoint_db_id_in_manifest");
-  {
-    // create new DB with set_write_dbid_to_manifest=true
-    // db_identity is now the same across checkpoints
-    rocksdb_close(db);
-    db = NULL;
-
-    rocksdb_options_t* options_dbid_in_manifest = rocksdb_options_create();
-    rocksdb_options_set_create_if_missing(options_dbid_in_manifest, 1);
-
-    rocksdb_options_set_write_dbid_to_manifest(options_dbid_in_manifest, false);
-    unsigned char write_to_manifest =
-        rocksdb_options_get_write_dbid_to_manifest(options_dbid_in_manifest);
-    CheckCondition(!write_to_manifest);
-    rocksdb_options_set_write_dbid_to_manifest(options_dbid_in_manifest, true);
-    write_to_manifest =
-        rocksdb_options_get_write_dbid_to_manifest(options_dbid_in_manifest);
-    CheckCondition(write_to_manifest);
-
-    rocksdb_options_set_write_identity_file(options_dbid_in_manifest, true);
-    unsigned char write_identity_file =
-        rocksdb_options_get_write_identity_file(options_dbid_in_manifest);
-    CheckCondition(write_identity_file);
-    rocksdb_options_set_write_identity_file(options_dbid_in_manifest, false);
-    write_identity_file =
-        rocksdb_options_get_write_identity_file(options_dbid_in_manifest);
-    CheckCondition(!write_identity_file);
-
-    db = rocksdb_open(options_dbid_in_manifest, dbbackupname, &err);
-    CheckNoError(err);
-
-    rocksdb_checkpoint_t* checkpoint =
-        rocksdb_checkpoint_object_create(db, &err);
-    CheckNoError(err);
-
-    rocksdb_checkpoint_create(checkpoint, dbcheckpointname, 0, &err);
-    CheckNoError(err);
-
-    rocksdb_checkpoint_object_destroy(checkpoint);
-    checkpoint = NULL;
-
-    // get the identity before the backup
-    size_t before_db_id_len = 0;
-    char* before_db_id = rocksdb_get_db_identity(db, &before_db_id_len);
-    CheckCondition(before_db_id_len == 36);
-
-    // open the checkpoint
-    rocksdb_close(db);
-    rocksdb_destroy_db(options_dbid_in_manifest, dbbackupname, &err);
-    CheckNoError(err);
-
-    rocksdb_options_set_error_if_exists(options_dbid_in_manifest, 0);
-    db = rocksdb_open(options_dbid_in_manifest, dbcheckpointname, &err);
-    CheckNoError(err);
-
-    // the db_identity after the checkpoint is the same
-    size_t after_db_id_len = 0;
-    char* after_db_id = rocksdb_get_db_identity(db, &after_db_id_len);
-    CheckCondition(after_db_id_len == 36);
-    CheckCondition(memcmp(after_db_id, before_db_id, after_db_id_len) == 0);
-    Free(&before_db_id);
-    Free(&after_db_id);
-
-    rocksdb_close(db);
-    rocksdb_destroy_db(options_dbid_in_manifest, dbcheckpointname, &err);
-    CheckNoError(err);
-    rocksdb_options_destroy(options_dbid_in_manifest);
-    options_dbid_in_manifest = NULL;
-
-    // re-open the default database
-    rocksdb_options_set_error_if_exists(options, 0);
-    db = rocksdb_open(options, dbname, &err);
-    CheckNoError(err);
-    rocksdb_options_set_error_if_exists(options, 1);
-  }
-
   StartPhase("compactall");
   rocksdb_compact_range(db, NULL, 0, NULL, 0);
   CheckGet(db, roptions, "foo", "hello");
@@ -1772,21 +1590,6 @@ int main(int argc, char** argv) {
     CheckPinGetCF(db, roptions, handles[1], "bar", NULL);
     CheckPinGetCF(db, roptions, handles[1], "box", "c");
     CheckPinGetCF(db, roptions, handles[1], "buff", "rocksdb");
-    rocksdb_writebatch_clear(wb);
-    // Test WriteBatch iteration with Column Family
-    int pos = 0;
-    rocksdb_writebatch_put_cf(wb, handles[1], "bar", 3, "b", 1);
-    rocksdb_writebatch_put_cf(wb, handles[1], "box", 3, "c", 1);
-    rocksdb_writebatch_delete_cf(wb, handles[1], "bar", 3);
-    rocksdb_writebatch_merge_cf(wb, handles[1], "box", 3, "cc", 2);
-    rocksdb_writebatch_put(wb, "foo", 3, "f", 1);
-    rocksdb_writebatch_delete(wb, "foo", 3);
-    rocksdb_writebatch_put(wb, "baz", 3, "a", 1);
-    rocksdb_writebatch_merge(wb, "baz", 3, "aa", 2);
-    rocksdb_writebatch_iterate_cf(wb, &pos, CheckPutCF, CheckDelCF,
-                                  CheckMergeCF);
-    CheckCondition(pos == 8);
-    rocksdb_writebatch_clear(wb);
     rocksdb_writebatch_destroy(wb);
 
     rocksdb_flush_wal(db, 1, &err);
@@ -2238,6 +2041,7 @@ int main(int argc, char** argv) {
     rocksdb_options_set_advise_random_on_open(o, 1);
     CheckCondition(1 == rocksdb_options_get_advise_random_on_open(o));
 
+
     rocksdb_options_set_use_adaptive_mutex(o, 1);
     CheckCondition(1 == rocksdb_options_get_use_adaptive_mutex(o));
 
@@ -2308,9 +2112,6 @@ int main(int argc, char** argv) {
     rocksdb_options_set_compaction_style(o, 2);
     CheckCondition(2 == rocksdb_options_get_compaction_style(o));
 
-    rocksdb_options_set_compaction_pri(o, 4);
-    CheckCondition(4 == rocksdb_options_get_compaction_pri(o));
-
     rocksdb_options_set_atomic_flush(o, 1);
     CheckCondition(1 == rocksdb_options_get_atomic_flush(o));
 
@@ -2333,12 +2134,6 @@ int main(int argc, char** argv) {
     CheckCondition(rocksdb_statistics_level_all ==
                    rocksdb_options_get_statistics_level(o));
 
-    CheckCondition(0 ==
-                   rocksdb_options_get_track_and_verify_wals_in_manifest(o));
-    rocksdb_options_set_track_and_verify_wals_in_manifest(o, 42);
-    CheckCondition(1 ==
-                   rocksdb_options_get_track_and_verify_wals_in_manifest(o));
-
     /* Blob Options */
     rocksdb_options_set_enable_blob_files(o, 1);
     CheckCondition(1 == rocksdb_options_get_enable_blob_files(o));
@@ -2821,10 +2616,6 @@ int main(int argc, char** argv) {
     CheckCondition(1 == rocksdb_options_get_compaction_style(copy));
     CheckCondition(2 == rocksdb_options_get_compaction_style(o));
 
-    rocksdb_options_set_compaction_pri(copy, 1);
-    CheckCondition(1 == rocksdb_options_get_compaction_pri(copy));
-    CheckCondition(4 == rocksdb_options_get_compaction_pri(o));
-
     rocksdb_options_set_atomic_flush(copy, 0);
     CheckCondition(0 == rocksdb_options_get_atomic_flush(copy));
     CheckCondition(1 == rocksdb_options_get_atomic_flush(o));

db/column_family.cc

@@ -538,7 +538,6 @@ ColumnFamilyData::ColumnFamilyData(
       refs_(0),
       initialized_(false),
       dropped_(false),
-      flush_skip_reschedule_(false),
       internal_comparator_(cf_options.comparator),
       initial_cf_options_(SanitizeOptions(db_options, cf_options)),
       ioptions_(db_options, initial_cf_options_),
@@ -1201,10 +1200,8 @@ Status ColumnFamilyData::RangesOverlapWithMemtables(
   read_opts.total_order_seek = true;
   MergeIteratorBuilder merge_iter_builder(&internal_comparator_, &arena);
   merge_iter_builder.AddIterator(super_version->mem->NewIterator(
-      read_opts, /*seqno_to_time_mapping=*/nullptr, &arena,
-      /*prefix_extractor=*/nullptr));
+      read_opts, /*seqno_to_time_mapping=*/nullptr, &arena));
   super_version->imm->AddIterators(read_opts, /*seqno_to_time_mapping=*/nullptr,
-                                   /*prefix_extractor=*/nullptr,
                                    &merge_iter_builder,
                                    false /* add_range_tombstone_iter */);
   ScopedArenaPtr<InternalIterator> memtable_iter(merge_iter_builder.Finish());
@@ -1531,20 +1528,6 @@ Status ColumnFamilyData::ValidateOptions(
       }
     }
   }
-
-  if (cf_options.compaction_style == kCompactionStyleUniversal) {
-    int max_read_amp = cf_options.compaction_options_universal.max_read_amp;
-    if (max_read_amp < -1) {
-      return Status::NotSupported(
-          "CompactionOptionsUniversal::max_read_amp should be at least -1.");
-    } else if (0 < max_read_amp &&
-               max_read_amp < cf_options.level0_file_num_compaction_trigger) {
-      return Status::NotSupported(
-          "CompactionOptionsUniversal::max_read_amp limits the number of sorted"
-          " runs but is smaller than the compaction trigger "
-          "level0_file_num_compaction_trigger.");
-    }
-  }
   return s;
 }
 
@@ -1567,6 +1550,28 @@ Status ColumnFamilyData::SetOptions(
   return s;
 }
 
+// REQUIRES: DB mutex held
+Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
+  if (initial_cf_options_.compaction_style != kCompactionStyleLevel) {
+    return Env::WLTH_NOT_SET;
+  }
+  if (level == 0) {
+    return Env::WLTH_MEDIUM;
+  }
+  int base_level = current_->storage_info()->base_level();
+
+  // L1: medium, L2: long, ...
+  if (level - base_level >= 2) {
+    return Env::WLTH_EXTREME;
+  } else if (level < base_level) {
+    // There is no restriction which prevents level passed in to be smaller
+    // than base_level.
+    return Env::WLTH_MEDIUM;
+  }
+  return static_cast<Env::WriteLifeTimeHint>(
+      level - base_level + static_cast<int>(Env::WLTH_MEDIUM));
+}
+
 Status ColumnFamilyData::AddDirectories(
     std::map<std::string, std::shared_ptr<FSDirectory>>* created_dirs) {
   Status s;
@@ -1602,19 +1607,6 @@ FSDirectory* ColumnFamilyData::GetDataDir(size_t path_id) const {
   return data_dirs_[path_id].get();
 }
 
-void ColumnFamilyData::SetFlushSkipReschedule() {
-  const Comparator* ucmp = user_comparator();
-  const size_t ts_sz = ucmp->timestamp_size();
-  if (ts_sz == 0 || ioptions_.persist_user_defined_timestamps) {
-    return;
-  }
-  flush_skip_reschedule_.store(true);
-}
-
-bool ColumnFamilyData::GetAndClearFlushSkipReschedule() {
-  return flush_skip_reschedule_.exchange(false);
-}
-
 bool ColumnFamilyData::ShouldPostponeFlushToRetainUDT(
     uint64_t max_memtable_id) {
   const Comparator* ucmp = user_comparator();
@@ -1632,9 +1624,6 @@ bool ColumnFamilyData::ShouldPostponeFlushToRetainUDT(
   }
   for (const Slice& table_newest_udt :
        imm()->GetTablesNewestUDT(max_memtable_id)) {
-    if (table_newest_udt.empty()) {
-      continue;
-    }
     assert(table_newest_udt.size() == full_history_ts_low.size());
     // Checking the newest UDT contained in MemTable with ascending ID up to
     // `max_memtable_id`. Return immediately on finding the first MemTable that

db/column_family.h

@@ -329,10 +329,6 @@ class ColumnFamilyData {
   void SetDropped();
   bool IsDropped() const { return dropped_.load(std::memory_order_relaxed); }
 
-  void SetFlushSkipReschedule();
-
-  bool GetAndClearFlushSkipReschedule();
-
   // thread-safe
   int NumberLevels() const { return ioptions_.num_levels; }
 
@@ -401,7 +397,6 @@ class ColumnFamilyData {
                          SequenceNumber earliest_seq);
 
   TableCache* table_cache() const { return table_cache_.get(); }
-  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
   BlobSource* blob_source() const { return blob_source_.get(); }
 
   // See documentation in compaction_picker.h
@@ -512,6 +507,8 @@ class ColumnFamilyData {
     return initial_cf_options_;
   }
 
+  Env::WriteLifeTimeHint CalculateSSTWriteHint(int level);
+
   // created_dirs remembers directory created, so that we don't need to call
   // the same data creation operation again.
   Status AddDirectories(
@@ -571,10 +568,6 @@ class ColumnFamilyData {
   // of its files (if missing)
   void RecoverEpochNumbers();
 
-  int GetUnflushedMemTableCountForWriteStallCheck() const {
-    return (mem_->IsEmpty() ? 0 : 1) + imm_.NumNotFlushed();
-  }
-
  private:
   friend class ColumnFamilySet;
   ColumnFamilyData(uint32_t id, const std::string& name,
@@ -599,15 +592,6 @@ class ColumnFamilyData {
   std::atomic<bool> initialized_;
   std::atomic<bool> dropped_;  // true if client dropped it
 
-  // When user-defined timestamps in memtable only feature is enabled, this
-  // flag indicates a successfully requested flush that should
-  // skip being rescheduled and haven't undergone the rescheduling check yet.
-  // This flag is cleared when a check skips rescheduling a FlushRequest.
-  // With this flag, automatic flushes in regular cases can continue to
-  // retain UDTs by getting rescheduled as usual while manual flushes and
-  // error recovery flushes will proceed without getting rescheduled.
-  std::atomic<bool> flush_skip_reschedule_;
-
   const InternalKeyComparator internal_comparator_;
   InternalTblPropCollFactories internal_tbl_prop_coll_factories_;
 

db/column_family_test.cc

@@ -23,7 +23,6 @@
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
-#include "rocksdb/listener.h"
 #include "rocksdb/utilities/object_registry.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
@@ -35,13 +34,6 @@
 #include "utilities/merge_operators.h"
 
 namespace ROCKSDB_NAMESPACE {
-namespace {
-std::string EncodeAsUint64(uint64_t number) {
-  std::string result;
-  PutFixed64(&result, number);
-  return result;
-}
-}  // namespace
 
 static const int kValueSize = 1000;
 
@@ -3067,20 +3059,12 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupForMarkedFiles) {
   WaitForCompaction();
   AssertFilesPerLevel("0,1", 0 /* cf */);
 
-  // We should calculate the limit by obtaining the number of env background
-  // threads, because the current test case will share the same env
-  // with another case that may have already increased the number of
-  // background threads which is larger than kParallelismLimit
-  const auto limit = env_->GetBackgroundThreads(Env::Priority::LOW);
-
   // Block the compaction thread pool so marked files accumulate in L0.
-  std::vector<std::shared_ptr<test::SleepingBackgroundTask>> sleeping_tasks;
-  for (int i = 0; i < limit; i++) {
-    sleeping_tasks.emplace_back(
-        std::make_shared<test::SleepingBackgroundTask>());
+  test::SleepingBackgroundTask sleeping_tasks[kParallelismLimit];
+  for (int i = 0; i < kParallelismLimit; i++) {
     env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   sleeping_tasks[i].get(), Env::Priority::LOW);
-    sleeping_tasks[i]->WaitUntilSleeping();
+                   &sleeping_tasks[i], Env::Priority::LOW);
+    sleeping_tasks[i].WaitUntilSleeping();
   }
 
   // Zero marked upper-level files. No speedup.
@@ -3099,9 +3083,9 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupForMarkedFiles) {
   ASSERT_EQ(kParallelismLimit, dbfull()->TEST_BGCompactionsAllowed());
   AssertFilesPerLevel("2,1", 0 /* cf */);
 
-  for (int i = 0; i < limit; i++) {
-    sleeping_tasks[i]->WakeUp();
-    sleeping_tasks[i]->WaitUntilDone();
+  for (int i = 0; i < kParallelismLimit; i++) {
+    sleeping_tasks[i].WakeUp();
+    sleeping_tasks[i].WaitUntilDone();
   }
 }
 
@@ -3186,8 +3170,6 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile1) {
   SpecialEnv env(Env::Default());
   db_options_.env = &env;
   db_options_.max_background_flushes = 1;
-  // When this option is removed, the test will need re-engineering
-  db_options_.background_close_inactive_wals = true;
   column_family_options_.memtable_factory.reset(
       test::NewSpecialSkipListFactory(2));
   Open();
@@ -3240,8 +3222,6 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile2) {
   env.SetBackgroundThreads(2, Env::HIGH);
   db_options_.env = &env;
   db_options_.max_background_flushes = 1;
-  // When this option is removed, the test will need re-engineering
-  db_options_.background_close_inactive_wals = true;
   column_family_options_.memtable_factory.reset(
       test::NewSpecialSkipListFactory(2));
   Open();
@@ -3299,8 +3279,6 @@ TEST_P(ColumnFamilyTest, ForwardIteratorCloseWALFile) {
   env.SetBackgroundThreads(2, Env::HIGH);
   db_options_.env = &env;
   db_options_.max_background_flushes = 1;
-  // When this option is removed, the test will need re-engineering
-  db_options_.background_close_inactive_wals = true;
   column_family_options_.memtable_factory.reset(
       test::NewSpecialSkipListFactory(3));
   column_family_options_.level0_file_num_compaction_trigger = 2;
@@ -3625,9 +3603,7 @@ TEST(ColumnFamilyTest, ValidateMemtableKVChecksumOption) {
 }
 
 // Tests the flushing behavior of a column family to retain user-defined
-// timestamp when `persist_user_defined_timestamp` is false. The behavior of
-// auto flush is it makes some effort to retain user-defined timestamps while
-// the behavior of manual flush is that it skips retaining UDTs.
+// timestamp when `persist_user_defined_timestamp` is false.
 class ColumnFamilyRetainUDTTest : public ColumnFamilyTestBase {
  public:
   ColumnFamilyRetainUDTTest() : ColumnFamilyTestBase(kLatestFormatVersion) {}
@@ -3645,27 +3621,6 @@ class ColumnFamilyRetainUDTTest : public ColumnFamilyTestBase {
     return db_->Put(WriteOptions(), handles_[cf], Slice(key), Slice(ts),
                     Slice(value));
   }
-
-  std::string Get(int cf, const std::string& key, const std::string& read_ts) {
-    ReadOptions ropts;
-    Slice timestamp = read_ts;
-    ropts.timestamp = &timestamp;
-    std::string value;
-    Status s = db_->Get(ropts, handles_[cf], Slice(key), &value);
-    if (s.IsNotFound()) {
-      return "NOT_FOUND";
-    } else if (s.ok()) {
-      return value;
-    }
-    return "";
-  }
-
-  void CheckEffectiveCutoffTime(uint64_t expected_cutoff) {
-    std::string effective_full_history_ts_low;
-    EXPECT_OK(
-        db_->GetFullHistoryTsLow(handles_[0], &effective_full_history_ts_low));
-    EXPECT_EQ(EncodeAsUint64(expected_cutoff), effective_full_history_ts_low);
-  }
 };
 
 class TestTsComparator : public Comparator {
@@ -3709,9 +3664,7 @@ TEST_F(ColumnFamilyRetainUDTTest, SanityCheck) {
   Close();
 }
 
-class AutoFlushRetainUDTTest : public ColumnFamilyRetainUDTTest {};
-
-TEST_F(AutoFlushRetainUDTTest, FullHistoryTsLowNotSet) {
+TEST_F(ColumnFamilyRetainUDTTest, FullHistoryTsLowNotSet) {
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::BackgroundFlush:CheckFlushRequest:cb", [&](void* arg) {
         ASSERT_NE(nullptr, arg);
@@ -3721,22 +3674,28 @@ TEST_F(AutoFlushRetainUDTTest, FullHistoryTsLowNotSet) {
 
   SyncPoint::GetInstance()->EnableProcessing();
   Open();
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  // No `full_history_ts_low` explicitly set by user, auto flush is continued
+  std::string write_ts;
+  PutFixed64(&write_ts, 1);
+  ASSERT_OK(Put(0, "foo", write_ts, "v1"));
+  // No `full_history_ts_low` explicitly set by user, flush is continued
   // without checking if its UDTs expired.
-  ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  ASSERT_OK(Flush(0));
 
   // After flush, `full_history_ts_low` should be automatically advanced to
   // the effective cutoff timestamp: write_ts + 1
-  CheckEffectiveCutoffTime(2);
+  std::string cutoff_ts;
+  PutFixed64(&cutoff_ts, 2);
+  std::string effective_full_history_ts_low;
+  ASSERT_OK(
+      db_->GetFullHistoryTsLow(handles_[0], &effective_full_history_ts_low));
+  ASSERT_EQ(cutoff_ts, effective_full_history_ts_low);
   Close();
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
-TEST_F(AutoFlushRetainUDTTest, AllKeysExpired) {
+TEST_F(ColumnFamilyRetainUDTTest, AllKeysExpired) {
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::BackgroundFlush:CheckFlushRequest:cb", [&](void* arg) {
         ASSERT_NE(nullptr, arg);
@@ -3746,22 +3705,27 @@ TEST_F(AutoFlushRetainUDTTest, AllKeysExpired) {
 
   SyncPoint::GetInstance()->EnableProcessing();
   Open();
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(3)));
-  // All keys expired w.r.t the configured `full_history_ts_low`, auto flush
-  // continue without the need for a re-schedule.
-  ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  std::string write_ts;
+  PutFixed64(&write_ts, 1);
+  ASSERT_OK(Put(0, "foo", write_ts, "v1"));
+  std::string cutoff_ts;
+  PutFixed64(&cutoff_ts, 3);
+  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], cutoff_ts));
+  // All keys expired w.r.t the configured `full_history_ts_low`, flush continue
+  // without the need for a re-schedule.
+  ASSERT_OK(Flush(0));
 
   // `full_history_ts_low` stays unchanged after flush.
-  CheckEffectiveCutoffTime(3);
+  std::string effective_full_history_ts_low;
+  ASSERT_OK(
+      db_->GetFullHistoryTsLow(handles_[0], &effective_full_history_ts_low));
+  ASSERT_EQ(cutoff_ts, effective_full_history_ts_low);
   Close();
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
 }
-
-TEST_F(AutoFlushRetainUDTTest, NotAllKeysExpiredFlushToAvoidWriteStall) {
+TEST_F(ColumnFamilyRetainUDTTest, NotAllKeysExpiredFlushToAvoidWriteStall) {
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::BackgroundFlush:CheckFlushRequest:cb", [&](void* arg) {
         ASSERT_NE(nullptr, arg);
@@ -3771,218 +3735,72 @@ TEST_F(AutoFlushRetainUDTTest, NotAllKeysExpiredFlushToAvoidWriteStall) {
 
   SyncPoint::GetInstance()->EnableProcessing();
   Open();
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(1)));
+  std::string cutoff_ts;
+  std::string write_ts;
+  PutFixed64(&write_ts, 1);
+  ASSERT_OK(Put(0, "foo", write_ts, "v1"));
+  PutFixed64(&cutoff_ts, 1);
+  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], cutoff_ts));
   ASSERT_OK(db_->SetOptions(handles_[0], {{"max_write_buffer_number", "1"}}));
-  // Not all keys expired, but auto flush is continued without a re-schedule
-  // because of risk of write stall.
-  ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  // Not all keys expired, but flush is continued without a re-schedule because
+  // of risk of write stall.
+  ASSERT_OK(Flush(0));
 
   // After flush, `full_history_ts_low` should be automatically advanced to
   // the effective cutoff timestamp: write_ts + 1
-  CheckEffectiveCutoffTime(2);
+  std::string effective_full_history_ts_low;
+  ASSERT_OK(
+      db_->GetFullHistoryTsLow(handles_[0], &effective_full_history_ts_low));
+
+  cutoff_ts.clear();
+  PutFixed64(&cutoff_ts, 2);
+  ASSERT_EQ(cutoff_ts, effective_full_history_ts_low);
   Close();
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
-TEST_F(AutoFlushRetainUDTTest, NotAllKeysExpiredFlushRescheduled) {
-  std::atomic<int> local_counter{1};
+TEST_F(ColumnFamilyRetainUDTTest, NotAllKeysExpiredFlushRescheduled) {
+  std::string cutoff_ts;
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::AfterRetainUDTReschedule:cb", [&](void* /*arg*/) {
         // Increasing full_history_ts_low so all keys expired after the initial
         // FlushRequest is rescheduled
-        ASSERT_OK(
-            db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(3)));
+        cutoff_ts.clear();
+        PutFixed64(&cutoff_ts, 3);
+        ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], cutoff_ts));
       });
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::BackgroundFlush:CheckFlushRequest:cb", [&](void* arg) {
         ASSERT_NE(nullptr, arg);
         auto reschedule_count = *static_cast<int*>(arg);
         ASSERT_EQ(2, reschedule_count);
-        local_counter.fetch_add(1);
       });
   SyncPoint::GetInstance()->EnableProcessing();
 
   Open();
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(1)));
+  std::string write_ts;
+  PutFixed64(&write_ts, 1);
+  ASSERT_OK(Put(0, "foo", write_ts, "v1"));
+  PutFixed64(&cutoff_ts, 1);
+  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], cutoff_ts));
   // Not all keys expired, and there is no risk of write stall. Flush is
   // rescheduled. The actual flush happens after `full_history_ts_low` is
   // increased to mark all keys expired.
-  ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-  // Make sure callback is not skipped.
-  ASSERT_EQ(2, local_counter);
+  ASSERT_OK(Flush(0));
 
-  CheckEffectiveCutoffTime(3);
+  std::string effective_full_history_ts_low;
+  ASSERT_OK(
+      db_->GetFullHistoryTsLow(handles_[0], &effective_full_history_ts_low));
+  // `full_history_ts_low` stays unchanged.
+  ASSERT_EQ(cutoff_ts, effective_full_history_ts_low);
   Close();
 
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
-class ManualFlushSkipRetainUDTTest : public ColumnFamilyRetainUDTTest {
- public:
-  // Write an entry with timestamp that is not expired w.r.t cutoff timestamp,
-  // and make sure automatic flush would be rescheduled to retain UDT.
-  void CheckAutomaticFlushRetainUDT(uint64_t write_ts) {
-    std::atomic<int> local_counter{1};
-    SyncPoint::GetInstance()->SetCallBack(
-        "DBImpl::AfterRetainUDTReschedule:cb", [&](void* /*arg*/) {
-          // Increasing full_history_ts_low so all keys expired after the
-          // initial FlushRequest is rescheduled
-          ASSERT_OK(db_->IncreaseFullHistoryTsLow(
-              handles_[0], EncodeAsUint64(write_ts + 1)));
-        });
-    SyncPoint::GetInstance()->SetCallBack(
-        "DBImpl::BackgroundFlush:CheckFlushRequest:cb", [&](void* arg) {
-          ASSERT_NE(nullptr, arg);
-          auto reschedule_count = *static_cast<int*>(arg);
-          ASSERT_EQ(2, reschedule_count);
-          local_counter.fetch_add(1);
-        });
-    SyncPoint::GetInstance()->EnableProcessing();
-    EXPECT_OK(Put(0, "foo", EncodeAsUint64(write_ts),
-                  "foo" + std::to_string(write_ts)));
-    EXPECT_OK(dbfull()->TEST_SwitchWAL());
-    EXPECT_OK(dbfull()->TEST_WaitForFlushMemTable());
-    // Make sure callback is not skipped.
-    EXPECT_EQ(2, local_counter);
-
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-  }
-};
-
-TEST_F(ManualFlushSkipRetainUDTTest, ManualFlush) {
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-
-  // Manual flush proceeds without trying to retain UDT.
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  ASSERT_OK(Flush(0));
-  CheckEffectiveCutoffTime(2);
-  CheckAutomaticFlushRetainUDT(3);
-
-  Close();
-}
-
-TEST_F(ManualFlushSkipRetainUDTTest, ManualCompaction) {
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-
-  // Manual compaction proceeds without trying to retain UDT.
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v2"));
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), handles_[0], nullptr, nullptr));
-  CheckEffectiveCutoffTime(2);
-  CheckAutomaticFlushRetainUDT(3);
-
-  Close();
-}
-
-TEST_F(ManualFlushSkipRetainUDTTest, BulkLoading) {
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-
-  // Test flush behavior in bulk loading scenarios.
-  Options options(db_options_, column_family_options_);
-  std::string sst_files_dir = dbname_ + "/sst_files/";
-  ASSERT_OK(DestroyDir(env_, sst_files_dir));
-  ASSERT_OK(env_->CreateDir(sst_files_dir));
-  SstFileWriter sst_file_writer(EnvOptions(), options);
-  std::string file1 = sst_files_dir + "file1.sst";
-  ASSERT_OK(sst_file_writer.Open(file1));
-  ASSERT_OK(sst_file_writer.Put("foo", EncodeAsUint64(0), "v2"));
-  ExternalSstFileInfo file1_info;
-  ASSERT_OK(sst_file_writer.Finish(&file1_info));
-
-  // Bulk loading in UDT mode doesn't support external file key range overlap
-  // with DB key range.
-  ASSERT_TRUE(db_->IngestExternalFile({file1}, IngestExternalFileOptions())
-                  .IsInvalidArgument());
-
-  std::string file2 = sst_files_dir + "file2.sst";
-  ASSERT_OK(sst_file_writer.Open(file2));
-  ASSERT_OK(sst_file_writer.Put("bar", EncodeAsUint64(0), "val"));
-  ExternalSstFileInfo file2_info;
-  ASSERT_OK(sst_file_writer.Finish(&file2_info));
-  // A successful bulk loading, and it doesn't trigger any flush. As a result
-  // the effective cutoff timestamp is also unchanged.
-  ASSERT_OK(db_->IngestExternalFile({file2}, IngestExternalFileOptions()));
-
-  ASSERT_EQ(Get(0, "foo", EncodeAsUint64(1)), "v1");
-  ASSERT_EQ(Get(0, "bar", EncodeAsUint64(0)), "val");
-  CheckEffectiveCutoffTime(0);
-  CheckAutomaticFlushRetainUDT(1);
-
-  Close();
-}
-
-TEST_F(ManualFlushSkipRetainUDTTest, AutomaticFlushQueued) {
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-
-  ASSERT_OK(Put(0, "foo", EncodeAsUint64(1), "v1"));
-  ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  CheckEffectiveCutoffTime(0);
-
-  // Default `max_write_buffer_number=2` used, writing another memtable can get
-  // automatic flush to proceed because of memory pressure. Not doing that so
-  // we can test automatic flush gets to proceed because of an ongoing manual
-  // flush attempt.
-  ASSERT_OK(Flush(0));
-  CheckEffectiveCutoffTime(2);
-  CheckAutomaticFlushRetainUDT(3);
-
-  Close();
-}
-
-TEST_F(ManualFlushSkipRetainUDTTest, ConcurrentManualFlushes) {
-  Open();
-  ASSERT_OK(db_->IncreaseFullHistoryTsLow(handles_[0], EncodeAsUint64(0)));
-
-  std::vector<ROCKSDB_NAMESPACE::port::Thread> manual_flush_tds;
-  std::atomic<int> next_ts{0};
-  std::mutex mtx;
-  std::condition_variable cv;
-
-  auto manual_flush = [&](int write_ts) {
-    {
-      std::unique_lock<std::mutex> lock(mtx);
-      cv.wait(lock,
-              [&write_ts, &next_ts] { return write_ts == next_ts.load(); });
-      ASSERT_OK(Put(0, "foo" + std::to_string(write_ts),
-                    EncodeAsUint64(write_ts),
-                    "val_" + std::to_string(write_ts)));
-      next_ts.fetch_add(1);
-      cv.notify_all();
-    }
-    if (write_ts % 2 == 0) {
-      ASSERT_OK(Flush(0));
-    } else {
-      ASSERT_OK(db_->CompactRange(CompactRangeOptions(), handles_[0], nullptr,
-                                  nullptr));
-    }
-  };
-
-  for (int write_ts = 0; write_ts < 10; write_ts++) {
-    manual_flush_tds.emplace_back(manual_flush, write_ts);
-  }
-
-  for (auto& td : manual_flush_tds) {
-    td.join();
-  }
-
-  CheckEffectiveCutoffTime(10);
-  CheckAutomaticFlushRetainUDT(11);
-  Close();
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/compaction/compaction.cc

@@ -63,9 +63,7 @@ uint64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
   return sum;
 }
 
-// TODO(hx235): consider making this function part of the construction so we
-// don't forget to call it
-void Compaction::FinalizeInputInfo(Version* _input_version) {
+void Compaction::SetInputVersion(Version* _input_version) {
   input_version_ = _input_version;
   cfd_ = input_version_->cfd();
 
@@ -686,11 +684,12 @@ bool Compaction::KeyRangeNotExistsBeyondOutputLevel(
 };
 
 // Mark (or clear) each file that is being compacted
-void Compaction::MarkFilesBeingCompacted(bool being_compacted) const {
+void Compaction::MarkFilesBeingCompacted(bool mark_as_compacted) {
   for (size_t i = 0; i < num_input_levels(); i++) {
     for (size_t j = 0; j < inputs_[i].size(); j++) {
-      assert(being_compacted != inputs_[i][j]->being_compacted);
-      inputs_[i][j]->being_compacted = being_compacted;
+      assert(mark_as_compacted ? !inputs_[i][j]->being_compacted
+                               : inputs_[i][j]->being_compacted);
+      inputs_[i][j]->being_compacted = mark_as_compacted;
     }
   }
 }
@@ -734,7 +733,7 @@ uint64_t Compaction::CalculateTotalInputSize() const {
   return size;
 }
 
-void Compaction::ReleaseCompactionFiles(const Status& status) {
+void Compaction::ReleaseCompactionFiles(Status status) {
   MarkFilesBeingCompacted(false);
   cfd_->compaction_picker()->ReleaseCompactionFiles(this, status);
 }
@@ -865,11 +864,6 @@ bool Compaction::ShouldFormSubcompactions() const {
     return false;
   }
 
-  if (cfd_->ioptions()->table_factory->Name() ==
-      TableFactory::kPlainTableName()) {
-    return false;
-  }
-
   // Round-Robin pri under leveled compaction allows subcompactions by default
   // and the number of subcompactions can be larger than max_subcompactions_
   if (cfd_->ioptions()->compaction_pri == kRoundRobin &&

db/compaction/compaction.h

@@ -230,7 +230,7 @@ class Compaction {
   // Delete this compaction from the list of running compactions.
   //
   // Requirement: DB mutex held
-  void ReleaseCompactionFiles(const Status& status);
+  void ReleaseCompactionFiles(Status status);
 
   // Returns the summary of the compaction in "output" with maximum "len"
   // in bytes.  The caller is responsible for the memory management of
@@ -289,7 +289,14 @@ class Compaction {
   // is the sum of all input file sizes.
   uint64_t OutputFilePreallocationSize() const;
 
-  void FinalizeInputInfo(Version* input_version);
+  // TODO(hx235): eventually we should consider `InitInputTableProperties()`'s
+  // status and fail the compaction if needed
+  // TODO(hx235): consider making this function part of the construction so we
+  // don't forget to call it
+  void FinalizeInputInfo(Version* input_version) {
+    SetInputVersion(input_version);
+    InitInputTableProperties().PermitUncheckedError();
+  }
 
   struct InputLevelSummaryBuffer {
     char buffer[128];
@@ -326,16 +333,6 @@ class Compaction {
       int output_level, VersionStorageInfo* vstorage,
       const std::vector<CompactionInputFiles>& inputs);
 
-  // TODO(hx235): eventually we should consider `InitInputTableProperties()`'s
-  // status and fail the compaction if needed
-  //
-  // May open and read table files for table property.
-  // Should not be called while holding mutex_.
-  const TablePropertiesCollection& GetOrInitInputTableProperties() {
-    InitInputTableProperties().PermitUncheckedError();
-    return input_table_properties_;
-  }
-
   const TablePropertiesCollection& GetInputTableProperties() const {
     return input_table_properties_;
   }
@@ -435,13 +432,14 @@ class Compaction {
                                       const int start_level,
                                       const int output_level);
 
-  // mark (or clear) all files that are being compacted
-  void MarkFilesBeingCompacted(bool being_compacted) const;
-
  private:
+  void SetInputVersion(Version* input_version);
 
   Status InitInputTableProperties();
 
+  // mark (or clear) all files that are being compacted
+  void MarkFilesBeingCompacted(bool mark_as_compacted);
+
   // get the smallest and largest key present in files to be compacted
   static void GetBoundaryKeys(VersionStorageInfo* vstorage,
                               const std::vector<CompactionInputFiles>& inputs,

db/compaction/compaction_iterator.cc

@@ -25,7 +25,6 @@ namespace ROCKSDB_NAMESPACE {
 CompactionIterator::CompactionIterator(
     InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
     SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-    SequenceNumber earliest_snapshot,
     SequenceNumber earliest_write_conflict_snapshot,
     SequenceNumber job_snapshot, const SnapshotChecker* snapshot_checker,
     Env* env, bool report_detailed_time, bool expect_valid_internal_key,
@@ -41,7 +40,7 @@ CompactionIterator::CompactionIterator(
     const SequenceNumber preserve_time_min_seqno,
     const SequenceNumber preclude_last_level_min_seqno)
     : CompactionIterator(
-          input, cmp, merge_helper, last_sequence, snapshots, earliest_snapshot,
+          input, cmp, merge_helper, last_sequence, snapshots,
           earliest_write_conflict_snapshot, job_snapshot, snapshot_checker, env,
           report_detailed_time, expect_valid_internal_key, range_del_agg,
           blob_file_builder, allow_data_in_errors, enforce_single_del_contracts,
@@ -55,7 +54,6 @@ CompactionIterator::CompactionIterator(
 CompactionIterator::CompactionIterator(
     InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
     SequenceNumber /*last_sequence*/, std::vector<SequenceNumber>* snapshots,
-    SequenceNumber earliest_snapshot,
     SequenceNumber earliest_write_conflict_snapshot,
     SequenceNumber job_snapshot, const SnapshotChecker* snapshot_checker,
     Env* env, bool report_detailed_time, bool expect_valid_internal_key,
@@ -93,7 +91,9 @@ CompactionIterator::CompactionIterator(
       // snapshots_ cannot be nullptr, but we will assert later in the body of
       // the constructor.
       visible_at_tip_(snapshots_ ? snapshots_->empty() : false),
-      earliest_snapshot_(earliest_snapshot),
+      earliest_snapshot_(!snapshots_ || snapshots_->empty()
+                             ? kMaxSequenceNumber
+                             : snapshots_->at(0)),
       info_log_(info_log),
       allow_data_in_errors_(allow_data_in_errors),
       enforce_single_del_contracts_(enforce_single_del_contracts),

db/compaction/compaction_iterator.h

@@ -203,7 +203,6 @@ class CompactionIterator {
   CompactionIterator(
       InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
       SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_snapshot,
       SequenceNumber earliest_write_conflict_snapshot,
       SequenceNumber job_snapshot, const SnapshotChecker* snapshot_checker,
       Env* env, bool report_detailed_time, bool expect_valid_internal_key,
@@ -223,7 +222,6 @@ class CompactionIterator {
   CompactionIterator(
       InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
       SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_snapshot,
       SequenceNumber earliest_write_conflict_snapshot,
       SequenceNumber job_snapshot, const SnapshotChecker* snapshot_checker,
       Env* env, bool report_detailed_time, bool expect_valid_internal_key,

db/compaction/compaction_iterator_test.cc

@@ -296,7 +296,6 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
     iter_->SeekToFirst();
     c_iter_.reset(new CompactionIterator(
         iter_.get(), cmp_, merge_helper_.get(), last_sequence, &snapshots_,
-        snapshots_.empty() ? kMaxSequenceNumber : snapshots_.at(0),
         earliest_write_conflict_snapshot, kMaxSequenceNumber,
         snapshot_checker_.get(), Env::Default(),
         false /* report_detailed_time */, false, range_del_agg_.get(),

db/compaction/compaction_job.cc

@@ -174,9 +174,6 @@ CompactionJob::CompactionJob(
       db_mutex_(db_mutex),
       db_error_handler_(db_error_handler),
       existing_snapshots_(std::move(existing_snapshots)),
-      earliest_snapshot_(existing_snapshots_.empty()
-                             ? kMaxSequenceNumber
-                             : existing_snapshots_.at(0)),
       earliest_write_conflict_snapshot_(earliest_write_conflict_snapshot),
       snapshot_checker_(snapshot_checker),
       job_context_(job_context),
@@ -251,13 +248,12 @@ void CompactionJob::Prepare() {
 
   // Generate file_levels_ for compaction before making Iterator
   auto* c = compact_->compaction;
-  [[maybe_unused]] ColumnFamilyData* cfd = c->column_family_data();
+  ColumnFamilyData* cfd = c->column_family_data();
   assert(cfd != nullptr);
-  const VersionStorageInfo* storage_info = c->input_version()->storage_info();
-  assert(storage_info);
-  assert(storage_info->NumLevelFiles(compact_->compaction->level()) > 0);
+  assert(cfd->current()->storage_info()->NumLevelFiles(
+             compact_->compaction->level()) > 0);
 
-  write_hint_ = storage_info->CalculateSSTWriteHint(c->output_level());
+  write_hint_ = cfd->CalculateSSTWriteHint(c->output_level());
   bottommost_level_ = c->bottommost_level();
 
   if (c->ShouldFormSubcompactions()) {
@@ -286,7 +282,6 @@ void CompactionJob::Prepare() {
 
   // collect all seqno->time information from the input files which will be used
   // to encode seqno->time to the output files.
-
   uint64_t preserve_time_duration =
       std::max(c->immutable_options()->preserve_internal_time_seconds,
                c->immutable_options()->preclude_last_level_data_seconds);
@@ -298,8 +293,8 @@ void CompactionJob::Prepare() {
     for (const auto& each_level : *c->inputs()) {
       for (const auto& fmd : each_level.files) {
         std::shared_ptr<const TableProperties> tp;
-        Status s = c->input_version()->GetTableProperties(read_options, &tp,
-                                                          fmd, nullptr);
+        Status s =
+            cfd->current()->GetTableProperties(read_options, &tp, fmd, nullptr);
         if (s.ok()) {
           s = seqno_to_time_mapping_.DecodeFrom(tp->seqno_to_time_mapping);
         }
@@ -324,11 +319,28 @@ void CompactionJob::Prepare() {
       seqno_to_time_mapping_.Enforce();
     } else {
       seqno_to_time_mapping_.Enforce(_current_time);
-      seqno_to_time_mapping_.GetCurrentTieringCutoffSeqnos(
-          static_cast<uint64_t>(_current_time),
-          c->immutable_options()->preserve_internal_time_seconds,
-          c->immutable_options()->preclude_last_level_data_seconds,
-          &preserve_time_min_seqno_, &preclude_last_level_min_seqno_);
+      uint64_t preserve_time =
+          static_cast<uint64_t>(_current_time) > preserve_time_duration
+              ? _current_time - preserve_time_duration
+              : 0;
+      // GetProximalSeqnoBeforeTime tells us the last seqno known to have been
+      // written at or before the given time. + 1 to get the minimum we should
+      // preserve without excluding anything that might have been written on or
+      // after the given time.
+      preserve_time_min_seqno_ =
+          seqno_to_time_mapping_.GetProximalSeqnoBeforeTime(preserve_time) + 1;
+      if (c->immutable_options()->preclude_last_level_data_seconds > 0) {
+        uint64_t preclude_last_level_time =
+            static_cast<uint64_t>(_current_time) >
+                    c->immutable_options()->preclude_last_level_data_seconds
+                ? _current_time -
+                      c->immutable_options()->preclude_last_level_data_seconds
+                : 0;
+        preclude_last_level_min_seqno_ =
+            seqno_to_time_mapping_.GetProximalSeqnoBeforeTime(
+                preclude_last_level_time) +
+            1;
+      }
     }
     // For accuracy of the GetProximalSeqnoBeforeTime queries above, we only
     // limit the capacity after them.
@@ -469,11 +481,6 @@ void CompactionJob::GenSubcompactionBoundaries() {
   ReadOptions read_options(Env::IOActivity::kCompaction);
   read_options.rate_limiter_priority = GetRateLimiterPriority();
   auto* c = compact_->compaction;
-  if (c->immutable_options()->table_factory->Name() ==
-      TableFactory::kPlainTableName()) {
-    return;
-  }
-
   if (c->max_subcompactions() <= 1 &&
       !(c->immutable_options()->compaction_pri == kRoundRobin &&
         c->immutable_options()->compaction_style == kCompactionStyleLevel)) {
@@ -627,7 +634,6 @@ Status CompactionJob::Run() {
   const size_t num_threads = compact_->sub_compact_states.size();
   assert(num_threads > 0);
   const uint64_t start_micros = db_options_.clock->NowMicros();
-  compact_->compaction->GetOrInitInputTableProperties();
 
   // Launch a thread for each of subcompactions 1...num_threads-1
   std::vector<port::Thread> thread_pool;
@@ -806,12 +812,6 @@ Status CompactionJob::Run() {
     }
   }
 
-  // Before the compaction starts, is_remote_compaction was set to true if
-  // compaction_service is set. We now know whether each sub_compaction was
-  // done remotely or not. Reset is_remote_compaction back to false and allow
-  // AggregateCompactionStats() to set the right value.
-  compaction_job_stats_->is_remote_compaction = false;
-
   // Finish up all bookkeeping to unify the subcompaction results.
   compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
   uint64_t num_input_range_del = 0;
@@ -1090,7 +1090,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     }
     // fallback to local compaction
     assert(comp_status == CompactionServiceJobStatus::kUseLocal);
-    sub_compact->compaction_job_stats.is_remote_compaction = false;
   }
 
   uint64_t prev_cpu_micros = db_options_.clock->CPUMicros();
@@ -1296,9 +1295,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
 
   auto c_iter = std::make_unique<CompactionIterator>(
       input, cfd->user_comparator(), &merge, versions_->LastSequence(),
-      &existing_snapshots_, earliest_snapshot_,
-      earliest_write_conflict_snapshot_, job_snapshot_seq, snapshot_checker_,
-      env_, ShouldReportDetailedTime(env_, stats_),
+      &existing_snapshots_, earliest_write_conflict_snapshot_, job_snapshot_seq,
+      snapshot_checker_, env_, ShouldReportDetailedTime(env_, stats_),
       /*expect_valid_internal_key=*/true, range_del_agg.get(),
       blob_file_builder.get(), db_options_.allow_data_in_errors,
       db_options_.enforce_single_del_contracts, manual_compaction_canceled_,
@@ -1971,10 +1969,7 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
       cfd->GetName(), sub_compact->compaction->output_level(),
       bottommost_level_, TableFileCreationReason::kCompaction,
       0 /* oldest_key_time */, current_time, db_id_, db_session_id_,
-      sub_compact->compaction->max_output_file_size(), file_number,
-      preclude_last_level_min_seqno_ == kMaxSequenceNumber
-          ? preclude_last_level_min_seqno_
-          : std::min(earliest_snapshot_, preclude_last_level_min_seqno_));
+      sub_compact->compaction->max_output_file_size(), file_number);
 
   outputs.NewBuilder(tboptions);
 

db/compaction/compaction_job.h

@@ -209,8 +209,6 @@ class CompactionJob {
   // Returns true iff compaction_stats_.stats.num_input_records and
   // num_input_range_del are calculated successfully.
   bool UpdateCompactionStats(uint64_t* num_input_range_del = nullptr);
-  virtual void UpdateCompactionJobStats(
-      const InternalStats::CompactionStats& stats) const;
   void LogCompaction();
   virtual void RecordCompactionIOStats();
   void CleanupCompaction();
@@ -281,7 +279,8 @@ class CompactionJob {
                                   bool* compaction_released);
   Status OpenCompactionOutputFile(SubcompactionState* sub_compact,
                                   CompactionOutputs& outputs);
-
+  void UpdateCompactionJobStats(
+      const InternalStats::CompactionStats& stats) const;
   void RecordDroppedKeys(const CompactionIterationStats& c_iter_stats,
                          CompactionJobStats* compaction_job_stats = nullptr);
 
@@ -315,8 +314,6 @@ class CompactionJob {
   // deleted because that version is not visible in any snapshot.
   std::vector<SequenceNumber> existing_snapshots_;
 
-  SequenceNumber earliest_snapshot_;
-
   // This is the earliest snapshot that could be used for write-conflict
   // checking by a transaction.  For any user-key newer than this snapshot, we
   // should make sure not to remove evidence that a write occurred.
@@ -378,7 +375,9 @@ class CompactionJob {
 // doesn't contain the LSM tree information, which is passed though MANIFEST
 // file.
 struct CompactionServiceInput {
-  std::string cf_name;
+  ColumnFamilyDescriptor column_family;
+
+  DBOptions db_options;
 
   std::vector<SequenceNumber> snapshots;
 
@@ -397,12 +396,13 @@ struct CompactionServiceInput {
   bool has_end = false;
   std::string end;
 
-  uint64_t options_file_number;
-
   // serialization interface to read and write the object
   static Status Read(const std::string& data_str, CompactionServiceInput* obj);
   Status Write(std::string* output);
 
+  // Initialize a dummy ColumnFamilyDescriptor
+  CompactionServiceInput() : column_family("", ColumnFamilyOptions()) {}
+
 #ifndef NDEBUG
   bool TEST_Equals(CompactionServiceInput* other);
   bool TEST_Equals(CompactionServiceInput* other, std::string* mismatch);
@@ -416,22 +416,19 @@ struct CompactionServiceOutputFile {
   SequenceNumber largest_seqno;
   std::string smallest_internal_key;
   std::string largest_internal_key;
-  uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;
-  uint64_t file_creation_time = kUnknownFileCreationTime;
-  uint64_t epoch_number = kUnknownEpochNumber;
-  std::string file_checksum = kUnknownFileChecksum;
-  std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
+  uint64_t oldest_ancester_time;
+  uint64_t file_creation_time;
+  uint64_t epoch_number;
   uint64_t paranoid_hash;
   bool marked_for_compaction;
-  UniqueId64x2 unique_id{};
+  UniqueId64x2 unique_id;
 
   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 _epoch_number, const std::string& _file_checksum,
-      const std::string& _file_checksum_func_name, uint64_t _paranoid_hash,
+      uint64_t _epoch_number, uint64_t _paranoid_hash,
       bool _marked_for_compaction, UniqueId64x2 _unique_id)
       : file_name(name),
         smallest_seqno(smallest),
@@ -441,8 +438,6 @@ struct CompactionServiceOutputFile {
         oldest_ancester_time(_oldest_ancester_time),
         file_creation_time(_file_creation_time),
         epoch_number(_epoch_number),
-        file_checksum(_file_checksum),
-        file_checksum_func_name(_file_checksum_func_name),
         paranoid_hash(_paranoid_hash),
         marked_for_compaction(_marked_for_compaction),
         unique_id(std::move(_unique_id)) {}
@@ -459,6 +454,9 @@ struct CompactionServiceResult {
   // location of the output files
   std::string output_path;
 
+  // some statistics about the compaction
+  uint64_t num_output_records = 0;
+  uint64_t total_bytes = 0;
   uint64_t bytes_read = 0;
   uint64_t bytes_written = 0;
   CompactionJobStats stats;
@@ -504,9 +502,6 @@ class CompactionServiceCompactionJob : private CompactionJob {
  protected:
   void RecordCompactionIOStats() override;
 
-  void UpdateCompactionJobStats(
-      const InternalStats::CompactionStats& stats) const override;
-
  private:
   // Get table file name in output_path
   std::string GetTableFileName(uint64_t file_number) override;

db/compaction/compaction_job_test.cc

@@ -50,8 +50,7 @@ void VerifyInitializationOfCompactionJobStats(
   ASSERT_EQ(compaction_job_stats.num_output_records, 0U);
   ASSERT_EQ(compaction_job_stats.num_output_files, 0U);
 
-  ASSERT_TRUE(compaction_job_stats.is_manual_compaction);
-  ASSERT_FALSE(compaction_job_stats.is_remote_compaction);
+  ASSERT_EQ(compaction_job_stats.is_manual_compaction, true);
 
   ASSERT_EQ(compaction_job_stats.total_input_bytes, 0U);
   ASSERT_EQ(compaction_job_stats.total_output_bytes, 0U);
@@ -546,14 +545,14 @@ class CompactionJobTestBase : public testing::Test {
     ASSERT_OK(s);
     db_options_.info_log = info_log;
 
-    versions_.reset(
-        new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
-                       &write_buffer_manager_, &write_controller_,
-                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                       test::kUnitTestDbId, /*db_session_id=*/"",
-                       /*daily_offpeak_time_utc=*/"",
-                       /*error_handler=*/nullptr, /*read_only=*/false));
+    versions_.reset(new VersionSet(
+        dbname_, &db_options_, env_options_, table_cache_.get(),
+        &write_buffer_manager_, &write_controller_,
+        /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
+        /*db_id=*/"", /*db_session_id=*/"", /*daily_offpeak_time_utc=*/"",
+        /*error_handler=*/nullptr, /*read_only=*/false));
     compaction_job_stats_.Reset();
+    ASSERT_OK(SetIdentityFile(WriteOptions(), env_, dbname_));
 
     VersionEdit new_db;
     new_db.SetLogNumber(0);
@@ -576,8 +575,7 @@ class CompactionJobTestBase : public testing::Test {
     }
     ASSERT_OK(s);
     // Make "CURRENT" file that points to the new manifest file.
-    s = SetCurrentFile(WriteOptions(), fs_.get(), dbname_, 1,
-                       Temperature::kUnknown, nullptr);
+    s = SetCurrentFile(WriteOptions(), fs_.get(), dbname_, 1, nullptr);
 
     ASSERT_OK(s);
 
@@ -1569,7 +1567,17 @@ TEST_F(CompactionJobTest, InputSerialization) {
   const int kStrMaxLen = 1000;
   Random rnd(static_cast<uint32_t>(time(nullptr)));
   Random64 rnd64(time(nullptr));
-  input.cf_name = rnd.RandomString(rnd.Uniform(kStrMaxLen));
+  input.column_family.name = rnd.RandomString(rnd.Uniform(kStrMaxLen));
+  input.column_family.options.comparator = ReverseBytewiseComparator();
+  input.column_family.options.max_bytes_for_level_base =
+      rnd64.Uniform(UINT64_MAX);
+  input.column_family.options.disable_auto_compactions = rnd.OneIn(2);
+  input.column_family.options.compression = kZSTD;
+  input.column_family.options.compression_opts.level = 4;
+  input.db_options.max_background_flushes = 10;
+  input.db_options.paranoid_checks = rnd.OneIn(2);
+  input.db_options.statistics = CreateDBStatistics();
+  input.db_options.env = env_;
   while (!rnd.OneIn(10)) {
     input.snapshots.emplace_back(rnd64.Uniform(UINT64_MAX));
   }
@@ -1597,10 +1605,10 @@ TEST_F(CompactionJobTest, InputSerialization) {
   ASSERT_TRUE(deserialized1.TEST_Equals(&input));
 
   // Test mismatch
-  deserialized1.output_level += 10;
+  deserialized1.db_options.max_background_flushes += 10;
   std::string mismatch;
   ASSERT_FALSE(deserialized1.TEST_Equals(&input, &mismatch));
-  ASSERT_EQ(mismatch, "output_level");
+  ASSERT_EQ(mismatch, "db_options.max_background_flushes");
 
   // Test unknown field
   CompactionServiceInput deserialized2;
@@ -1656,30 +1664,20 @@ TEST_F(CompactionJobTest, ResultSerialization) {
   };
   result.status =
       status_list.at(rnd.Uniform(static_cast<int>(status_list.size())));
-
-  std::string file_checksum = rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen));
-  std::string file_checksum_func_name = "MyAwesomeChecksumGenerator";
   while (!rnd.OneIn(10)) {
     UniqueId64x2 id{rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX)};
     result.output_files.emplace_back(
-        rnd.RandomString(rnd.Uniform(kStrMaxLen)) /* file_name */,
-        rnd64.Uniform(UINT64_MAX) /* smallest_seqno */,
-        rnd64.Uniform(UINT64_MAX) /* largest_seqno */,
-        rnd.RandomBinaryString(
-            rnd.Uniform(kStrMaxLen)) /* smallest_internal_key */,
-        rnd.RandomBinaryString(
-            rnd.Uniform(kStrMaxLen)) /* largest_internal_key */,
-        rnd64.Uniform(UINT64_MAX) /* oldest_ancester_time */,
-        rnd64.Uniform(UINT64_MAX) /* file_creation_time */,
-        rnd64.Uniform(UINT64_MAX) /* epoch_number */,
-        file_checksum /* file_checksum */,
-        file_checksum_func_name /* file_checksum_func_name */,
-        rnd64.Uniform(UINT64_MAX) /* paranoid_hash */,
-        rnd.OneIn(2) /* marked_for_compaction */, id);
+        rnd.RandomString(rnd.Uniform(kStrMaxLen)), rnd64.Uniform(UINT64_MAX),
+        rnd64.Uniform(UINT64_MAX),
+        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
+        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
+        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX),
+        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX), rnd.OneIn(2), id);
   }
   result.output_level = rnd.Uniform(10);
   result.output_path = rnd.RandomString(rnd.Uniform(kStrMaxLen));
-  result.stats.num_output_records = rnd64.Uniform(UINT64_MAX);
+  result.num_output_records = rnd64.Uniform(UINT64_MAX);
+  result.total_bytes = rnd64.Uniform(UINT64_MAX);
   result.bytes_read = 123;
   result.bytes_written = rnd64.Uniform(UINT64_MAX);
   result.stats.elapsed_micros = rnd64.Uniform(UINT64_MAX);
@@ -1710,10 +1708,6 @@ TEST_F(CompactionJobTest, ResultSerialization) {
     ASSERT_FALSE(deserialized_tmp.TEST_Equals(&result, &mismatch));
     ASSERT_EQ(mismatch, "output_files.unique_id");
     deserialized_tmp.status.PermitUncheckedError();
-
-    ASSERT_EQ(deserialized_tmp.output_files[0].file_checksum, file_checksum);
-    ASSERT_EQ(deserialized_tmp.output_files[0].file_checksum_func_name,
-              file_checksum_func_name);
   }
 
   // Test unknown field

db/compaction/compaction_outputs.h

@@ -62,9 +62,8 @@ class CompactionOutputs {
   }
 
   // TODO: Remove it when remote compaction support tiered compaction
-  void AddBytesWritten(uint64_t bytes) { stats_.bytes_written += bytes; }
+  void SetTotalBytes(uint64_t bytes) { stats_.bytes_written += bytes; }
   void SetNumOutputRecords(uint64_t num) { stats_.num_output_records = num; }
-  void SetNumOutputFiles(uint64_t num) { stats_.num_output_files = num; }
 
   // TODO: Move the BlobDB builder into CompactionOutputs
   const std::vector<BlobFileAddition>& GetBlobFileAdditions() const {

db/compaction/compaction_picker.cc

@@ -133,8 +133,7 @@ CompactionPicker::CompactionPicker(const ImmutableOptions& ioptions,
 CompactionPicker::~CompactionPicker() = default;
 
 // Delete this compaction from the list of running compactions.
-void CompactionPicker::ReleaseCompactionFiles(Compaction* c,
-                                              const Status& status) {
+void CompactionPicker::ReleaseCompactionFiles(Compaction* c, Status status) {
   UnregisterCompaction(c);
   if (!status.ok()) {
     c->ResetNextCompactionIndex();
@@ -341,8 +340,8 @@ Compaction* CompactionPicker::CompactFiles(
 #ifndef NDEBUG
   assert(input_files.size());
   // This compaction output should not overlap with a running compaction as
-  // `SanitizeAndConvertCompactionInputFiles` should've checked earlier and db
-  // mutex shouldn't have been released since.
+  // `SanitizeCompactionInputFiles` should've checked earlier and db mutex
+  // shouldn't have been released since.
   int start_level = Compaction::kInvalidLevel;
   for (const auto& in : input_files) {
     // input_files should already be sorted by level
@@ -1041,18 +1040,19 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
       }
     }
   }
+  if (RangeOverlapWithCompaction(smallestkey, largestkey, output_level)) {
+    return Status::Aborted(
+        "A running compaction is writing to the same output level in an "
+        "overlapping key range");
+  }
   return Status::OK();
 }
 
-Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
+Status CompactionPicker::SanitizeCompactionInputFiles(
     std::unordered_set<uint64_t>* input_files,
-    const ColumnFamilyMetaData& cf_meta, const int output_level,
-    const VersionStorageInfo* vstorage,
-    std::vector<CompactionInputFiles>* converted_input_files) const {
+    const ColumnFamilyMetaData& cf_meta, const int output_level) const {
   assert(static_cast<int>(cf_meta.levels.size()) - 1 ==
          cf_meta.levels[cf_meta.levels.size() - 1].level);
-  assert(converted_input_files);
-
   if (output_level >= static_cast<int>(cf_meta.levels.size())) {
     return Status::InvalidArgument(
         "Output level for column family " + cf_meta.name +
@@ -1078,6 +1078,7 @@ Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
 
   Status s = SanitizeCompactionInputFilesForAllLevels(input_files, cf_meta,
                                                       output_level);
+
   if (!s.ok()) {
     return s;
   }
@@ -1118,22 +1119,6 @@ Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
     }
   }
 
-  s = GetCompactionInputsFromFileNumbers(converted_input_files, input_files,
-                                         vstorage, CompactionOptions());
-  if (!s.ok()) {
-    return s;
-  }
-  assert(converted_input_files->size() > 0);
-  if (output_level != 0 &&
-      FilesRangeOverlapWithCompaction(
-          *converted_input_files, output_level,
-          Compaction::EvaluatePenultimateLevel(
-              vstorage, ioptions_, (*converted_input_files)[0].level,
-              output_level))) {
-    return Status::Aborted(
-        "A running compaction is writing to the same output level(s) in an "
-        "overlapping key range");
-  }
   return Status::OK();
 }
 

db/compaction/compaction_picker.h

@@ -86,25 +86,21 @@ class CompactionPicker {
 
   virtual bool NeedsCompaction(const VersionStorageInfo* vstorage) const = 0;
 
-  // Sanitize the input set of compaction input files and convert it to
-  // `std::vector<CompactionInputFiles>` in the output parameter
-  // `converted_input_files`.
-  // When the input parameters do not describe a valid
-  // compaction, the function will try to fix the input_files by adding
-  // necessary files.  If it's not possible to convert an invalid input_files
-  // into a valid one by adding more files, the function will return a
-  // non-ok status with specific reason.
-  //
-  Status SanitizeAndConvertCompactionInputFiles(
-      std::unordered_set<uint64_t>* input_files,
-      const ColumnFamilyMetaData& cf_meta, const int output_level,
-      const VersionStorageInfo* vstorage,
-      std::vector<CompactionInputFiles>* converted_input_files) const;
+// Sanitize the input set of compaction input files.
+// When the input parameters do not describe a valid compaction, the
+// function will try to fix the input_files by adding necessary
+// files.  If it's not possible to conver an invalid input_files
+// into a valid one by adding more files, the function will return a
+// non-ok status with specific reason.
+//
+  Status SanitizeCompactionInputFiles(std::unordered_set<uint64_t>* input_files,
+                                      const ColumnFamilyMetaData& cf_meta,
+                                      const int output_level) const;
 
   // Free up the files that participated in a compaction
   //
   // Requirement: DB mutex held
-  void ReleaseCompactionFiles(Compaction* c, const Status& status);
+  void ReleaseCompactionFiles(Compaction* c, Status status);
 
   // Returns true if any one of the specified files are being compacted
   bool AreFilesInCompaction(const std::vector<FileMetaData*>& files);
@@ -113,8 +109,8 @@ class CompactionPicker {
   // object.
   //
   // Caller must provide a set of input files that has been passed through
-  // `SanitizeAndConvertCompactionInputFiles` earlier. The lock should not be
-  // released between that call and this one.
+  // `SanitizeCompactionInputFiles` earlier. The lock should not be released
+  // between that call and this one.
   Compaction* CompactFiles(const CompactionOptions& compact_options,
                            const std::vector<CompactionInputFiles>& input_files,
                            int output_level, VersionStorageInfo* vstorage,
@@ -124,7 +120,6 @@ class CompactionPicker {
 
   // Converts a set of compaction input file numbers into
   // a list of CompactionInputFiles.
-  // TODO(hx235): remove the unused paramter `compact_options`
   Status GetCompactionInputsFromFileNumbers(
       std::vector<CompactionInputFiles>* input_files,
       std::unordered_set<uint64_t>* input_set,
@@ -230,8 +225,8 @@ class CompactionPicker {
  protected:
   const ImmutableOptions& ioptions_;
 
-  // A helper function to SanitizeAndConvertCompactionInputFiles() that
-  // sanitizes "input_files" by adding necessary files.
+// A helper function to SanitizeCompactionInputFiles() that
+// sanitizes "input_files" by adding necessary files.
   virtual Status SanitizeCompactionInputFilesForAllLevels(
       std::unordered_set<uint64_t>* input_files,
       const ColumnFamilyMetaData& cf_meta, const int output_level) const;

db/compaction/compaction_picker_fifo.cc

@@ -294,7 +294,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
 Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
     const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
     const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer) const {
+    LogBuffer* log_buffer) {
   const std::vector<FileTemperatureAge>& ages =
       mutable_cf_options.compaction_options_fifo
           .file_temperature_age_thresholds;
@@ -344,10 +344,12 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
   Temperature compaction_target_temp = Temperature::kLastTemperature;
   if (current_time > min_age) {
     uint64_t create_time_threshold = current_time - min_age;
+    uint64_t compaction_size = 0;
     // We will ideally identify a file qualifying for temperature change by
     // knowing the timestamp for the youngest entry in the file. However, right
     // now we don't have the information. We infer it by looking at timestamp of
     // the previous file's (which is just younger) oldest entry's timestamp.
+    Temperature cur_target_temp;
     // avoid index underflow
     assert(level_files.size() >= 1);
     for (size_t index = level_files.size() - 1; index >= 1; --index) {
@@ -372,7 +374,7 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
         // cur_file is too fresh
         break;
       }
-      Temperature cur_target_temp = ages[0].temperature;
+      cur_target_temp = ages[0].temperature;
       for (size_t i = 1; i < ages.size(); ++i) {
         if (current_time >= ages[i].age &&
             oldest_ancestor_time <= current_time - ages[i].age) {
@@ -380,20 +382,35 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
         }
       }
       if (cur_file->temperature == cur_target_temp) {
-        continue;
+        if (inputs[0].empty()) {
+          continue;
+        } else {
+          break;
+        }
       }
 
       // cur_file needs to change temperature
-      assert(compaction_target_temp == Temperature::kLastTemperature);
-      compaction_target_temp = cur_target_temp;
-      inputs[0].files.push_back(cur_file);
-      ROCKS_LOG_BUFFER(
-          log_buffer,
-          "[%s] FIFO compaction: picking file %" PRIu64
-          " with next file's oldest time %" PRIu64 " for temperature %s.",
-          cf_name.c_str(), cur_file->fd.GetNumber(), oldest_ancestor_time,
-          temperature_to_string[cur_target_temp].c_str());
-      break;
+      if (compaction_target_temp == Temperature::kLastTemperature) {
+        assert(inputs[0].empty());
+        compaction_target_temp = cur_target_temp;
+      } else if (cur_target_temp != compaction_target_temp) {
+        assert(!inputs[0].empty());
+        break;
+      }
+      if (inputs[0].empty() || compaction_size + cur_file->fd.GetFileSize() <=
+                                   mutable_cf_options.max_compaction_bytes) {
+        inputs[0].files.push_back(cur_file);
+        compaction_size += cur_file->fd.GetFileSize();
+        ROCKS_LOG_BUFFER(
+            log_buffer,
+            "[%s] FIFO compaction: picking file %" PRIu64
+            " with next file's oldest time %" PRIu64 " for temperature %s.",
+            cf_name.c_str(), cur_file->fd.GetNumber(), oldest_ancestor_time,
+            temperature_to_string[cur_target_temp].c_str());
+      }
+      if (compaction_size > mutable_cf_options.max_compaction_bytes) {
+        break;
+      }
     }
   }
 
@@ -401,9 +418,7 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
     return nullptr;
   }
   assert(compaction_target_temp != Temperature::kLastTemperature);
-  // Only compact one file at a time.
-  assert(inputs.size() == 1);
-  assert(inputs[0].size() == 1);
+
   Compaction* c = new Compaction(
       vstorage, ioptions_, mutable_cf_options, mutable_db_options,
       std::move(inputs), 0, 0 /* output file size limit */,

db/compaction/compaction_picker_fifo.h

@@ -53,10 +53,9 @@ class FIFOCompactionPicker : public CompactionPicker {
                                  VersionStorageInfo* version,
                                  LogBuffer* log_buffer);
 
-  // Will pick one file to compact at a time, starting from the oldest file.
   Compaction* PickTemperatureChangeCompaction(
       const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
       const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer) const;
+      LogBuffer* log_buffer);
 };
 }  // namespace ROCKSDB_NAMESPACE

db/compaction/compaction_picker_level.cc

@@ -925,15 +925,11 @@ bool LevelCompactionBuilder::PickSizeBasedIntraL0Compaction() {
   }
   uint64_t l0_size = 0;
   for (const auto& file : l0_files) {
-    assert(file->compensated_file_size >= file->fd.GetFileSize());
-    // Compact down L0s with more deletions.
-    l0_size += file->compensated_file_size;
+    l0_size += file->fd.GetFileSize();
   }
-
-  // Avoid L0->Lbase compactions that are inefficient for write-amp.
-  const double kMultiplier =
-      std::max(10.0, mutable_cf_options_.max_bytes_for_level_multiplier) * 2;
-  const uint64_t min_lbase_size = MultiplyCheckOverflow(l0_size, kMultiplier);
+  const uint64_t min_lbase_size =
+      l0_size * static_cast<uint64_t>(std::max(
+                    10.0, mutable_cf_options_.max_bytes_for_level_multiplier));
   assert(min_lbase_size >= l0_size);
   const std::vector<FileMetaData*>& lbase_files =
       vstorage_->LevelFiles(/*level=*/base_level);

db/compaction/compaction_picker_test.cc

@@ -214,10 +214,7 @@ class CompactionPickerTest : public CompactionPickerTestBase {
   explicit CompactionPickerTest()
       : CompactionPickerTestBase(BytewiseComparator()) {}
 
-  ~CompactionPickerTest() override {
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-    SyncPoint::GetInstance()->DisableProcessing();
-  }
+  ~CompactionPickerTest() override = default;
 };
 
 class CompactionPickerU64TsTest : public CompactionPickerTestBase {
@@ -1119,6 +1116,48 @@ TEST_F(CompactionPickerTest, FIFOToCold1) {
   ASSERT_EQ(3U, compaction->input(0, 0)->fd.GetNumber());
 }
 
+TEST_F(CompactionPickerTest, FIFOToCold2) {
+  NewVersionStorage(1, kCompactionStyleFIFO);
+  const uint64_t kFileSize = 100000;
+  const uint64_t kMaxSize = kFileSize * 100000;
+  uint64_t kColdThreshold = 2000;
+
+  fifo_options_.max_table_files_size = kMaxSize;
+  fifo_options_.file_temperature_age_thresholds = {
+      {Temperature::kCold, kColdThreshold}};
+  mutable_cf_options_.compaction_options_fifo = fifo_options_;
+  mutable_cf_options_.level0_file_num_compaction_trigger = 100;
+  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
+  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
+
+  int64_t current_time = 0;
+  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
+  uint64_t threshold_time =
+      static_cast<uint64_t>(current_time) - kColdThreshold;
+  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
+      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
+  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
+      Temperature::kUnknown, threshold_time);
+  // The following two files qualify for compaction to kCold.
+  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
+      Temperature::kUnknown, threshold_time - 3000);
+  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
+      Temperature::kUnknown, threshold_time - 4000);
+  UpdateVersionStorageInfo();
+
+  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
+  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
+      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
+      &log_buffer_));
+  ASSERT_TRUE(compaction.get() != nullptr);
+  ASSERT_EQ(compaction->compaction_reason(),
+            CompactionReason::kChangeTemperature);
+  ASSERT_EQ(compaction->output_temperature(), Temperature::kCold);
+  ASSERT_EQ(2U, compaction->num_input_files(0));
+  ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
+  ASSERT_EQ(3U, compaction->input(0, 1)->fd.GetNumber());
+}
+
 TEST_F(CompactionPickerTest, FIFOToColdMaxCompactionSize) {
   NewVersionStorage(1, kCompactionStyleFIFO);
   const uint64_t kFileSize = 100000;
@@ -1160,10 +1199,10 @@ TEST_F(CompactionPickerTest, FIFOToColdMaxCompactionSize) {
   ASSERT_TRUE(compaction.get() != nullptr);
   ASSERT_EQ(compaction->compaction_reason(),
             CompactionReason::kChangeTemperature);
-  // Compaction picker picks older files first and picks one file at a time.
   ASSERT_EQ(compaction->output_temperature(), Temperature::kCold);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
+  ASSERT_EQ(2U, compaction->num_input_files(0));
   ASSERT_EQ(1U, compaction->input(0, 0)->fd.GetNumber());
+  ASSERT_EQ(2U, compaction->input(0, 1)->fd.GetNumber());
 }
 
 TEST_F(CompactionPickerTest, FIFOToColdWithExistingCold) {
@@ -1206,10 +1245,10 @@ TEST_F(CompactionPickerTest, FIFOToColdWithExistingCold) {
   ASSERT_TRUE(compaction.get() != nullptr);
   ASSERT_EQ(compaction->compaction_reason(),
             CompactionReason::kChangeTemperature);
-  // Compaction picker picks older files first and picks one file at a time.
   ASSERT_EQ(compaction->output_temperature(), Temperature::kCold);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
   ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
+  ASSERT_EQ(2U, compaction->num_input_files(0));
+  ASSERT_EQ(3U, compaction->input(0, 1)->fd.GetNumber());
 }
 
 TEST_F(CompactionPickerTest, FIFOToColdWithHotBetweenCold) {
@@ -1257,7 +1296,7 @@ TEST_F(CompactionPickerTest, FIFOToColdWithHotBetweenCold) {
   ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
 }
 
-TEST_F(CompactionPickerTest, FIFOToHotAndWarm) {
+TEST_F(CompactionPickerTest, FIFOToColdAndWarm) {
   NewVersionStorage(1, kCompactionStyleFIFO);
   const uint64_t kFileSize = 100000;
   const uint64_t kMaxSize = kFileSize * 100000;
@@ -1302,10 +1341,11 @@ TEST_F(CompactionPickerTest, FIFOToHotAndWarm) {
   ASSERT_TRUE(compaction.get() != nullptr);
   ASSERT_EQ(compaction->compaction_reason(),
             CompactionReason::kChangeTemperature);
-  // Compaction picker picks older files first and picks one file at a time.
+  // Assumes compaction picker picks older files first.
   ASSERT_EQ(compaction->output_temperature(), Temperature::kWarm);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
+  ASSERT_EQ(2U, compaction->num_input_files(0));
   ASSERT_EQ(1U, compaction->input(0, 0)->fd.GetNumber());
+  ASSERT_EQ(2U, compaction->input(0, 1)->fd.GetNumber());
 }
 
 TEST_F(CompactionPickerTest, CompactionPriMinOverlapping1) {
@@ -4244,28 +4284,27 @@ TEST_F(CompactionPickerTest, IntraL0WhenL0IsSmall) {
     SCOPED_TRACE("lbase_size_multiplier=" +
                  std::to_string(lbase_size_multiplier));
     NewVersionStorage(6, kCompactionStyleLevel);
-    // When L0 size is <= Lbase size / max_bytes_for_level_multiplier / 2,
+    // When L0 size is <= Lbase size / max_bytes_for_level_multiplier,
     // intra-L0 compaction is picked. Otherwise, L0->L1
     // compaction is picked.
-    // compensated_file_size will be used to compute total l0 size.
     Add(/*level=*/0, /*file_number=*/1U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
         /*smallest_seq=*/10, /*largest_seq=*/11,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/2U, /*smallest=*/"100",
-        /*largest=*/"100", /*file_size=*/10, /*path_id=*/0,
+        /*largest=*/"100", /*file_size=*/1000, /*path_id=*/0,
         /*smallest_seq=*/20, /*largest_seq=*/21,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/3U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
         /*smallest_seq=*/30, /*largest_seq=*/31,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/4U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
         /*smallest_seq=*/40, /*largest_seq=*/41,
         /*compensated_file_size=*/1000);
     const uint64_t l0_size = 4000;
-    const uint64_t lbase_size = l0_size * lbase_size_multiplier * 2;
+    const uint64_t lbase_size = l0_size * lbase_size_multiplier;
     Add(/*level=*/1, /*file_number=*/5U, /*smallest=*/"100",
         /*largest=*/"200", /*file_size=*/lbase_size, /*path_id=*/0,
         /*smallest_seq=*/0, /*largest_seq=*/0,
@@ -4291,118 +4330,6 @@ TEST_F(CompactionPickerTest, IntraL0WhenL0IsSmall) {
   }
 }
 
-TEST_F(CompactionPickerTest, UniversalMaxReadAmpLargeDB) {
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.num_levels = 50;
-  mutable_cf_options_.RefreshDerivedOptions(ioptions_);
-  mutable_cf_options_.compaction_options_universal.size_ratio = 10;
-  mutable_cf_options_.write_buffer_size = 256 << 20;
-  // Avoid space amp compaction
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  const int kMaxRuns = 8;
-  for (int max_read_amp : {kMaxRuns, 0, -1}) {
-    SCOPED_TRACE("max_read_amp = " + std::to_string(max_read_amp));
-    if (max_read_amp == -1) {
-      mutable_cf_options_.level0_file_num_compaction_trigger = kMaxRuns;
-    } else {
-      mutable_cf_options_.level0_file_num_compaction_trigger = 4;
-    }
-    mutable_cf_options_.compaction_options_universal.max_read_amp =
-        max_read_amp;
-    UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-    uint64_t max_run_size = 20ull << 30;
-    // When max_read_amp = 0, we estimate the number of levels needed based on
-    // size_ratio and write_buffer_size. See more in
-    // UniversalCompactionBuilder::PickCompaction().
-    // With a 20GB last level, we estimate that 8 levels are needed:
-    // L0 256MB
-    // L1 256MB * 1.1 (size_ratio) = 282MB
-    // L2 (256MB + 282MB) * 1.1 = 592MB
-    // L3 1243MB
-    // L4 2610MB
-    // L5 5481MB
-    // L6 11510MB
-    // L7 24171MB > 20GB
-    for (int i = 0; i <= kMaxRuns; ++i) {
-      SCOPED_TRACE("i = " + std::to_string(i));
-      NewVersionStorage(/*num_levels=*/50, kCompactionStyleUniversal);
-      Add(/*level=*/49, /*file_number=*/10, /*smallest=*/"100",
-          /*largest=*/"200", /*file_size=*/max_run_size, /*path_id=*/0,
-          /*smallest_seq=*/0, /*largest_seq=*/0,
-          /*compensated_file_size=*/max_run_size);
-      // Besides the last sorted run, we add additional `i` sorted runs
-      // without triggering space-amp or size-amp compactions.
-      uint64_t file_size = 1 << 20;
-      for (int j = 0; j < i; ++j) {
-        Add(/*level=*/j, /*file_number=*/100 - j, /*smallest=*/"100",
-            /*largest=*/"200", /*file_size=*/file_size, /*path_id=*/0,
-            /*smallest_seq=*/100 - j, /*largest_seq=*/100 - j,
-            /*compensated_file_size=*/file_size);
-        // to avoid space-amp and size-amp compaction
-        file_size *= 2;
-      }
-      UpdateVersionStorageInfo();
-      // level0_file_num_compaction_trigger is still used as trigger to
-      // check potential compactions
-      ASSERT_EQ(
-          universal_compaction_picker.NeedsCompaction(vstorage_.get()),
-          i + 1 >= mutable_cf_options_.level0_file_num_compaction_trigger);
-      std::unique_ptr<Compaction> compaction(
-          universal_compaction_picker.PickCompaction(
-              cf_name_, mutable_cf_options_, mutable_db_options_,
-              vstorage_.get(), &log_buffer_));
-      if (i == kMaxRuns) {
-        // There are in total i + 1 > kMaxRuns sorted runs.
-        // This triggers compaction ignoring size_ratio.
-        ASSERT_NE(nullptr, compaction);
-        ASSERT_EQ(CompactionReason::kUniversalSortedRunNum,
-                  compaction->compaction_reason());
-        // First two runs are compacted
-        ASSERT_EQ(0, compaction->start_level());
-        ASSERT_EQ(1, compaction->output_level());
-        ASSERT_EQ(1U, compaction->num_input_files(0));
-        ASSERT_EQ(1U, compaction->num_input_files(1));
-      } else {
-        ASSERT_EQ(nullptr, compaction);
-      }
-    }
-  }
-}
-
-TEST_F(CompactionPickerTest, UniversalMaxReadAmpSmallDB) {
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.num_levels = 50;
-  mutable_cf_options_.RefreshDerivedOptions(ioptions_);
-  mutable_cf_options_.level0_file_num_compaction_trigger = 1;
-  mutable_cf_options_.compaction_options_universal.size_ratio = 10;
-  mutable_cf_options_.write_buffer_size = 256 << 20;
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  const int kMaxRuns = 1;
-  for (int max_read_amp : {-1, kMaxRuns, 0}) {
-    SCOPED_TRACE("max_read_amp = " + std::to_string(max_read_amp));
-    mutable_cf_options_.compaction_options_universal.max_read_amp =
-        max_read_amp;
-    UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-    NewVersionStorage(/*num_levels=*/50, kCompactionStyleUniversal);
-    // max_run_size is much smaller than write_buffer_size,
-    // only 1 level is needed.
-    uint64_t max_run_size = 8 << 10;
-    Add(/*level=*/49, /*file_number=*/10, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/max_run_size, /*path_id=*/0,
-        /*smallest_seq=*/0, /*largest_seq=*/0,
-        /*compensated_file_size=*/max_run_size);
-    UpdateVersionStorageInfo();
-    ASSERT_TRUE(universal_compaction_picker.NeedsCompaction(vstorage_.get()));
-    std::unique_ptr<Compaction> compaction(
-        universal_compaction_picker.PickCompaction(
-            cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-            &log_buffer_));
-    ASSERT_EQ(nullptr, compaction);
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/compaction/compaction_picker_universal.cc

@@ -227,7 +227,6 @@ class UniversalCompactionBuilder {
   const InternalKeyComparator* icmp_;
   double score_;
   std::vector<SortedRun> sorted_runs_;
-  uint64_t max_run_size_;
   const std::string& cf_name_;
   const MutableCFOptions& mutable_cf_options_;
   const MutableDBOptions& mutable_db_options_;
@@ -236,8 +235,7 @@ class UniversalCompactionBuilder {
   LogBuffer* log_buffer_;
 
   static std::vector<UniversalCompactionBuilder::SortedRun> CalculateSortedRuns(
-      const VersionStorageInfo& vstorage, int last_level,
-      uint64_t* max_run_size);
+      const VersionStorageInfo& vstorage, int last_level);
 
   // Pick a path ID to place a newly generated file, with its estimated file
   // size.
@@ -442,15 +440,11 @@ void UniversalCompactionBuilder::SortedRun::DumpSizeInfo(
 
 std::vector<UniversalCompactionBuilder::SortedRun>
 UniversalCompactionBuilder::CalculateSortedRuns(
-    const VersionStorageInfo& vstorage, int last_level,
-    uint64_t* max_run_size) {
-  assert(max_run_size);
-  *max_run_size = 0;
+    const VersionStorageInfo& vstorage, int last_level) {
   std::vector<UniversalCompactionBuilder::SortedRun> ret;
   for (FileMetaData* f : vstorage.LevelFiles(0)) {
     ret.emplace_back(0, f, f->fd.GetFileSize(), f->compensated_file_size,
                      f->being_compacted);
-    *max_run_size = std::max(*max_run_size, f->fd.GetFileSize());
   }
   for (int level = 1; level <= last_level; level++) {
     uint64_t total_compensated_size = 0U;
@@ -472,7 +466,6 @@ UniversalCompactionBuilder::CalculateSortedRuns(
       ret.emplace_back(level, nullptr, total_size, total_compensated_size,
                        being_compacted);
     }
-    *max_run_size = std::max(*max_run_size, total_size);
   }
   return ret;
 }
@@ -484,16 +477,13 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
   score_ = vstorage_->CompactionScore(kLevel0);
   int max_output_level =
       vstorage_->MaxOutputLevel(ioptions_.allow_ingest_behind);
-  max_run_size_ = 0;
-  sorted_runs_ =
-      CalculateSortedRuns(*vstorage_, max_output_level, &max_run_size_);
-  int file_num_compaction_trigger =
-      mutable_cf_options_.level0_file_num_compaction_trigger;
+  sorted_runs_ = CalculateSortedRuns(*vstorage_, max_output_level);
 
   if (sorted_runs_.size() == 0 ||
       (vstorage_->FilesMarkedForPeriodicCompaction().empty() &&
        vstorage_->FilesMarkedForCompaction().empty() &&
-       sorted_runs_.size() < (unsigned int)file_num_compaction_trigger)) {
+       sorted_runs_.size() < (unsigned int)mutable_cf_options_
+                                 .level0_file_num_compaction_trigger)) {
     ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: nothing to do\n",
                      cf_name_.c_str());
     TEST_SYNC_POINT_CALLBACK(
@@ -515,9 +505,11 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
     TEST_SYNC_POINT_CALLBACK("PostPickPeriodicCompaction", c);
   }
 
+  // Check for size amplification.
   if (c == nullptr &&
-      sorted_runs_.size() >= static_cast<size_t>(file_num_compaction_trigger)) {
-    // Check for size amplification.
+      sorted_runs_.size() >=
+          static_cast<size_t>(
+              mutable_cf_options_.level0_file_num_compaction_trigger)) {
     if ((c = PickCompactionToReduceSizeAmp()) != nullptr) {
       TEST_SYNC_POINT("PickCompactionToReduceSizeAmpReturnNonnullptr");
       ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: compacting for size amp\n",
@@ -535,48 +527,13 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
                          cf_name_.c_str());
       } else {
         // Size amplification and file size ratios are within configured limits.
-        // If max read amplification exceeds configured limits, then force
-        // compaction to reduce the number sorted runs without looking at file
-        // size ratios.
-
+        // If max read amplification is exceeding configured limits, then force
+        // compaction without looking at filesize ratios and try to reduce
+        // the number of files to fewer than level0_file_num_compaction_trigger.
         // This is guaranteed by NeedsCompaction()
         assert(sorted_runs_.size() >=
-               static_cast<size_t>(file_num_compaction_trigger));
-        int max_num_runs =
-            mutable_cf_options_.compaction_options_universal.max_read_amp;
-        if (max_num_runs < 0) {
-          // any value < -1 is not valid
-          assert(max_num_runs == -1);
-          // By default, fall back to `level0_file_num_compaction_trigger`
-          max_num_runs = file_num_compaction_trigger;
-        } else if (max_num_runs == 0) {
-          if (mutable_cf_options_.compaction_options_universal.stop_style ==
-              kCompactionStopStyleTotalSize) {
-            // 0 means auto-tuning by RocksDB. We estimate max num run based on
-            // max_run_size, size_ratio and write buffer size:
-            // Assume the size of the lowest level size is equal to
-            // write_buffer_size. Each subsequent level is the max size without
-            // triggering size_ratio compaction. `max_num_runs` is the minimum
-            // number of levels required such that the target size of the
-            // largest level is at least `max_run_size_`.
-            max_num_runs = 1;
-            double cur_level_max_size =
-                static_cast<double>(mutable_cf_options_.write_buffer_size);
-            double total_run_size = 0;
-            while (cur_level_max_size < static_cast<double>(max_run_size_)) {
-              // This loop should not take too many iterations since
-              // cur_level_max_size at least doubles each iteration.
-              total_run_size += cur_level_max_size;
-              cur_level_max_size = (100.0 + ratio) / 100.0 * total_run_size;
-              ++max_num_runs;
-            }
-          } else {
-            // TODO: implement the auto-tune logic for this stop style
-            max_num_runs = file_num_compaction_trigger;
-          }
-        } else {
-          // max_num_runs > 0, it's the limit on the number of sorted run
-        }
+               static_cast<size_t>(
+                   mutable_cf_options_.level0_file_num_compaction_trigger));
         // Get the total number of sorted runs that are not being compacted
         int num_sr_not_compacted = 0;
         for (size_t i = 0; i < sorted_runs_.size(); i++) {
@@ -587,25 +544,17 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
 
         // The number of sorted runs that are not being compacted is greater
         // than the maximum allowed number of sorted runs
-        if (num_sr_not_compacted > max_num_runs) {
-          unsigned int num_files = num_sr_not_compacted - max_num_runs + 1;
+        if (num_sr_not_compacted >
+            mutable_cf_options_.level0_file_num_compaction_trigger) {
+          unsigned int num_files =
+              num_sr_not_compacted -
+              mutable_cf_options_.level0_file_num_compaction_trigger + 1;
           if ((c = PickCompactionToReduceSortedRuns(UINT_MAX, num_files)) !=
               nullptr) {
             ROCKS_LOG_BUFFER(log_buffer_,
-                             "[%s] Universal: compacting for file num, to "
-                             "compact file num -- %u, max num runs allowed"
-                             "-- %d, max_run_size -- %" PRIu64 "\n",
-                             cf_name_.c_str(), num_files, max_num_runs,
-                             max_run_size_);
+                             "[%s] Universal: compacting for file num -- %u\n",
+                             cf_name_.c_str(), num_files);
           }
-        } else {
-          ROCKS_LOG_BUFFER(
-              log_buffer_,
-              "[%s] Universal: skipping compaction for file num, num runs not "
-              "being compacted -- %u, max num runs allowed -- %d, max_run_size "
-              "-- %" PRIu64 "\n",
-              cf_name_.c_str(), num_sr_not_compacted, max_num_runs,
-              max_run_size_);
         }
       }
     }

db/compaction/compaction_service_job.cc

@@ -39,8 +39,12 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
           MakeTableFileName(file->fd.GetNumber()));
     }
   }
-
-  compaction_input.cf_name = compaction->column_family_data()->GetName();
+  compaction_input.column_family.name =
+      compaction->column_family_data()->GetName();
+  compaction_input.column_family.options =
+      compaction->column_family_data()->GetLatestCFOptions();
+  compaction_input.db_options =
+      BuildDBOptions(db_options_, mutable_db_options_copy_);
   compaction_input.snapshots = existing_snapshots_;
   compaction_input.has_begin = sub_compact->start.has_value();
   compaction_input.begin =
@@ -48,14 +52,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
   compaction_input.has_end = sub_compact->end.has_value();
   compaction_input.end =
       compaction_input.has_end ? sub_compact->end->ToString() : "";
-  compaction_input.options_file_number =
-      sub_compact->compaction->input_version()
-          ->version_set()
-          ->options_file_number();
-
-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionServiceJob::ProcessKeyValueCompactionWithCompactionService",
-      &compaction_input);
 
   std::string compaction_input_binary;
   Status s = compaction_input.Write(&compaction_input_binary);
@@ -74,13 +70,10 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
   ROCKS_LOG_INFO(
       db_options_.info_log,
       "[%s] [JOB %d] Starting remote compaction (output level: %d): %s",
-      compaction->column_family_data()->GetName().c_str(), job_id_,
+      compaction_input.column_family.name.c_str(), job_id_,
       compaction_input.output_level, input_files_oss.str().c_str());
-  CompactionServiceJobInfo info(
-      dbname_, db_id_, db_session_id_, GetCompactionId(sub_compact),
-      thread_pri_, compaction->compaction_reason(),
-      compaction->is_full_compaction(), compaction->is_manual_compaction(),
-      compaction->bottommost_level());
+  CompactionServiceJobInfo info(dbname_, db_id_, db_session_id_,
+                                GetCompactionId(sub_compact), thread_pri_);
   CompactionServiceScheduleResponse response =
       db_options_.compaction_service->Schedule(info, compaction_input_binary);
   switch (response.status) {
@@ -91,14 +84,13 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
           "CompactionService failed to schedule a remote compaction job.");
       ROCKS_LOG_WARN(db_options_.info_log,
                      "[%s] [JOB %d] Remote compaction failed to start.",
-                     compaction->column_family_data()->GetName().c_str(),
-                     job_id_);
+                     compaction_input.column_family.name.c_str(), job_id_);
       return response.status;
     case CompactionServiceJobStatus::kUseLocal:
       ROCKS_LOG_INFO(
           db_options_.info_log,
           "[%s] [JOB %d] Remote compaction fallback to local by API (Schedule)",
-          compaction->column_family_data()->GetName().c_str(), job_id_);
+          compaction_input.column_family.name.c_str(), job_id_);
       return response.status;
     default:
       assert(false);  // unknown status
@@ -107,7 +99,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
 
   ROCKS_LOG_INFO(db_options_.info_log,
                  "[%s] [JOB %d] Waiting for remote compaction...",
-                 compaction->column_family_data()->GetName().c_str(), job_id_);
+                 compaction_input.column_family.name.c_str(), job_id_);
   std::string compaction_result_binary;
   CompactionServiceJobStatus compaction_status =
       db_options_.compaction_service->Wait(response.scheduled_job_id,
@@ -117,7 +109,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     ROCKS_LOG_INFO(
         db_options_.info_log,
         "[%s] [JOB %d] Remote compaction fallback to local by API (Wait)",
-        compaction->column_family_data()->GetName().c_str(), job_id_);
+        compaction_input.column_family.name.c_str(), job_id_);
     return compaction_status;
   }
 
@@ -142,19 +134,15 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
           "result is returned).");
       compaction_result.status.PermitUncheckedError();
     }
-    ROCKS_LOG_WARN(
-        db_options_.info_log, "[%s] [JOB %d] Remote compaction failed.",
-        compaction->column_family_data()->GetName().c_str(), job_id_);
+    ROCKS_LOG_WARN(db_options_.info_log,
+                   "[%s] [JOB %d] Remote compaction failed.",
+                   compaction_input.column_family.name.c_str(), job_id_);
     return compaction_status;
   }
 
-  // CompactionServiceJobStatus::kSuccess was returned, but somehow we failed to
-  // read the result. Consider this as an installation failure
   if (!s.ok()) {
     sub_compact->status = s;
     compaction_result.status.PermitUncheckedError();
-    db_options_.compaction_service->OnInstallation(
-        response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
     return CompactionServiceJobStatus::kFailure;
   }
   sub_compact->status = compaction_result.status;
@@ -166,14 +154,18 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     is_first_one = false;
   }
 
-  ROCKS_LOG_INFO(
-      db_options_.info_log,
-      "[%s] [JOB %d] Received remote compaction result, output path: "
-      "%s, files: %s",
-      compaction->column_family_data()->GetName().c_str(), job_id_,
-      compaction_result.output_path.c_str(), output_files_oss.str().c_str());
+  ROCKS_LOG_INFO(db_options_.info_log,
+                 "[%s] [JOB %d] Receive remote compaction result, output path: "
+                 "%s, files: %s",
+                 compaction_input.column_family.name.c_str(), job_id_,
+                 compaction_result.output_path.c_str(),
+                 output_files_oss.str().c_str());
+
+  if (!s.ok()) {
+    sub_compact->status = s;
+    return CompactionServiceJobStatus::kFailure;
+  }
 
-  // Installation Starts
   for (const auto& file : compaction_result.output_files) {
     uint64_t file_num = versions_->NewFileNumber();
     auto src_file = compaction_result.output_path + "/" + file.file_name;
@@ -182,8 +174,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr);
     if (!s.ok()) {
       sub_compact->status = s;
-      db_options_.compaction_service->OnInstallation(
-          response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
       return CompactionServiceJobStatus::kFailure;
     }
 
@@ -192,8 +182,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     s = fs_->GetFileSize(tgt_file, IOOptions(), &file_size, nullptr);
     if (!s.ok()) {
       sub_compact->status = s;
-      db_options_.compaction_service->OnInstallation(
-          response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
       return CompactionServiceJobStatus::kFailure;
     }
     meta.fd = FileDescriptor(file_num, compaction->output_path_id(), file_size,
@@ -203,8 +191,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     meta.oldest_ancester_time = file.oldest_ancester_time;
     meta.file_creation_time = file.file_creation_time;
     meta.epoch_number = file.epoch_number;
-    meta.file_checksum = file.file_checksum;
-    meta.file_checksum_func_name = file.file_checksum_func_name;
     meta.marked_for_compaction = file.marked_for_compaction;
     meta.unique_id = file.unique_id;
 
@@ -215,15 +201,11 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
   }
   sub_compact->compaction_job_stats = compaction_result.stats;
   sub_compact->Current().SetNumOutputRecords(
-      compaction_result.stats.num_output_records);
-  sub_compact->Current().SetNumOutputFiles(
-      compaction_result.stats.num_output_files);
-  sub_compact->Current().AddBytesWritten(compaction_result.bytes_written);
+      compaction_result.num_output_records);
+  sub_compact->Current().SetTotalBytes(compaction_result.total_bytes);
   RecordTick(stats_, REMOTE_COMPACT_READ_BYTES, compaction_result.bytes_read);
   RecordTick(stats_, REMOTE_COMPACT_WRITE_BYTES,
              compaction_result.bytes_written);
-  db_options_.compaction_service->OnInstallation(
-      response.scheduled_job_id, CompactionServiceJobStatus::kSuccess);
   return CompactionServiceJobStatus::kSuccess;
 }
 
@@ -238,18 +220,6 @@ void CompactionServiceCompactionJob::RecordCompactionIOStats() {
   CompactionJob::RecordCompactionIOStats();
 }
 
-void CompactionServiceCompactionJob::UpdateCompactionJobStats(
-    const InternalStats::CompactionStats& stats) const {
-  compaction_job_stats_->elapsed_micros = stats.micros;
-
-  // output information only in remote compaction
-  compaction_job_stats_->total_output_bytes = stats.bytes_written;
-  compaction_job_stats_->total_output_bytes_blob = stats.bytes_written_blob;
-  compaction_job_stats_->num_output_records = stats.num_output_records;
-  compaction_job_stats_->num_output_files = stats.num_output_files;
-  compaction_job_stats_->num_output_files_blob = stats.num_output_files_blob;
-}
-
 CompactionServiceCompactionJob::CompactionServiceCompactionJob(
     int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
     const MutableDBOptions& mutable_db_options, const FileOptions& file_options,
@@ -285,11 +255,11 @@ Status CompactionServiceCompactionJob::Run() {
 
   auto* c = compact_->compaction;
   assert(c->column_family_data() != nullptr);
-  const VersionStorageInfo* storage_info = c->input_version()->storage_info();
-  assert(storage_info);
-  assert(storage_info->NumLevelFiles(compact_->compaction->level()) > 0);
-  write_hint_ = storage_info->CalculateSSTWriteHint(c->output_level());
+  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();
 
   Slice begin = compaction_input_.begin;
@@ -304,12 +274,7 @@ Status CompactionServiceCompactionJob::Run() {
 
   log_buffer_->FlushBufferToLog();
   LogCompaction();
-
-  compaction_result_->stats.Reset();
-
   const uint64_t start_micros = db_options_.clock->NowMicros();
-  c->GetOrInitInputTableProperties();
-
   // Pick the only sub-compaction we should have
   assert(compact_->sub_compact_states.size() == 1);
   SubcompactionState* sub_compact = compact_->sub_compact_states.data();
@@ -347,32 +312,20 @@ Status CompactionServiceCompactionJob::Run() {
   if (status.ok()) {
     status = io_s;
   }
+  if (status.ok()) {
+    // TODO: Add verify_table()
+  }
+
+  // Finish up all book-keeping to unify the subcompaction results
+  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
+  UpdateCompactionStats();
+  RecordCompactionIOStats();
 
   LogFlush(db_options_.info_log);
   compact_->status = status;
   compact_->status.PermitUncheckedError();
 
-  // Build Compaction Job Stats
-
-  // 1. Aggregate CompactionOutputStats into Internal Compaction Stats
-  // (compaction_stats_) and aggregate Compaction Job Stats
-  // (compaction_job_stats_) from the sub compactions
-  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
-
-  // 2. Update the Output information in the Compaction Job Stats with
-  // aggregated Internal Compaction Stats.
-  UpdateCompactionJobStats(compaction_stats_.stats);
-
-  // 3. Set fields that are not propagated as part of aggregations above
-  compaction_result_->stats.is_manual_compaction = c->is_manual_compaction();
-  compaction_result_->stats.is_full_compaction = c->is_full_compaction();
-  compaction_result_->stats.is_remote_compaction = true;
-
-  // 4. Update IO Stats that are not part of the aggregations above (bytes_read,
-  // bytes_written)
-  RecordCompactionIOStats();
-
-  // Build Output
+  // Build compaction result
   compaction_result_->output_level = compact_->compaction->output_level();
   compaction_result_->output_path = output_path_;
   for (const auto& output_file : sub_compact->GetOutputs()) {
@@ -381,13 +334,16 @@ Status CompactionServiceCompactionJob::Run() {
         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, meta.epoch_number, meta.file_checksum,
-        meta.file_checksum_func_name, output_file.validator.GetHash(),
-        meta.marked_for_compaction, meta.unique_id);
+        meta.file_creation_time, meta.epoch_number,
+        output_file.validator.GetHash(), meta.marked_for_compaction,
+        meta.unique_id);
   }
+  InternalStats::CompactionStatsFull compaction_stats;
+  sub_compact->AggregateCompactionStats(compaction_stats);
+  compaction_result_->num_output_records =
+      compaction_stats.stats.num_output_records;
+  compaction_result_->total_bytes = compaction_stats.TotalBytesWritten();
 
-  TEST_SYNC_POINT_CALLBACK("CompactionServiceCompactionJob::Run:0",
-                           &compaction_result_);
   return status;
 }
 
@@ -440,9 +396,42 @@ static std::unordered_map<std::string, OptionTypeInfo> cfd_type_info = {
 };
 
 static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
-    {"cf_name",
-     {offsetof(struct CompactionServiceInput, cf_name),
-      OptionType::kEncodedString}},
+    {"column_family",
+     OptionTypeInfo::Struct(
+         "column_family", &cfd_type_info,
+         offsetof(struct CompactionServiceInput, column_family),
+         OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
+    {"db_options",
+     {offsetof(struct CompactionServiceInput, db_options),
+      OptionType::kConfigurable, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone,
+      [](const ConfigOptions& opts, const std::string& /*name*/,
+         const std::string& value, void* addr) {
+        auto options = static_cast<DBOptions*>(addr);
+        return GetDBOptionsFromString(opts, DBOptions(), value, options);
+      },
+      [](const ConfigOptions& opts, const std::string& /*name*/,
+         const void* addr, std::string* value) {
+        const auto options = static_cast<const DBOptions*>(addr);
+        std::string result;
+        auto status = GetStringFromDBOptions(opts, *options, &result);
+        *value = "{" + result + "}";
+        return status;
+      },
+      [](const ConfigOptions& opts, const std::string& name, const void* addr1,
+         const void* addr2, std::string* mismatch) {
+        const auto this_one = static_cast<const DBOptions*>(addr1);
+        const auto that_one = static_cast<const DBOptions*>(addr2);
+        auto this_conf = DBOptionsAsConfigurable(*this_one);
+        auto that_conf = DBOptionsAsConfigurable(*that_one);
+        std::string mismatch_opt;
+        bool result =
+            this_conf->AreEquivalent(opts, that_conf.get(), &mismatch_opt);
+        if (!result) {
+          *mismatch = name + "." + mismatch_opt;
+        }
+        return result;
+      }}},
     {"snapshots", OptionTypeInfo::Vector<uint64_t>(
                       offsetof(struct CompactionServiceInput, snapshots),
                       OptionVerificationType::kNormal, OptionTypeFlags::kNone,
@@ -470,10 +459,6 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
     {"end",
      {offsetof(struct CompactionServiceInput, end), OptionType::kEncodedString,
       OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-    {"options_file_number",
-     {offsetof(struct CompactionServiceInput, options_file_number),
-      OptionType::kUInt64T, OptionVerificationType::kNormal,
-      OptionTypeFlags::kNone}},
 };
 
 static std::unordered_map<std::string, OptionTypeInfo>
@@ -510,14 +495,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct CompactionServiceOutputFile, epoch_number),
           OptionType::kUInt64T, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-        {"file_checksum",
-         {offsetof(struct CompactionServiceOutputFile, file_checksum),
-          OptionType::kEncodedString, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"file_checksum_func_name",
-         {offsetof(struct CompactionServiceOutputFile, file_checksum_func_name),
-          OptionType::kEncodedString, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
         {"paranoid_hash",
          {offsetof(struct CompactionServiceOutputFile, paranoid_hash),
           OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -578,10 +555,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct CompactionJobStats, is_manual_compaction),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-        {"is_remote_compaction",
-         {offsetof(struct CompactionJobStats, is_remote_compaction),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
         {"total_input_bytes",
          {offsetof(struct CompactionJobStats, total_input_bytes),
           OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -750,6 +723,14 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_result_type_info = {
      {offsetof(struct CompactionServiceResult, output_path),
       OptionType::kEncodedString, OptionVerificationType::kNormal,
       OptionTypeFlags::kNone}},
+    {"num_output_records",
+     {offsetof(struct CompactionServiceResult, num_output_records),
+      OptionType::kUInt64T, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone}},
+    {"total_bytes",
+     {offsetof(struct CompactionServiceResult, total_bytes),
+      OptionType::kUInt64T, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone}},
     {"bytes_read",
      {offsetof(struct CompactionServiceResult, bytes_read),
       OptionType::kUInt64T, OptionVerificationType::kNormal,

db/compaction/compaction_service_test.cc

@@ -3,9 +3,9 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/utilities/options_util.h"
 #include "table/unique_id_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -21,10 +21,8 @@ class MyTestCompactionService : public CompactionService {
       : db_path_(std::move(db_path)),
         options_(options),
         statistics_(statistics),
-        start_info_("na", "na", "na", 0, Env::TOTAL, CompactionReason::kUnknown,
-                    false, false, false),
-        wait_info_("na", "na", "na", 0, Env::TOTAL, CompactionReason::kUnknown,
-                   false, false, false),
+        start_info_("na", "na", "na", 0, Env::TOTAL),
+        wait_info_("na", "na", "na", 0, Env::TOTAL),
         listeners_(listeners),
         table_properties_collector_factories_(
             std::move(table_properties_collector_factories)) {}
@@ -99,12 +97,8 @@ class MyTestCompactionService : public CompactionService {
     Status s =
         DB::OpenAndCompact(options, db_path_, db_path_ + "/" + scheduled_job_id,
                            compaction_input, result, options_override);
-    {
-      InstrumentedMutexLock l(&mutex_);
-      if (is_override_wait_result_) {
-        *result = override_wait_result_;
-      }
-      result_ = *result;
+    if (is_override_wait_result_) {
+      *result = override_wait_result_;
     }
     compaction_num_.fetch_add(1);
     if (s.ok()) {
@@ -114,11 +108,6 @@ class MyTestCompactionService : public CompactionService {
     }
   }
 
-  void OnInstallation(const std::string& /*scheduled_job_id*/,
-                      CompactionServiceJobStatus status) override {
-    final_updated_status_ = status;
-  }
-
   int GetCompactionNum() { return compaction_num_.load(); }
 
   CompactionServiceJobInfo GetCompactionInfoForStart() { return start_info_; }
@@ -147,14 +136,6 @@ class MyTestCompactionService : public CompactionService {
 
   void SetCanceled(bool canceled) { canceled_ = canceled; }
 
-  void GetResult(CompactionServiceResult* deserialized) {
-    CompactionServiceResult::Read(result_, deserialized).PermitUncheckedError();
-  }
-
-  CompactionServiceJobStatus GetFinalCompactionServiceJobStatus() {
-    return final_updated_status_.load();
-  }
-
  private:
   InstrumentedMutex mutex_;
   std::atomic_int compaction_num_{0};
@@ -172,14 +153,11 @@ class MyTestCompactionService : public CompactionService {
   CompactionServiceJobStatus override_wait_status_ =
       CompactionServiceJobStatus::kFailure;
   bool is_override_wait_result_ = false;
-  std::string result_;
   std::string override_wait_result_;
   std::vector<std::shared_ptr<EventListener>> listeners_;
   std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>
       table_properties_collector_factories_;
   std::atomic_bool canceled_{false};
-  std::atomic<CompactionServiceJobStatus> final_updated_status_{
-      CompactionServiceJobStatus::kUseLocal};
 };
 
 class CompactionServiceTest : public DBTestBase {
@@ -277,8 +255,6 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
 
   auto my_cs = GetCompactionService();
   ASSERT_GE(my_cs->GetCompactionNum(), 1);
-  ASSERT_EQ(CompactionServiceJobStatus::kSuccess,
-            my_cs->GetFinalCompactionServiceJobStatus());
 
   // make sure the compaction statistics is only recorded on the remote side
   ASSERT_GE(compactor_statistics->getTickerCount(COMPACT_WRITE_BYTES), 1);
@@ -342,34 +318,6 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
   ReopenWithColumnFamilies({kDefaultColumnFamilyName, "cf_1", "cf_2", "cf_3"},
                            options);
   ASSERT_GT(verify_passed, 0);
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  if (s.IsAborted()) {
-    ASSERT_NOK(result.status);
-  } else {
-    ASSERT_OK(result.status);
-  }
-  ASSERT_GE(result.stats.elapsed_micros, 1);
-  ASSERT_GE(result.stats.cpu_micros, 1);
-
-  ASSERT_EQ(20, result.stats.num_output_records);
-  ASSERT_EQ(result.output_files.size(), result.stats.num_output_files);
-
-  uint64_t total_size = 0;
-  for (auto output_file : result.output_files) {
-    std::string file_name = result.output_path + "/" + output_file.file_name;
-
-    uint64_t file_size = 0;
-    ASSERT_OK(options.env->GetFileSize(file_name, &file_size));
-    ASSERT_GT(file_size, 0);
-    total_size += file_size;
-  }
-  ASSERT_EQ(total_size, result.stats.total_output_bytes);
-
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_FALSE(result.stats.is_full_compaction);
-
   Close();
 }
 
@@ -408,507 +356,6 @@ TEST_F(CompactionServiceTest, ManualCompaction) {
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
   ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
   VerifyTestData();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, PreservedOptionsLocalCompaction) {
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  options.disable_auto_compactions = true;
-  DestroyAndReopen(options);
-
-  Random rnd(301);
-  for (auto i = 0; i < 2; ++i) {
-    for (auto j = 0; j < 10; ++j) {
-      ASSERT_OK(
-          Put("foo" + std::to_string(i * 10 + j), rnd.RandomString(1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
-        auto compaction = static_cast<Compaction*>(arg);
-        std::string options_file_name = OptionsFileName(
-            dbname_,
-            compaction->input_version()->version_set()->options_file_number());
-
-        // Change option twice to make sure the very first OPTIONS file gets
-        // purged
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "4"}}));
-        ASSERT_EQ(4, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "6"}}));
-        ASSERT_EQ(6, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        dbfull()->TEST_DeleteObsoleteFiles();
-
-        // For non-remote compactions, OPTIONS file can be deleted while
-        // using option at the start of the compaction
-        Status s = env_->FileExists(options_file_name);
-        ASSERT_NOK(s);
-        ASSERT_TRUE(s.IsNotFound());
-        // Should be old value
-        ASSERT_EQ(2, compaction->mutable_cf_options()
-                         ->level0_file_num_compaction_trigger);
-        ASSERT_TRUE(dbfull()->min_options_file_numbers_.empty());
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_TRUE(s.ok());
-}
-
-TEST_F(CompactionServiceTest, PreservedOptionsRemoteCompaction) {
-  // For non-remote compaction do not preserve options file
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = 2;
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  Random rnd(301);
-  for (auto i = 0; i < 2; ++i) {
-    for (auto j = 0; j < 10; ++j) {
-      ASSERT_OK(
-          Put("foo" + std::to_string(i * 10 + j), rnd.RandomString(1024)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  bool is_primary_called = false;
-  // This will be called twice. One from primary and one from remote.
-  // Try changing the option when called from remote. Otherwise, the new option
-  // will be used
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:BeforeRun", [&](void* /*arg*/) {
-        if (!is_primary_called) {
-          is_primary_called = true;
-          return;
-        }
-        // Change the option right before the compaction run
-        ASSERT_OK(dbfull()->SetOptions(
-            {{"level0_file_num_compaction_trigger", "4"}}));
-        ASSERT_EQ(4, dbfull()->GetOptions().level0_file_num_compaction_trigger);
-        dbfull()->TEST_DeleteObsoleteFiles();
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceJob::ProcessKeyValueCompactionWithCompactionService",
-      [&](void* arg) {
-        auto input = static_cast<CompactionServiceInput*>(arg);
-        std::string options_file_name =
-            OptionsFileName(dbname_, input->options_file_number);
-
-        ASSERT_OK(env_->FileExists(options_file_name));
-        ASSERT_FALSE(dbfull()->min_options_file_numbers_.empty());
-        ASSERT_EQ(dbfull()->min_options_file_numbers_.front(),
-                  input->options_file_number);
-
-        DBOptions db_options;
-        ConfigOptions config_options;
-        std::vector<ColumnFamilyDescriptor> all_column_families;
-        config_options.env = env_;
-        ASSERT_OK(LoadOptionsFromFile(config_options, options_file_name,
-                                      &db_options, &all_column_families));
-        bool has_cf = false;
-        for (auto& cf : all_column_families) {
-          if (cf.name == input->cf_name) {
-            // Should be old value
-            ASSERT_EQ(2, cf.options.level0_file_num_compaction_trigger);
-            has_cf = true;
-          }
-        }
-        ASSERT_TRUE(has_cf);
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
-        auto compaction = static_cast<Compaction*>(arg);
-        ASSERT_EQ(2, compaction->mutable_cf_options()
-                         ->level0_file_num_compaction_trigger);
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-  ASSERT_TRUE(s.ok());
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-class EventVerifier : public EventListener {
- public:
-  explicit EventVerifier(uint64_t expected_num_input_records,
-                         size_t expected_num_input_files,
-                         uint64_t expected_num_output_records,
-                         size_t expected_num_output_files,
-                         const std::string& expected_smallest_output_key_prefix,
-                         const std::string& expected_largest_output_key_prefix,
-                         bool expected_is_remote_compaction_on_begin,
-                         bool expected_is_remote_compaction_on_complete)
-      : expected_num_input_records_(expected_num_input_records),
-        expected_num_input_files_(expected_num_input_files),
-        expected_num_output_records_(expected_num_output_records),
-        expected_num_output_files_(expected_num_output_files),
-        expected_smallest_output_key_prefix_(
-            expected_smallest_output_key_prefix),
-        expected_largest_output_key_prefix_(expected_largest_output_key_prefix),
-        expected_is_remote_compaction_on_begin_(
-            expected_is_remote_compaction_on_begin),
-        expected_is_remote_compaction_on_complete_(
-            expected_is_remote_compaction_on_complete) {}
-  void OnCompactionBegin(DB* /*db*/, const CompactionJobInfo& ci) override {
-    ASSERT_EQ(expected_num_input_files_, ci.input_files.size());
-    ASSERT_EQ(expected_num_input_files_, ci.input_file_infos.size());
-    ASSERT_EQ(expected_is_remote_compaction_on_begin_,
-              ci.stats.is_remote_compaction);
-    ASSERT_TRUE(ci.stats.is_manual_compaction);
-    ASSERT_FALSE(ci.stats.is_full_compaction);
-  }
-  void OnCompactionCompleted(DB* /*db*/, const CompactionJobInfo& ci) override {
-    ASSERT_GT(ci.stats.elapsed_micros, 0);
-    ASSERT_GT(ci.stats.cpu_micros, 0);
-    ASSERT_EQ(expected_num_input_records_, ci.stats.num_input_records);
-    ASSERT_EQ(expected_num_input_files_, ci.stats.num_input_files);
-    ASSERT_EQ(expected_num_output_records_, ci.stats.num_output_records);
-    ASSERT_EQ(expected_num_output_files_, ci.stats.num_output_files);
-    ASSERT_EQ(expected_smallest_output_key_prefix_,
-              ci.stats.smallest_output_key_prefix);
-    ASSERT_EQ(expected_largest_output_key_prefix_,
-              ci.stats.largest_output_key_prefix);
-    ASSERT_GT(ci.stats.total_input_bytes, 0);
-    ASSERT_GT(ci.stats.total_output_bytes, 0);
-    ASSERT_EQ(ci.stats.num_input_records,
-              ci.stats.num_output_records + ci.stats.num_records_replaced);
-    ASSERT_EQ(expected_is_remote_compaction_on_complete_,
-              ci.stats.is_remote_compaction);
-    ASSERT_TRUE(ci.stats.is_manual_compaction);
-    ASSERT_FALSE(ci.stats.is_full_compaction);
-  }
-
- private:
-  uint64_t expected_num_input_records_;
-  size_t expected_num_input_files_;
-  uint64_t expected_num_output_records_;
-  size_t expected_num_output_files_;
-  std::string expected_smallest_output_key_prefix_;
-  std::string expected_largest_output_key_prefix_;
-  bool expected_is_remote_compaction_on_begin_;
-  bool expected_is_remote_compaction_on_complete_;
-};
-
-TEST_F(CompactionServiceTest, VerifyStats) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  auto event_verifier = std::make_shared<EventVerifier>(
-      30 /* expected_num_input_records */, 3 /* expected_num_input_files */,
-      20 /* expected_num_output_records */, 1 /* expected_num_output_files */,
-      "key00000" /* expected_smallest_output_key_prefix */,
-      "key00001" /* expected_largest_output_key_prefix */,
-      true /* expected_is_remote_compaction_on_begin */,
-      true /* expected_is_remote_compaction_on_complete */);
-  options.listeners.push_back(event_verifier);
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(0);
-  std::string end_str = Key(1);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-  VerifyTestData();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, VerifyStatsLocalFallback) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  auto event_verifier = std::make_shared<EventVerifier>(
-      30 /* expected_num_input_records */, 3 /* expected_num_input_files */,
-      20 /* expected_num_output_records */, 1 /* expected_num_output_files */,
-      "key00000" /* expected_smallest_output_key_prefix */,
-      "key00001" /* expected_largest_output_key_prefix */,
-      true /* expected_is_remote_compaction_on_begin */,
-      false /* expected_is_remote_compaction_on_complete */);
-  options.listeners.push_back(event_verifier);
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-  my_cs->OverrideStartStatus(CompactionServiceJobStatus::kUseLocal);
-
-  std::string start_str = Key(0);
-  std::string end_str = Key(1);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  // Remote Compaction did not happen
-  ASSERT_EQ(my_cs->GetCompactionNum(), comp_num);
-  VerifyTestData();
-}
-
-TEST_F(CompactionServiceTest, CorruptedOutput) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Corrupt files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          ASSERT_OK(test::CorruptFile(env_, file_name, 0,
-                                      static_cast<int>(file_size),
-                                      true /* verifyChecksum */));
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // CompactRange() should fail
-  Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // On the worker side, the compaction is considered success
-  // Verification is done on the primary side
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, CorruptedOutputParanoidFileCheck) {
-  for (bool paranoid_file_check_enabled : {false, true}) {
-    SCOPED_TRACE("paranoid_file_check_enabled=" +
-                 std::to_string(paranoid_file_check_enabled));
-
-    Options options = CurrentOptions();
-    Destroy(options);
-    options.disable_auto_compactions = true;
-    options.paranoid_file_checks = paranoid_file_check_enabled;
-    ReopenWithCompactionService(&options);
-    GenerateTestData();
-
-    auto my_cs = GetCompactionService();
-
-    std::string start_str = Key(15);
-    std::string end_str = Key(45);
-    Slice start(start_str);
-    Slice end(end_str);
-    uint64_t comp_num = my_cs->GetCompactionNum();
-
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-        "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-          CompactionServiceResult* compaction_result =
-              *(static_cast<CompactionServiceResult**>(arg));
-          ASSERT_TRUE(compaction_result != nullptr &&
-                      !compaction_result->output_files.empty());
-          // Corrupt files here
-          for (const auto& output_file : compaction_result->output_files) {
-            std::string file_name =
-                compaction_result->output_path + "/" + output_file.file_name;
-
-            // Corrupt very small range of bytes. This corruption is so small
-            // that this isn't caught by default light-weight check
-            ASSERT_OK(test::CorruptFile(env_, file_name, 0, 1,
-                                        false /* verifyChecksum */));
-          }
-        });
-    SyncPoint::GetInstance()->EnableProcessing();
-
-    Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-    if (paranoid_file_check_enabled) {
-      ASSERT_NOK(s);
-      ASSERT_EQ(Status::Corruption("Paranoid checksums do not match"), s);
-    } else {
-      // CompactRange() goes through if paranoid file check is not enabled
-      ASSERT_OK(s);
-    }
-
-    ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-
-    // On the worker side, the compaction is considered success
-    // Verification is done on the primary side
-    CompactionServiceResult result;
-    my_cs->GetResult(&result);
-    ASSERT_OK(result.status);
-    ASSERT_TRUE(result.stats.is_manual_compaction);
-    ASSERT_TRUE(result.stats.is_remote_compaction);
-  }
-}
-
-TEST_F(CompactionServiceTest, TruncatedOutput) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Truncate files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          ASSERT_OK(test::TruncateFile(env_, file_name, file_size / 2));
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // CompactRange() should fail
-  Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  // On the worker side, the compaction is considered success
-  // Verification is done on the primary side
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-}
-
-TEST_F(CompactionServiceTest, CustomFileChecksum) {
-  Options options = CurrentOptions();
-  options.file_checksum_gen_factory = GetFileChecksumGenCrc32cFactory();
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  std::string start_str = Key(15);
-  std::string end_str = Key(45);
-  Slice start(start_str);
-  Slice end(end_str);
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
-        CompactionServiceResult* compaction_result =
-            *(static_cast<CompactionServiceResult**>(arg));
-        ASSERT_TRUE(compaction_result != nullptr &&
-                    !compaction_result->output_files.empty());
-        // Validate Checksum files here
-        for (const auto& output_file : compaction_result->output_files) {
-          std::string file_name =
-              compaction_result->output_path + "/" + output_file.file_name;
-
-          FileChecksumGenContext gen_context;
-          gen_context.file_name = file_name;
-          std::unique_ptr<FileChecksumGenerator> file_checksum_gen =
-              options.file_checksum_gen_factory->CreateFileChecksumGenerator(
-                  gen_context);
-
-          std::unique_ptr<SequentialFile> file_reader;
-          uint64_t file_size = 0;
-          Status s = options.env->GetFileSize(file_name, &file_size);
-          ASSERT_OK(s);
-          ASSERT_GT(file_size, 0);
-
-          s = options.env->NewSequentialFile(file_name, &file_reader,
-                                             EnvOptions());
-          ASSERT_OK(s);
-
-          Slice result;
-          std::unique_ptr<char[]> scratch(new char[file_size]);
-          s = file_reader->Read(file_size, &result, scratch.get());
-          ASSERT_OK(s);
-
-          file_checksum_gen->Update(scratch.get(), result.size());
-          file_checksum_gen->Finalize();
-
-          // Verify actual checksum and the func name
-          ASSERT_EQ(file_checksum_gen->Name(),
-                    output_file.file_checksum_func_name);
-          ASSERT_EQ(file_checksum_gen->GetChecksum(),
-                    output_file.file_checksum);
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
 }
 
 TEST_F(CompactionServiceTest, CancelCompactionOnRemoteSide) {
@@ -990,8 +437,6 @@ TEST_F(CompactionServiceTest, InvalidResult) {
   Slice end(end_str);
   Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
   ASSERT_FALSE(s.ok());
-  ASSERT_EQ(CompactionServiceJobStatus::kFailure,
-            my_cs->GetFinalCompactionServiceJobStatus());
 }
 
 TEST_F(CompactionServiceTest, SubCompaction) {
@@ -1141,20 +586,11 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
                               {file.db_path + "/" + file.name}, 2));
   info = my_cs->GetCompactionInfoForStart();
   ASSERT_EQ(Env::USER, info.priority);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
   info = my_cs->GetCompactionInfoForWait();
   ASSERT_EQ(Env::USER, info.priority);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
 
   // Test priority BOTTOM
   env_->SetBackgroundThreads(1, Env::BOTTOM);
-  // This will set bottommost_level = true but is_full_compaction = false
   options.num_levels = 2;
   ReopenWithCompactionService(&options);
   my_cs =
@@ -1177,71 +613,9 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
   }
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
   info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(CompactionReason::kLevelL0FilesNum, info.compaction_reason);
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
   ASSERT_EQ(Env::BOTTOM, info.priority);
   info = my_cs->GetCompactionInfoForWait();
   ASSERT_EQ(Env::BOTTOM, info.priority);
-  ASSERT_EQ(CompactionReason::kLevelL0FilesNum, info.compaction_reason);
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-
-  // Test Non-Bottommost Level
-  options.num_levels = 4;
-  ReopenWithCompactionService(&options);
-  my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-
-  for (int i = 0; i < options.level0_file_num_compaction_trigger; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value_new_new" + std::to_string(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(false, info.bottommost_level);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(false, info.is_manual_compaction);
-  ASSERT_EQ(false, info.is_full_compaction);
-  ASSERT_EQ(false, info.bottommost_level);
-
-  // Test Full Compaction + Bottommost Level
-  options.num_levels = 6;
-  ReopenWithCompactionService(&options);
-  my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-
-  for (int i = 0; i < 20; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value_new_new" + std::to_string(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(true, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(true, info.is_manual_compaction);
-  ASSERT_EQ(true, info.is_full_compaction);
-  ASSERT_EQ(true, info.bottommost_level);
-  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
 }
 
 TEST_F(CompactionServiceTest, FallbackLocalAuto) {

db/compaction/compaction_state.cc

@@ -39,7 +39,7 @@ void CompactionState::AggregateCompactionStats(
     InternalStats::CompactionStatsFull& compaction_stats,
     CompactionJobStats& compaction_job_stats) {
   for (const auto& sc : sub_compact_states) {
-    sc.AggregateCompactionOutputStats(compaction_stats);
+    sc.AggregateCompactionStats(compaction_stats);
     compaction_job_stats.Add(sc.compaction_job_stats);
   }
 }

db/compaction/subcompaction_state.cc

@@ -13,7 +13,7 @@
 #include "rocksdb/sst_partitioner.h"
 
 namespace ROCKSDB_NAMESPACE {
-void SubcompactionState::AggregateCompactionOutputStats(
+void SubcompactionState::AggregateCompactionStats(
     InternalStats::CompactionStatsFull& compaction_stats) const {
   compaction_stats.stats.Add(compaction_outputs_.stats_);
   if (HasPenultimateLevelOutputs()) {

db/compaction/subcompaction_state.h

@@ -179,7 +179,7 @@ class SubcompactionState {
 
   void Cleanup(Cache* cache);
 
-  void AggregateCompactionOutputStats(
+  void AggregateCompactionStats(
       InternalStats::CompactionStatsFull& compaction_stats) const;
 
   CompactionOutputs& Current() const {

db/compaction/tiered_compaction_test.cc

@@ -13,7 +13,6 @@
 #include "rocksdb/iostats_context.h"
 #include "rocksdb/listener.h"
 #include "rocksdb/utilities/debug.h"
-#include "rocksdb/utilities/table_properties_collectors.h"
 #include "test_util/mock_time_env.h"
 #include "utilities/merge_operators.h"
 
@@ -1735,82 +1734,6 @@ TEST_P(TimedPutPrecludeLastLevelTest, PreserveTimedPutOnPenultimateLevel) {
   Close();
 }
 
-TEST_P(TimedPutPrecludeLastLevelTest, AutoTriggerCompaction) {
-  const int kNumTrigger = 10;
-  const int kNumLevels = 7;
-  const int kNumKeys = 200;
-
-  Options options = CurrentOptions();
-  options.compaction_style = kCompactionStyleUniversal;
-  options.preclude_last_level_data_seconds = 60;
-  options.preserve_internal_time_seconds = 0;
-  options.env = mock_env_.get();
-  options.level0_file_num_compaction_trigger = kNumTrigger;
-  options.num_levels = kNumLevels;
-  options.last_level_temperature = Temperature::kCold;
-  ConfigOptions config_options;
-  config_options.ignore_unsupported_options = false;
-  std::shared_ptr<TablePropertiesCollectorFactory> factory;
-  std::string id = CompactForTieringCollectorFactory::kClassName();
-  ASSERT_OK(TablePropertiesCollectorFactory::CreateFromString(
-      config_options, "compaction_trigger_ratio=0.4; id=" + id, &factory));
-  auto collector_factory =
-      factory->CheckedCast<CompactForTieringCollectorFactory>();
-  options.table_properties_collector_factories.push_back(factory);
-  DestroyAndReopen(options);
-  WriteOptions wo;
-  wo.protection_bytes_per_key = GetParam();
-
-  Random rnd(301);
-
-  dbfull()->TEST_WaitForPeriodicTaskRun([&] {
-    mock_clock_->MockSleepForSeconds(static_cast<int>(rnd.Uniform(10) + 1));
-  });
-
-  for (int i = 0; i < kNumKeys / 4; i++) {
-    ASSERT_OK(Put(Key(i), rnd.RandomString(100), wo));
-    dbfull()->TEST_WaitForPeriodicTaskRun([&] {
-      mock_clock_->MockSleepForSeconds(static_cast<int>(rnd.Uniform(2)));
-    });
-  }
-  // Create one file with regular Put.
-  ASSERT_OK(Flush());
-
-  // Create one file with TimedPut.
-  // These data are eligible to be put on the last level once written to db
-  // and compaction will fast track them to the last level.
-  for (int i = kNumKeys / 4; i < kNumKeys / 2; i++) {
-    ASSERT_OK(TimedPut(0, Key(i), rnd.RandomString(100), 50, wo));
-  }
-  ASSERT_OK(Flush());
-
-  // TimedPut file moved to the last level via auto triggered compaction.
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ("1,0,0,0,0,0,1", FilesPerLevel());
-  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
-
-  collector_factory->SetCompactionTriggerRatio(1.1);
-  for (int i = kNumKeys / 2; i < kNumKeys * 3 / 4; i++) {
-    ASSERT_OK(TimedPut(0, Key(i), rnd.RandomString(100), 50, wo));
-  }
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ("2,0,0,0,0,0,1", FilesPerLevel());
-
-  collector_factory->SetCompactionTriggerRatio(0);
-  for (int i = kNumKeys * 3 / 4; i < kNumKeys; i++) {
-    ASSERT_OK(TimedPut(0, Key(i), rnd.RandomString(100), 50, wo));
-  }
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_EQ("3,0,0,0,0,0,1", FilesPerLevel());
-
-  Close();
-}
-
 INSTANTIATE_TEST_CASE_P(TimedPutPrecludeLastLevelTest,
                         TimedPutPrecludeLastLevelTest, ::testing::Values(0, 8));
 
@@ -2512,7 +2435,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
                               start_time + kSecondsPerRecording * (i + 1));
       }
     }
-    ASSERT_EQ(kNumKeys, i);
     ASSERT_OK(iter->status());
   }
 
@@ -2532,13 +2454,12 @@ TEST_P(IteratorWriteTimeTest, ReadFromMemtables) {
       }
     }
     ASSERT_OK(iter->status());
-    ASSERT_EQ(-1, i);
   }
 
   // Reopen the DB and disable the seqno to time recording, data with user
   // specified write time can still get a write time before it's flushed.
   options.preserve_internal_time_seconds = 0;
-  Reopen(options);
+  DestroyAndReopen(options);
   ASSERT_OK(TimedPut(Key(kKeyWithWriteTime), rnd.RandomString(100),
                      kUserSpecifiedWriteTime));
   {
@@ -2615,7 +2536,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
       }
     }
     ASSERT_OK(iter->status());
-    ASSERT_EQ(kNumKeys, i);
   }
 
   // Backward iteration
@@ -2635,13 +2555,12 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
       }
     }
     ASSERT_OK(iter->status());
-    ASSERT_EQ(-1, i);
   }
 
   // Reopen the DB and disable the seqno to time recording. Data retrieved from
   // SST files still have write time available.
   options.preserve_internal_time_seconds = 0;
-  Reopen(options);
+  DestroyAndReopen(options);
 
   dbfull()->TEST_WaitForPeriodicTaskRun(
       [&] { mock_clock_->MockSleepForSeconds(kSecondsPerRecording); });
@@ -2667,7 +2586,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
                               start_time + kSecondsPerRecording * (i + 1));
       }
     }
-    ASSERT_EQ(kNumKeys, i);
     ASSERT_OK(iter->status());
   }
 
@@ -2691,7 +2609,6 @@ TEST_P(IteratorWriteTimeTest, ReadFromSstFile) {
       VerifyKeyAndWriteTime(iter.get(), Key(i), 0);
     }
     ASSERT_OK(iter->status());
-    ASSERT_EQ(kNumKeys, i);
   }
   Close();
 }

db/convenience.cc

@@ -71,9 +71,6 @@ Status VerifySstFileChecksumInternal(const Options& options,
   } else {
     return s;
   }
-  if (!s.ok()) {
-    return s;
-  }
   std::unique_ptr<TableReader> table_reader;
   std::unique_ptr<RandomAccessFileReader> file_reader(
       new RandomAccessFileReader(

db/db_basic_test.cc

@@ -688,100 +688,76 @@ TEST_F(DBBasicTest, IdentityAcrossRestarts) {
   constexpr size_t kMinIdSize = 10;
   do {
     for (bool with_manifest : {false, true}) {
-      for (bool write_file : {false, true}) {
-        std::string idfilename = IdentityFileName(dbname_);
-        std::string id1, tmp;
-        ASSERT_OK(db_->GetDbIdentity(id1));
-        ASSERT_GE(id1.size(), kMinIdSize);
+      std::string idfilename = IdentityFileName(dbname_);
+      std::string id1, tmp;
+      ASSERT_OK(db_->GetDbIdentity(id1));
+      ASSERT_GE(id1.size(), kMinIdSize);
 
-        Options options = CurrentOptions();
-        options.write_dbid_to_manifest = with_manifest;
-        options.write_identity_file = true;  // initially
-        Reopen(options);
-        std::string id2;
-        ASSERT_OK(db_->GetDbIdentity(id2));
-        // id2 should match id1 because identity was not regenerated
-        ASSERT_EQ(id1, id2);
-        ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-        ASSERT_EQ(tmp, id2);
+      Options options = CurrentOptions();
+      options.write_dbid_to_manifest = with_manifest;
+      Reopen(options);
+      std::string id2;
+      ASSERT_OK(db_->GetDbIdentity(id2));
+      // id2 should match id1 because identity was not regenerated
+      ASSERT_EQ(id1, id2);
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id2);
 
-        if (write_file) {
-          // Recover from deleted/missing IDENTITY
-          ASSERT_OK(env_->DeleteFile(idfilename));
-        } else {
-          // Transition to no IDENTITY file
-          options.write_identity_file = false;
-          if (!with_manifest) {
-            // Incompatible options, should fail
-            ASSERT_NOK(TryReopen(options));
-            // Back to a usable config and continue
-            options.write_identity_file = true;
-            Reopen(options);
-            continue;
-          }
-        }
-        Reopen(options);
-        std::string id3;
-        ASSERT_OK(db_->GetDbIdentity(id3));
-        if (with_manifest) {
-          // id3 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id3);
-        } else {
-          // id3 should NOT match id1 because identity was regenerated
-          ASSERT_NE(id1, id3);
-          ASSERT_GE(id3.size(), kMinIdSize);
-        }
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id3);
-
-          // Recover from truncated IDENTITY
-          std::unique_ptr<WritableFile> w;
-          ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
-          ASSERT_OK(w->Close());
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
-        Reopen(options);
-        std::string id4;
-        ASSERT_OK(db_->GetDbIdentity(id4));
-        if (with_manifest) {
-          // id4 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id4);
-        } else {
-          // id4 should NOT match id1 because identity was regenerated
-          ASSERT_NE(id1, id4);
-          ASSERT_GE(id4.size(), kMinIdSize);
-        }
-        std::string silly_id = "asdf123456789";
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id4);
-
-          // Recover from overwritten IDENTITY
-          std::unique_ptr<WritableFile> w;
-          ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
-          ASSERT_OK(w->Append(silly_id));
-          ASSERT_OK(w->Close());
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
-        Reopen(options);
-        std::string id5;
-        ASSERT_OK(db_->GetDbIdentity(id5));
-        if (with_manifest) {
-          // id4 should match id1 because identity was restored from manifest
-          ASSERT_EQ(id1, id5);
-        } else {
-          ASSERT_EQ(id5, silly_id);
-        }
-        if (write_file) {
-          ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
-          ASSERT_EQ(tmp, id5);
-        } else {
-          ASSERT_TRUE(env_->FileExists(idfilename).IsNotFound());
-        }
+      // Recover from deleted/missing IDENTITY
+      ASSERT_OK(env_->DeleteFile(idfilename));
+      Reopen(options);
+      std::string id3;
+      ASSERT_OK(db_->GetDbIdentity(id3));
+      if (with_manifest) {
+        // id3 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id3);
+      } else {
+        // id3 should NOT match id1 because identity was regenerated
+        ASSERT_NE(id1, id3);
+        ASSERT_GE(id3.size(), kMinIdSize);
       }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id3);
+
+      // Recover from truncated IDENTITY
+      {
+        std::unique_ptr<WritableFile> w;
+        ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
+        ASSERT_OK(w->Close());
+      }
+      Reopen(options);
+      std::string id4;
+      ASSERT_OK(db_->GetDbIdentity(id4));
+      if (with_manifest) {
+        // id4 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id4);
+      } else {
+        // id4 should NOT match id1 because identity was regenerated
+        ASSERT_NE(id1, id4);
+        ASSERT_GE(id4.size(), kMinIdSize);
+      }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id4);
+
+      // Recover from overwritten IDENTITY
+      std::string silly_id = "asdf123456789";
+      {
+        std::unique_ptr<WritableFile> w;
+        ASSERT_OK(env_->NewWritableFile(idfilename, &w, EnvOptions()));
+        ASSERT_OK(w->Append(silly_id));
+        ASSERT_OK(w->Close());
+      }
+      Reopen(options);
+      std::string id5;
+      ASSERT_OK(db_->GetDbIdentity(id5));
+      if (with_manifest) {
+        // id4 should match id1 because identity was restored from manifest
+        ASSERT_EQ(id1, id5);
+      } else {
+        ASSERT_EQ(id5, silly_id);
+      }
+      ASSERT_OK(ReadFileToString(env_, idfilename, &tmp));
+      ASSERT_EQ(tmp, id5);
     }
   } while (ChangeCompactOptions());
 }
@@ -3431,46 +3407,6 @@ class TableFileListener : public EventListener {
   InstrumentedMutex mutex_;
   std::unordered_map<std::string, std::vector<std::string>> cf_to_paths_;
 };
-
-class FlushTableFileListener : public EventListener {
- public:
-  void OnTableFileCreated(const TableFileCreationInfo& info) override {
-    InstrumentedMutexLock lock(&mutex_);
-    if (info.reason != TableFileCreationReason::kFlush) {
-      return;
-    }
-    cf_to_flushed_files_[info.cf_name].push_back(info.file_path);
-  }
-  std::vector<std::string>& GetFlushedFiles(const std::string& cf_name) {
-    InstrumentedMutexLock lock(&mutex_);
-    return cf_to_flushed_files_[cf_name];
-  }
-
- private:
-  InstrumentedMutex mutex_;
-  std::unordered_map<std::string, std::vector<std::string>>
-      cf_to_flushed_files_;
-};
-
-class FlushBlobFileListener : public EventListener {
- public:
-  void OnBlobFileCreated(const BlobFileCreationInfo& info) override {
-    InstrumentedMutexLock lock(&mutex_);
-    if (info.reason != BlobFileCreationReason::kFlush) {
-      return;
-    }
-    cf_to_flushed_blobs_files_[info.cf_name].push_back(info.file_path);
-  }
-  std::vector<std::string>& GetFlushedBlobFiles(const std::string& cf_name) {
-    InstrumentedMutexLock lock(&mutex_);
-    return cf_to_flushed_blobs_files_[cf_name];
-  }
-
- private:
-  InstrumentedMutex mutex_;
-  std::unordered_map<std::string, std::vector<std::string>>
-      cf_to_flushed_blobs_files_;
-};
 }  // anonymous namespace
 
 TEST_F(DBBasicTest, LastSstFileNotInManifest) {
@@ -3576,121 +3512,6 @@ TEST_F(DBBasicTest, RecoverWithMissingFiles) {
   }
 }
 
-// Param 0: whether to enable blob DB.
-// Param 1: when blob DB is enabled, whether to also delete the missing L0
-// file's associated blob file.
-class BestEffortsRecoverIncompleteVersionTest
-    : public DBTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  BestEffortsRecoverIncompleteVersionTest()
-      : DBTestBase("best_efforts_recover_incomplete_version_test",
-                   /*env_do_fsync=*/false) {}
-};
-
-TEST_P(BestEffortsRecoverIncompleteVersionTest, Basic) {
-  Options options = CurrentOptions();
-  options.enable_blob_files = std::get<0>(GetParam());
-  bool delete_blob_file_too = std::get<1>(GetParam());
-  DestroyAndReopen(options);
-  FlushTableFileListener* flush_table_listener = new FlushTableFileListener();
-  FlushBlobFileListener* flush_blob_listener = new FlushBlobFileListener();
-  // Disable auto compaction to simplify SST file name tracking.
-  options.disable_auto_compactions = true;
-  options.listeners.emplace_back(flush_table_listener);
-  options.listeners.emplace_back(flush_blob_listener);
-  CreateAndReopenWithCF({"pikachu", "eevee"}, options);
-  std::vector<std::string> all_cf_names = {kDefaultColumnFamilyName, "pikachu",
-                                           "eevee"};
-  int num_cfs = static_cast<int>(handles_.size());
-  ASSERT_EQ(3, num_cfs);
-  std::string start = "a";
-  Slice start_slice = start;
-  std::string end = "d";
-  Slice end_slice = end;
-  for (int cf = 0; cf != num_cfs; ++cf) {
-    ASSERT_OK(Put(cf, "a", "a_value"));
-    ASSERT_OK(Flush(cf));
-    // Compact file to L1 to avoid trivial file move in the next compaction
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), handles_[cf],
-                                &start_slice, &end_slice));
-    ASSERT_OK(Put(cf, "a", "a_value_new"));
-    ASSERT_OK(Flush(cf));
-    ASSERT_OK(Put(cf, "b", "b_value"));
-    ASSERT_OK(Flush(cf));
-    ASSERT_OK(Put(cf, "f", "f_value"));
-    ASSERT_OK(Flush(cf));
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), handles_[cf],
-                                &start_slice, &end_slice));
-  }
-
-  dbfull()->TEST_DeleteObsoleteFiles();
-
-  // Delete the most recent L0 file which is before a compaction.
-  for (int i = 0; i < num_cfs; ++i) {
-    std::vector<std::string>& files =
-        flush_table_listener->GetFlushedFiles(all_cf_names[i]);
-    ASSERT_EQ(4, files.size());
-    ASSERT_OK(env_->DeleteFile(files[files.size() - 1]));
-    if (options.enable_blob_files) {
-      std::vector<std::string>& blob_files =
-          flush_blob_listener->GetFlushedBlobFiles(all_cf_names[i]);
-      ASSERT_EQ(4, blob_files.size());
-      if (delete_blob_file_too) {
-        ASSERT_OK(env_->DeleteFile(blob_files[files.size() - 1]));
-      }
-    }
-  }
-  options.best_efforts_recovery = true;
-  ReopenWithColumnFamilies(all_cf_names, options);
-
-  for (int i = 0; i < num_cfs; ++i) {
-    auto cfh = static_cast<ColumnFamilyHandleImpl*>(handles_[i]);
-    ColumnFamilyData* cfd = cfh->cfd();
-    VersionStorageInfo* vstorage = cfd->current()->storage_info();
-    // The L0 file flushed right before the last compaction is missing.
-    ASSERT_EQ(0, vstorage->LevelFiles(0).size());
-    // Only the output of the last compaction is available.
-    ASSERT_EQ(1, vstorage->LevelFiles(1).size());
-  }
-  // Verify data
-  ReadOptions read_opts;
-  read_opts.total_order_seek = true;
-  for (int i = 0; i < num_cfs; ++i) {
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts, handles_[i]));
-    iter->SeekToFirst();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ("a", iter->key());
-    ASSERT_EQ("a_value_new", iter->value());
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ("b", iter->key());
-    ASSERT_EQ("b_value", iter->value());
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-  }
-
-  // Write more data.
-  for (int cf = 0; cf < num_cfs; ++cf) {
-    ASSERT_OK(Put(cf, "g", "g_value"));
-    ASSERT_OK(Flush(cf));
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), handles_[cf], nullptr,
-                                nullptr));
-    std::string value;
-    ASSERT_OK(db_->Get(ReadOptions(), handles_[cf], "g", &value));
-    ASSERT_EQ("g_value", value);
-  }
-}
-
-INSTANTIATE_TEST_CASE_P(BestEffortsRecoverIncompleteVersionTest,
-                        BestEffortsRecoverIncompleteVersionTest,
-                        testing::Values(std::make_tuple(false, false),
-                                        std::make_tuple(true, false),
-                                        std::make_tuple(true, true)));
-
 TEST_F(DBBasicTest, BestEffortsRecoveryTryMultipleManifests) {
   Options options = CurrentOptions();
   options.env = env_;

db/db_block_cache_test.cc

@@ -26,7 +26,6 @@
 #include "rocksdb/table_properties.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/unique_id_impl.h"
-#include "test_util/secondary_cache_test_util.h"
 #include "util/compression.h"
 #include "util/defer.h"
 #include "util/hash.h"
@@ -741,6 +740,118 @@ class LookupLiarCache : public CacheWrapper {
 
 }  // anonymous namespace
 
+TEST_F(DBBlockCacheTest, AddRedundantStats) {
+  const size_t capacity = size_t{1} << 25;
+  const int num_shard_bits = 0;  // 1 shard
+  int iterations_tested = 0;
+  for (const std::shared_ptr<Cache>& base_cache :
+       {NewLRUCache(capacity, num_shard_bits),
+        // FixedHyperClockCache
+        HyperClockCacheOptions(
+            capacity,
+            BlockBasedTableOptions().block_size /*estimated_value_size*/,
+            num_shard_bits)
+            .MakeSharedCache(),
+        // AutoHyperClockCache
+        HyperClockCacheOptions(capacity, 0 /*estimated_value_size*/,
+                               num_shard_bits)
+            .MakeSharedCache()}) {
+    if (!base_cache) {
+      // Skip clock cache when not supported
+      continue;
+    }
+    ++iterations_tested;
+    Options options = CurrentOptions();
+    options.create_if_missing = true;
+    options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+
+    std::shared_ptr<LookupLiarCache> cache =
+        std::make_shared<LookupLiarCache>(base_cache);
+
+    BlockBasedTableOptions table_options;
+    table_options.cache_index_and_filter_blocks = true;
+    table_options.block_cache = cache;
+    table_options.filter_policy.reset(NewBloomFilterPolicy(50));
+    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    DestroyAndReopen(options);
+
+    // Create a new table.
+    ASSERT_OK(Put("foo", "value"));
+    ASSERT_OK(Put("bar", "value"));
+    ASSERT_OK(Flush());
+    ASSERT_EQ(1, NumTableFilesAtLevel(0));
+
+    // Normal access filter+index+data.
+    ASSERT_EQ("value", Get("foo"));
+
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
+    // --------
+    ASSERT_EQ(3, TestGetTickerCount(options, BLOCK_CACHE_ADD));
+
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
+    // --------
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
+
+    // Againt access filter+index+data, but force redundant load+insert on index
+    cache->SetNthLookupNotFound(2);
+    ASSERT_EQ("value", Get("bar"));
+
+    ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
+    // --------
+    ASSERT_EQ(4, TestGetTickerCount(options, BLOCK_CACHE_ADD));
+
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
+    // --------
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
+
+    // Access just filter (with high probability), and force redundant
+    // load+insert
+    cache->SetNthLookupNotFound(1);
+    ASSERT_EQ("NOT_FOUND", Get("this key was not added"));
+
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
+    // --------
+    EXPECT_EQ(5, TestGetTickerCount(options, BLOCK_CACHE_ADD));
+
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
+    EXPECT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
+    // --------
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
+
+    // Access just data, forcing redundant load+insert
+    ReadOptions read_options;
+    std::unique_ptr<Iterator> iter{db_->NewIterator(read_options)};
+    cache->SetNthLookupNotFound(1);
+    iter->SeekToFirst();
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key(), "bar");
+
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
+    EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
+    // --------
+    EXPECT_EQ(6, TestGetTickerCount(options, BLOCK_CACHE_ADD));
+
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
+    EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
+    // --------
+    EXPECT_EQ(3, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
+  }
+  EXPECT_GE(iterations_tested, 1);
+}
+
 TEST_F(DBBlockCacheTest, ParanoidFileChecks) {
   Options options = CurrentOptions();
   options.create_if_missing = true;
@@ -1236,274 +1347,6 @@ TEST_F(DBBlockCacheTest, HyperClockCacheReportProblems) {
   EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 1, 0}}));
 }
 
-class DBBlockCacheTypeTest
-    : public DBBlockCacheTest,
-      public secondary_cache_test_util::WithCacheTypeParam {};
-
-INSTANTIATE_TEST_CASE_P(DBBlockCacheTypeTestInstance, DBBlockCacheTypeTest,
-                        secondary_cache_test_util::GetTestingCacheTypes());
-
-TEST_P(DBBlockCacheTypeTest, AddRedundantStats) {
-  BlockBasedTableOptions table_options;
-
-  const size_t capacity = size_t{1} << 25;
-  const int num_shard_bits = 0;  // 1 shard
-  estimated_value_size_ = table_options.block_size;
-  std::shared_ptr<Cache> base_cache =
-      NewCache(capacity, num_shard_bits, /*strict_capacity_limit=*/false);
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  std::shared_ptr<LookupLiarCache> cache =
-      std::make_shared<LookupLiarCache>(base_cache);
-
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.block_cache = cache;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(50));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  DestroyAndReopen(options);
-
-  // Create a new table.
-  ASSERT_OK(Put("foo", "value"));
-  ASSERT_OK(Put("bar", "value"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-
-  // Normal access filter+index+data.
-  ASSERT_EQ("value", Get("foo"));
-
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
-  // --------
-  ASSERT_EQ(3, TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
-  // --------
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
-
-  // Againt access filter+index+data, but force redundant load+insert on index
-  cache->SetNthLookupNotFound(2);
-  ASSERT_EQ("value", Get("bar"));
-
-  ASSERT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
-  // --------
-  ASSERT_EQ(4, TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
-  ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
-  // --------
-  ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
-
-  // Access just filter (with high probability), and force redundant
-  // load+insert
-  cache->SetNthLookupNotFound(1);
-  ASSERT_EQ("NOT_FOUND", Get("this key was not added"));
-
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
-  // --------
-  EXPECT_EQ(5, TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
-  EXPECT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
-  // --------
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
-
-  // Access just data, forcing redundant load+insert
-  ReadOptions read_options;
-  std::unique_ptr<Iterator> iter{db_->NewIterator(read_options)};
-  cache->SetNthLookupNotFound(1);
-  iter->SeekToFirst();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(iter->key(), "bar");
-
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD));
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD));
-  EXPECT_EQ(2, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD));
-  // --------
-  EXPECT_EQ(6, TestGetTickerCount(options, BLOCK_CACHE_ADD));
-
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_INDEX_ADD_REDUNDANT));
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_FILTER_ADD_REDUNDANT));
-  EXPECT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_DATA_ADD_REDUNDANT));
-  // --------
-  EXPECT_EQ(3, TestGetTickerCount(options, BLOCK_CACHE_ADD_REDUNDANT));
-}
-
-namespace {
-std::string AltKey(int i) {
-  char buf[100];
-  snprintf(buf, sizeof(buf), "altkey%06d", i);
-  return std::string(buf);
-}
-}  // namespace
-
-TEST_P(DBBlockCacheTypeTest, Uncache) {
-  for (bool partitioned : {false, true}) {
-    SCOPED_TRACE("partitioned=" + std::to_string(partitioned));
-    for (uint32_t ua : {0, 1, 2, 10000}) {
-      SCOPED_TRACE("ua=" + std::to_string(ua));
-
-      BlockBasedTableOptions table_options;
-      Options options = CurrentOptions();
-      options.uncache_aggressiveness = ua;
-      options.create_if_missing = true;
-      // Don't allow background operations to keep Versions referenced
-      options.stats_dump_period_sec = 0;
-      options.stats_persist_period_sec = 0;
-      auto stats = ROCKSDB_NAMESPACE::CreateDBStatistics();
-      options.statistics = stats;
-
-      const size_t capacity = size_t{1} << 25;
-      const int num_shard_bits = 0;  // 1 shard
-      estimated_value_size_ = table_options.block_size;
-      std::shared_ptr<Cache> cache =
-          NewCache(capacity, num_shard_bits, /*strict_capacity_limit=*/false);
-
-      table_options.cache_index_and_filter_blocks = true;
-      table_options.block_cache = cache;
-      table_options.filter_policy.reset(NewBloomFilterPolicy(10));
-      table_options.partition_filters = partitioned;
-      table_options.index_type =
-          partitioned ? BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch
-                      : BlockBasedTableOptions::IndexType::kBinarySearch;
-      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-      DestroyAndReopen(options);
-
-      size_t kBaselineCount = 1;  // Because of entry stats collector
-
-      ASSERT_EQ(kBaselineCount, cache->GetOccupancyCount());
-      ASSERT_EQ(0U, cache->GetUsage());
-
-      constexpr uint8_t kNumDataBlocks = 10;
-      constexpr uint8_t kNumFiles = 3;
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        // Force some overlap with ordering
-        ASSERT_OK(Put(Key((i * 7) % kNumDataBlocks),
-                      Random::GetTLSInstance()->RandomBinaryString(
-                          static_cast<int>(table_options.block_size))));
-        if (i >= kNumDataBlocks - kNumFiles) {
-          ASSERT_OK(Flush());
-        }
-      }
-      ASSERT_EQ(int{kNumFiles}, NumTableFilesAtLevel(0));
-
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        ASSERT_NE(Get(Key(i)), "NOT_FOUND");
-      }
-
-      size_t meta_blocks_per_file = /*index & filter*/ 2U * (1U + partitioned);
-      ASSERT_EQ(
-          cache->GetOccupancyCount(),
-          kBaselineCount + kNumDataBlocks + meta_blocks_per_file * kNumFiles);
-      ASSERT_GE(cache->GetUsage(), kNumDataBlocks * table_options.block_size);
-
-      // Combine into one file, making the originals obsolete
-      ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-      ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
-
-      ASSERT_EQ(1, NumTableFilesAtLevel(1));
-
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        ASSERT_NE(Get(Key(i)), "NOT_FOUND");
-      }
-
-      if (ua == 0) {
-        // Expect to see cache entries for new file and obsolete files
-        EXPECT_EQ(cache->GetOccupancyCount(),
-                  kBaselineCount + kNumDataBlocks * 2U +
-                      meta_blocks_per_file * (kNumFiles + 1));
-        EXPECT_GE(cache->GetUsage(),
-                  kNumDataBlocks * table_options.block_size * 2U);
-      } else {
-        // Expect only to see cache entries for new file
-        EXPECT_EQ(cache->GetOccupancyCount(),
-                  kBaselineCount + kNumDataBlocks + meta_blocks_per_file);
-        EXPECT_GE(cache->GetUsage(), kNumDataBlocks * table_options.block_size);
-        EXPECT_LT(cache->GetUsage(),
-                  kNumDataBlocks * table_options.block_size * 2U);
-      }
-
-      size_t alt_baseline_count = cache->GetOccupancyCount();
-      size_t alt_baseline_usage = cache->GetUsage();
-      ASSERT_OK(stats->Reset());
-      // We aren't generally cleaning up cache entries on DB::Close, especially
-      // because someone might just re-open the same DB.
-      Reopen(options);
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        ASSERT_NE(Get(Key(i)), "NOT_FOUND");
-      }
-
-      EXPECT_EQ(cache->GetOccupancyCount(), alt_baseline_count);
-      EXPECT_EQ(cache->GetUsage(), alt_baseline_usage);
-
-      // Check for unnecessary unncessary cache churn
-      ASSERT_EQ(stats->getTickerCount(BLOCK_CACHE_ADD), 0U);
-      ASSERT_EQ(stats->getTickerCount(BLOCK_CACHE_MISS), 0U);
-      ASSERT_GT(stats->getTickerCount(BLOCK_CACHE_HIT), 0U);
-
-      // And now do a similar test as above except with trivial moves, making
-      // sure that we aren't falsely uncaching in that case, which would cause
-      // unnecessary cache misses. Using AltKey instead of Key to avoid
-      // interference.
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        // No overlap
-        ASSERT_OK(
-            Put(AltKey(i), Random::GetTLSInstance()->RandomBinaryString(
-                               static_cast<int>(table_options.block_size))));
-        if (i >= kNumDataBlocks - kNumFiles) {
-          ASSERT_OK(Flush());
-        }
-      }
-      ASSERT_EQ(int{kNumFiles}, NumTableFilesAtLevel(0));
-
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        ASSERT_NE(Get(AltKey(i)), "NOT_FOUND");
-      }
-
-      ASSERT_EQ(cache->GetOccupancyCount(),
-                alt_baseline_count + kNumDataBlocks +
-                    meta_blocks_per_file * kNumFiles);
-      ASSERT_GE(cache->GetUsage(),
-                alt_baseline_usage + kNumDataBlocks * table_options.block_size);
-
-      ASSERT_OK(stats->Reset());
-
-      // Make trivial move
-      {
-        auto a = AltKey(0);
-        auto b = AltKey(kNumDataBlocks);
-        Slice slice_a{a};
-        Slice slice_b{b};
-        ASSERT_OK(db_->CompactRange({}, &slice_a, &slice_b));
-      }
-      ASSERT_EQ(/*old*/ 1 + /*new*/ int{kNumFiles}, NumTableFilesAtLevel(1));
-
-      for (int i = 0; i < kNumDataBlocks; i++) {
-        ASSERT_NE(Get(AltKey(i)), "NOT_FOUND");
-      }
-
-      // Should be the same if trivial move
-      ASSERT_EQ(cache->GetOccupancyCount(),
-                alt_baseline_count + kNumDataBlocks +
-                    meta_blocks_per_file * kNumFiles);
-
-      // Check for unnecessary unncessary cache churn
-      ASSERT_EQ(stats->getTickerCount(BLOCK_CACHE_ADD), 0U);
-      ASSERT_EQ(stats->getTickerCount(BLOCK_CACHE_MISS), 0U);
-      ASSERT_GT(stats->getTickerCount(BLOCK_CACHE_HIT), 0U);
-    }
-  }
-}
 
 class DBBlockCacheKeyTest
     : public DBTestBase,

db/db_compaction_test.cc

@@ -16,7 +16,6 @@
 #include "env/mock_env.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
-#include "rocksdb/advanced_options.h"
 #include "rocksdb/concurrent_task_limiter.h"
 #include "rocksdb/experimental.h"
 #include "rocksdb/sst_file_writer.h"
@@ -6146,7 +6145,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
 
   std::vector<std::string> pending_compaction_cfs;
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "EnqueuePendingCompaction::cfd", [&](void* arg) {
+      "SchedulePendingCompaction::cfd", [&](void* arg) {
         const std::string& cf_name =
             static_cast<ColumnFamilyData*>(arg)->GetName();
         pending_compaction_cfs.emplace_back(cf_name);
@@ -6205,14 +6204,29 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
               NumTableFilesAtLevel(0, 0));
   }
 
-  // Wait until all CFs are pending compaction. WaitForFlushMemtable() can
-  // return before the next compaction is scheduled, so we need to do some
-  // waiting here.
+  // All CFs are pending compaction
   unsigned int tp_len = env_->GetThreadPoolQueueLen(Env::LOW);
-  for (int i = 0; i < 10000 && tp_len < cf_count; i++) {
-    env_->SleepForMicroseconds(1000);
-    tp_len = env_->GetThreadPoolQueueLen(Env::LOW);
+  if (cf_count != tp_len) {
+    // The test is flaky and fails the assertion below.
+    // Print some debug information.
+    uint64_t num_running_flushes = 0;
+    if (db_->GetIntProperty(DB::Properties::kNumRunningFlushes,
+                            &num_running_flushes)) {
+      fprintf(stdout, "Running flushes: %" PRIu64 "\n", num_running_flushes);
+    }
+    fprintf(stdout,
+            "%zu CF in compaction queue: ", pending_compaction_cfs.size());
+    for (const auto& cf_name : pending_compaction_cfs) {
+      fprintf(stdout, "%s, ", cf_name.c_str());
+    }
+    fprintf(stdout, "\n");
+
+    // print lsm
+    for (unsigned int cf = 0; cf < cf_count; cf++) {
+      fprintf(stdout, "%s: %s\n", cf_names[cf], FilesPerLevel(cf).c_str());
+    }
   }
+
   ASSERT_EQ(cf_count, tp_len);
 
   // Unblock all compaction threads
@@ -7121,8 +7135,7 @@ class DBCompactionTestWithOngoingFileIngestionParam
       SyncPoint::GetInstance()->SetCallBack(
           "ExternalSstFileIngestionJob::Run", [&](void*) {
             SyncPoint::GetInstance()->LoadDependency(
-                {{"DBImpl::CompactFilesImpl::"
-                  "PostSanitizeAndConvertCompactionInputFiles",
+                {{"DBImpl::CompactFilesImpl::PostSanitizeCompactionInputFiles",
                   "VersionSet::LogAndApply:WriteManifest"}});
           });
     } else {
@@ -7604,72 +7617,6 @@ class DBCompactionTestL0FilesMisorderCorruption : public DBCompactionTest {
   std::shared_ptr<test::SleepingBackgroundTask> sleeping_task_;
 };
 
-TEST_F(DBCompactionTest, CompactFilesSupportKeyPlacementRangeConflict) {
-  Options options;
-  options.create_if_missing = true;
-  options.compaction_style = kCompactionStyleUniversal;
-  options.num_levels = 3;
-  DestroyAndReopen(options);
-
-  // To create LSM of below shape:
-  // L0: [k2]
-  // L1: [k3],[k4]
-  // L2: [k1,  k5]
-  ASSERT_OK(Put("k1", "v"));
-  ASSERT_OK(Put("k5", "v"));
-  ASSERT_OK(Flush());
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForceOptimized;
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-  ASSERT_EQ("0,0,1", FilesPerLevel());
-
-  ASSERT_OK(Put("k3", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k4", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(experimental::PromoteL0(db_, db_->DefaultColumnFamily(), 1));
-  ASSERT_EQ("0,2,1", FilesPerLevel());
-
-  ASSERT_OK(Put("k2", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ("1,2,1", FilesPerLevel());
-
-  Close();
-
-  // To force below two CompactFiles() in order to coerce range conflict on L1
-  // upon (2)
-  // (1): Compact [k2] at L0 and [k3] at L1 with output to L1
-  // (2): Compact [k4] at L1 and [k1, k5] at L2 and output to L1 and L2
-  options.preclude_last_level_data_seconds = 1;
-  Reopen(options);
-
-  ColumnFamilyMetaData cf_meta_data;
-  db_->GetColumnFamilyMetaData(&cf_meta_data);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactFilesImpl:0", [&](void* /*arg*/) {
-        std::vector<std::string> c2_input_files;
-        c2_input_files.push_back(cf_meta_data.levels[1].files[1].name);
-        c2_input_files.push_back(cf_meta_data.levels[2].files[0].name);
-        // To verify CompactFiles() is aborted upon range conflict instead
-        // of crashing upon internal assertion
-        Status s = db_->CompactFiles(CompactionOptions(), c2_input_files,
-                                     2 /* output_level */);
-        ASSERT_TRUE(s.IsAborted());
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<std::string> c1_input_files;
-  c1_input_files.push_back(cf_meta_data.levels[0].files[0].name);
-  c1_input_files.push_back(cf_meta_data.levels[1].files[0].name);
-  Status s = db_->CompactFiles(CompactionOptions(), c1_input_files,
-                               1 /* output_level */);
-  ASSERT_OK(s);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(DBCompactionTestL0FilesMisorderCorruption,
        FlushAfterIntraL0LevelCompactionWithIngestedFile) {
   SetupOptions(CompactionStyle::kCompactionStyleLevel, "");
@@ -9357,13 +9304,12 @@ TEST_F(DBCompactionTest, FIFOChangeTemperature) {
     ASSERT_OK(Flush());
 
     ASSERT_OK(Put(Key(0), "value1"));
+    env_->MockSleepForSeconds(800);
     ASSERT_OK(Put(Key(2), "value2"));
     ASSERT_OK(Flush());
 
-    // First two L0 files both become eligible for temperature change compaction
-    // They should be compacted one-by-one.
     ASSERT_OK(Put(Key(0), "value1"));
-    env_->MockSleepForSeconds(1200);
+    env_->MockSleepForSeconds(800);
     ASSERT_OK(Put(Key(2), "value2"));
     ASSERT_OK(Flush());
     ASSERT_OK(dbfull()->TEST_WaitForCompact());

db/db_filesnapshot.cc

@@ -21,7 +21,6 @@
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/metadata.h"
-#include "rocksdb/transaction_log.h"
 #include "rocksdb/types.h"
 #include "test_util/sync_point.h"
 #include "util/file_checksum_helper.h"
@@ -92,12 +91,7 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
   return Status::OK();
 }
 
-Status DBImpl::GetSortedWalFiles(VectorWalPtr& files) {
-  return GetSortedWalFilesImpl(files,
-                               /*need_seqnos*/ true);
-}
-
-Status DBImpl::GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos) {
+Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
   // Record tracked WALs as a (minimum) cross-check for directory scan
   std::vector<uint64_t> required_by_manifest;
 
@@ -123,10 +117,7 @@ Status DBImpl::GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos) {
     }
   }
 
-  // NOTE: need to include archived WALs because needed WALs might have been
-  // archived since getting required_by_manifest set
-  Status s = wal_manager_.GetSortedWalFiles(files, need_seqnos,
-                                            /*include_archived*/ true);
+  Status s = wal_manager_.GetSortedWalFiles(files);
 
   // DisableFileDeletions / EnableFileDeletions not supported in read-only DB
   if (deletions_disabled.ok()) {
@@ -161,11 +152,11 @@ Status DBImpl::GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos) {
   }
 
   if (s.ok()) {
-    size_t wal_count = files.size();
+    size_t wal_size = files.size();
     ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "Number of WAL files %" ROCKSDB_PRIszt " (%" ROCKSDB_PRIszt
+                   "Number of log files %" ROCKSDB_PRIszt " (%" ROCKSDB_PRIszt
                    " required by manifest)",
-                   wal_count, required_by_manifest.size());
+                   wal_size, required_by_manifest.size());
 #ifndef NDEBUG
     std::ostringstream wal_names;
     for (const auto& wal : files) {
@@ -186,7 +177,7 @@ Status DBImpl::GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos) {
   return s;
 }
 
-Status DBImpl::GetCurrentWalFile(std::unique_ptr<WalFile>* current_log_file) {
+Status DBImpl::GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) {
   uint64_t current_logfile_number;
   {
     InstrumentedMutexLock l(&mutex_);
@@ -207,20 +198,14 @@ Status DBImpl::GetLiveFilesStorageInfo(
   // NOTE: This implementation was largely migrated from Checkpoint.
 
   Status s;
-  VectorWalPtr live_wal_files;
+  VectorLogPtr live_wal_files;
   bool flush_memtable = true;
   if (!immutable_db_options_.allow_2pc) {
     if (opts.wal_size_for_flush == std::numeric_limits<uint64_t>::max()) {
       flush_memtable = false;
     } else if (opts.wal_size_for_flush > 0) {
-      // FIXME: avoid querying the filesystem for current WAL state
-      // If the outstanding WAL files are small, we skip the flush.
-      // Don't take archived log size into account when calculating wal
-      // size for flush, and don't need to verify consistency with manifest
-      // here & now.
-      s = wal_manager_.GetSortedWalFiles(live_wal_files,
-                                         /* need_seqnos */ false,
-                                         /*include_archived*/ false);
+      // If the outstanding log files are small, we skip the flush.
+      s = GetSortedWalFiles(live_wal_files);
 
       if (!s.ok()) {
         return s;
@@ -231,7 +216,6 @@ Status DBImpl::GetLiveFilesStorageInfo(
       // We may be able to cover 2PC case too.
       uint64_t total_wal_size = 0;
       for (auto& wal : live_wal_files) {
-        assert(wal->Type() == kAliveLogFile);
         total_wal_size += wal->SizeFileBytes();
       }
       if (total_wal_size < opts.wal_size_for_flush) {
@@ -245,18 +229,12 @@ Status DBImpl::GetLiveFilesStorageInfo(
   // metadata.
   mutex_.Lock();
   if (flush_memtable) {
-    bool wal_locked = lock_wal_count_ > 0;
-    if (wal_locked) {
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Can't FlushForGetLiveFiles while WAL is locked");
-    } else {
-      Status status = FlushForGetLiveFiles();
-      if (!status.ok()) {
-        mutex_.Unlock();
-        ROCKS_LOG_ERROR(immutable_db_options_.info_log,
-                        "Cannot Flush data %s\n", status.ToString().c_str());
-        return status;
-      }
+    Status status = FlushForGetLiveFiles();
+    if (!status.ok()) {
+      mutex_.Unlock();
+      ROCKS_LOG_ERROR(immutable_db_options_.info_log, "Cannot Flush data %s\n",
+                      status.ToString().c_str());
+      return status;
     }
   }
 
@@ -332,8 +310,6 @@ Status DBImpl::GetLiveFilesStorageInfo(
   const uint64_t options_number = versions_->options_file_number();
   const uint64_t options_size = versions_->options_file_size_;
   const uint64_t min_log_num = MinLogNumberToKeep();
-  // Ensure consistency with manifest for track_and_verify_wals_in_manifest
-  const uint64_t max_log_num = logfile_number_;
 
   mutex_.Unlock();
 
@@ -397,13 +373,10 @@ Status DBImpl::GetLiveFilesStorageInfo(
   TEST_SYNC_POINT("CheckpointImpl::CreateCheckpoint:SavedLiveFiles2");
 
   if (s.ok()) {
-    // FlushWAL is required to ensure we can physically copy everything
-    // logically written to the WAL. (Sync not strictly required for
-    // active WAL to be copied rather than hard linked, even when
-    // Checkpoint guarantees that the copied-to file is sync-ed. Plus we can't
-    // help track_and_verify_wals_in_manifest after manifest_size is
-    // already determined.)
-    s = FlushWAL(/*sync=*/false);
+    // To maximize the effectiveness of track_and_verify_wals_in_manifest,
+    // sync WAL when it is enabled.
+    s = FlushWAL(
+        immutable_db_options_.track_and_verify_wals_in_manifest /* sync */);
     if (s.IsNotSupported()) {  // read-only DB or similar
       s = Status::OK();
     }
@@ -412,52 +385,21 @@ Status DBImpl::GetLiveFilesStorageInfo(
   TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive1");
   TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive2");
 
-  // Even after WAL flush, there could be multiple WALs that are not
-  // fully synced. Although the output DB of a Checkpoint or Backup needs
-  // to be fully synced on return, we don't strictly need to sync this
-  // DB (the input DB). If we allow Checkpoint to hard link an inactive
-  // WAL that isn't fully synced, that could result in an insufficiently
-  // sync-ed Checkpoint. Here we get the set of WALs that are potentially
-  // unsynced or still being written to, to prevent them from being hard
-  // linked. Enforcing max_log_num from above ensures any new WALs after
-  // GetOpenWalSizes() and before GetSortedWalFiles() are not included in
-  // the results.
-  // NOTE: we might still hard link a file that is open for writing, even
-  // if we don't do any more writes to it.
-  //
-  // In a step toward reducing unnecessary file metadata queries, we also
-  // get and use our known flushed sizes for those WALs.
-  // FIXME: eventually we should not be using filesystem queries at all for
-  // the required set of WAL files.
-  //
-  // However for recycled log files, we just copy the whole file,
-  // for better or worse.
-  //
-  std::map<uint64_t, uint64_t> open_wal_number_to_size;
-  bool recycling_log_files = immutable_db_options_.recycle_log_file_num > 0;
-  if (s.ok() && !recycling_log_files) {
-    s = GetOpenWalSizes(open_wal_number_to_size);
-  }
-
-  // [old comment] If we have more than one column family, we also need to get
-  // WAL files.
+  // If we have more than one column family, we also need to get WAL files.
   if (s.ok()) {
-    // FIXME: avoid querying the filesystem for current WAL state
-    s = GetSortedWalFilesImpl(live_wal_files,
-                              /* need_seqnos */ false);
+    s = GetSortedWalFiles(live_wal_files);
   }
   if (!s.ok()) {
     return s;
   }
 
-  size_t wal_count = live_wal_files.size();
+  size_t wal_size = live_wal_files.size();
   // Link WAL files. Copy exact size of last one because it is the only one
   // that has changes after the last flush.
   auto wal_dir = immutable_db_options_.GetWalDir();
-  for (size_t i = 0; s.ok() && i < wal_count; ++i) {
+  for (size_t i = 0; s.ok() && i < wal_size; ++i) {
     if ((live_wal_files[i]->Type() == kAliveLogFile) &&
-        (!flush_memtable || live_wal_files[i]->LogNumber() >= min_log_num) &&
-        live_wal_files[i]->LogNumber() <= max_log_num) {
+        (!flush_memtable || live_wal_files[i]->LogNumber() >= min_log_num)) {
       results.emplace_back();
       LiveFileStorageInfo& info = results.back();
       auto f = live_wal_files[i]->PathName();
@@ -466,29 +408,12 @@ Status DBImpl::GetLiveFilesStorageInfo(
       info.directory = wal_dir;
       info.file_number = live_wal_files[i]->LogNumber();
       info.file_type = kWalFile;
-      if (recycling_log_files) {
-        info.size = live_wal_files[i]->SizeFileBytes();
-        // Recyclable WAL files must be copied instead of hard linked
-        info.trim_to_size = true;
-      } else {
-        auto it = open_wal_number_to_size.find(info.file_number);
-        if (it == open_wal_number_to_size.end()) {
-          // Known fully synced and no future writes (in part from
-          // max_log_num check). Ok to hard link
-          info.size = live_wal_files[i]->SizeFileBytes();
-          assert(!info.trim_to_size);
-        } else {
-          // Marked as (possibly) still open -> use our known flushed size
-          // and force file copy instead of hard link
-          info.size = it->second;
-          info.trim_to_size = true;
-          // FIXME: this is needed as long as db_stress uses
-          // SetReadUnsyncedData(false), because it will only be able to
-          // copy the synced portion of the WAL, which under
-          // SetReadUnsyncedData(false) is given by the reported file size.
-          info.size = std::min(info.size, live_wal_files[i]->SizeFileBytes());
-        }
-      }
+      info.size = live_wal_files[i]->SizeFileBytes();
+      // Trim the log either if its the last one, or log file recycling is
+      // enabled. In the latter case, a hard link doesn't prevent the file
+      // from being renamed and recycled. So we need to copy it instead.
+      info.trim_to_size = (i + 1 == wal_size) ||
+                          (immutable_db_options_.recycle_log_file_num > 0);
       if (opts.include_checksum_info) {
         info.file_checksum_func_name = kUnknownFileChecksumFuncName;
         info.file_checksum = kUnknownFileChecksum;

db/db_flush_test.cc

@@ -86,8 +86,8 @@ TEST_F(DBFlushTest, SyncFail) {
   options.env = fault_injection_env.get();
 
   SyncPoint::GetInstance()->LoadDependency(
-      {{"DBFlushTest::SyncFail:1", "DBImpl::SyncClosedWals:Start"},
-       {"DBImpl::SyncClosedWals:Failed", "DBFlushTest::SyncFail:2"}});
+      {{"DBFlushTest::SyncFail:1", "DBImpl::SyncClosedLogs:Start"},
+       {"DBImpl::SyncClosedLogs:Failed", "DBFlushTest::SyncFail:2"}});
   SyncPoint::GetInstance()->EnableProcessing();
 
   CreateAndReopenWithCF({"pikachu"}, options);
@@ -111,8 +111,8 @@ TEST_F(DBFlushTest, SyncSkip) {
   Options options = CurrentOptions();
 
   SyncPoint::GetInstance()->LoadDependency(
-      {{"DBFlushTest::SyncSkip:1", "DBImpl::SyncClosedWals:Skip"},
-       {"DBImpl::SyncClosedWals:Skip", "DBFlushTest::SyncSkip:2"}});
+      {{"DBFlushTest::SyncSkip:1", "DBImpl::SyncClosedLogs:Skip"},
+       {"DBImpl::SyncClosedLogs:Skip", "DBFlushTest::SyncSkip:2"}});
   SyncPoint::GetInstance()->EnableProcessing();
 
   Reopen(options);
@@ -2381,7 +2381,7 @@ TEST_F(DBFlushTest, PickRightMemtables) {
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();
   SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::SyncClosedWals:BeforeReLock", [&](void* /*arg*/) {
+      "DBImpl::SyncClosedLogs:BeforeReLock", [&](void* /*arg*/) {
         ASSERT_OK(db_->Put(WriteOptions(), handles_[1], "what", "v"));
         auto* cfhi =
             static_cast_with_check<ColumnFamilyHandleImpl>(handles_[1]);

db/db_follower_test.cc

@@ -17,7 +17,6 @@ class DBFollowerTest : public DBTestBase {
   // Create the leader DB object
   DBFollowerTest() : DBTestBase("/db_follower_test", /*env_do_fsync*/ false) {
     follower_name_ = dbname_ + "/follower";
-    db_parent_ = dbname_;
     Close();
     Destroy(CurrentOptions());
     EXPECT_EQ(env_->CreateDirIfMissing(dbname_), Status::OK());
@@ -28,215 +27,17 @@ class DBFollowerTest : public DBTestBase {
   ~DBFollowerTest() {
     follower_.reset();
     EXPECT_EQ(DestroyDB(follower_name_, CurrentOptions()), Status::OK());
-    Destroy(CurrentOptions());
-    dbname_ = db_parent_;
   }
 
  protected:
-  class DBFollowerTestFS : public FileSystemWrapper {
-   public:
-    explicit DBFollowerTestFS(const std::shared_ptr<FileSystem>& target)
-        : FileSystemWrapper(target),
-          cv_(&mutex_),
-          barrier_(false),
-          count_(0),
-          reinit_count_(0) {}
-
-    const char* Name() const override { return "DBFollowerTestFS"; }
-
-    IOStatus NewSequentialFile(const std::string& fname,
-                               const FileOptions& file_opts,
-                               std::unique_ptr<FSSequentialFile>* result,
-                               IODebugContext* dbg = nullptr) override {
-      class DBFollowerTestSeqFile : public FSSequentialFileWrapper {
-       public:
-        DBFollowerTestSeqFile(DBFollowerTestFS* fs,
-                              std::unique_ptr<FSSequentialFile>&& file,
-                              uint64_t /*size*/)
-            : FSSequentialFileWrapper(file.get()),
-              fs_(fs),
-              file_(std::move(file)) {}
-
-        IOStatus Read(size_t n, const IOOptions& options, Slice* result,
-                      char* scratch, IODebugContext* dbg) override {
-          fs_->BarrierWait();
-          return target()->Read(n, options, result, scratch, dbg);
-        }
-
-       private:
-        DBFollowerTestFS* fs_;
-        std::unique_ptr<FSSequentialFile> file_;
-      };
-
-      std::unique_ptr<FSSequentialFile> file;
-      IOStatus s = target()->NewSequentialFile(fname, file_opts, &file, dbg);
-
-      if (s.ok() && test::GetFileType(fname) == kDescriptorFile) {
-        uint64_t size = 0;
-        EXPECT_EQ(target()->GetFileSize(fname, IOOptions(), &size, nullptr),
-                  IOStatus::OK());
-        result->reset(new DBFollowerTestSeqFile(this, std::move(file), size));
-      } else {
-        *result = std::move(file);
-      }
-      return s;
-    }
-
-    void BarrierInit(int count) {
-      MutexLock l(&mutex_);
-      barrier_ = true;
-      count_ = count;
-    }
-
-    void BarrierWait() {
-      MutexLock l(&mutex_);
-      if (!barrier_) {
-        return;
-      }
-      if (--count_ == 0) {
-        if (reinit_count_ > 0) {
-          count_ = reinit_count_;
-          reinit_count_ = 0;
-        } else {
-          barrier_ = false;
-        }
-        cv_.SignalAll();
-      } else {
-        cv_.Wait();
-      }
-    }
-
-    void BarrierWaitAndReinit(int count) {
-      MutexLock l(&mutex_);
-      if (!barrier_) {
-        return;
-      }
-      reinit_count_ = count;
-      if (--count_ == 0) {
-        if (reinit_count_ > 0) {
-          count_ = reinit_count_;
-          reinit_count_ = 0;
-        } else {
-          barrier_ = false;
-        }
-        cv_.SignalAll();
-      } else {
-        cv_.Wait();
-      }
-    }
-
-   private:
-    port::Mutex mutex_;
-    port::CondVar cv_;
-    bool barrier_;
-    int count_;
-    int reinit_count_;
-  };
-
-  class DBFollowerTestSstPartitioner : public SstPartitioner {
-   public:
-    explicit DBFollowerTestSstPartitioner(uint64_t max_keys)
-        : max_keys_(max_keys), num_keys_(0) {}
-
-    const char* Name() const override { return "DBFollowerTestSstPartitioner"; }
-
-    PartitionerResult ShouldPartition(
-        const PartitionerRequest& /*request*/) override {
-      if (++num_keys_ > max_keys_) {
-        num_keys_ = 0;
-        return PartitionerResult::kRequired;
-      } else {
-        return PartitionerResult::kNotRequired;
-      }
-    }
-
-    bool CanDoTrivialMove(const Slice& /*smallest_user_key*/,
-                          const Slice& /*largest_user_key*/) override {
-      return true;
-    }
-
-   private:
-    uint64_t max_keys_;
-    uint64_t num_keys_;
-  };
-
-  class DBFollowerTestSstPartitionerFactory : public SstPartitionerFactory {
-   public:
-    explicit DBFollowerTestSstPartitionerFactory(uint64_t max_keys)
-        : max_keys_(max_keys) {}
-
-    std::unique_ptr<SstPartitioner> CreatePartitioner(
-        const SstPartitioner::Context& /*context*/) const override {
-      std::unique_ptr<SstPartitioner> partitioner;
-      partitioner.reset(new DBFollowerTestSstPartitioner(max_keys_));
-      return partitioner;
-    }
-
-    const char* Name() const override {
-      return "DBFollowerTestSstPartitionerFactory";
-    }
-
-   private:
-    uint64_t max_keys_;
-  };
-
   Status OpenAsFollower() {
-    Options opts = CurrentOptions();
-    if (!follower_env_) {
-      follower_env_ = NewCompositeEnv(
-          std::make_shared<DBFollowerTestFS>(env_->GetFileSystem()));
-    }
-    opts.env = follower_env_.get();
-    opts.follower_refresh_catchup_period_ms = 100;
-    return DB::OpenAsFollower(opts, follower_name_, dbname_, &follower_);
+    return DB::OpenAsFollower(CurrentOptions(), follower_name_, dbname_,
+                              &follower_);
   }
-
-  std::string FollowerGet(const std::string& k) {
-    ReadOptions options;
-    options.verify_checksums = true;
-    std::string result;
-    Status s = follower()->Get(options, k, &result);
-    if (s.IsNotFound()) {
-      result = "NOT_FOUND";
-    } else if (!s.ok()) {
-      result = s.ToString();
-    }
-    return result;
-  }
-
   DB* follower() { return follower_.get(); }
-  DBFollowerTestFS* follower_fs() {
-    return static_cast<DBFollowerTestFS*>(follower_env_->GetFileSystem().get());
-  }
-
-  void CheckDirs() {
-    std::vector<std::string> db_children;
-    std::vector<std::string> follower_children;
-    EXPECT_OK(env_->GetChildren(dbname_, &db_children));
-    EXPECT_OK(env_->GetChildren(follower_name_, &follower_children));
-
-    std::set<uint64_t> db_filenums;
-    std::set<uint64_t> follower_filenums;
-    for (auto& name : db_children) {
-      if (test::GetFileType(name) != kTableFile) {
-        continue;
-      }
-      db_filenums.insert(test::GetFileNumber(name));
-    }
-    for (auto& name : follower_children) {
-      if (test::GetFileType(name) != kTableFile) {
-        continue;
-      }
-      follower_filenums.insert(test::GetFileNumber(name));
-    }
-    db_filenums.merge(follower_filenums);
-    EXPECT_EQ(follower_filenums.size(), db_filenums.size());
-  }
 
  private:
   std::string follower_name_;
-  std::string db_parent_;
-  std::unique_ptr<Env> follower_env_;
   std::unique_ptr<DB> follower_;
 };
 
@@ -250,277 +51,8 @@ TEST_F(DBFollowerTest, Basic) {
   std::string val;
   ASSERT_OK(follower()->Get(ReadOptions(), "k1", &val));
   ASSERT_EQ(val, "v1");
-  CheckDirs();
 }
 
-TEST_F(DBFollowerTest, Flush) {
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:Begin1", "Leader::Start"},
-      {"Leader::Done", "DBImplFollower::TryCatchupWithLeader:Begin2"},
-      {"DBImplFollower::TryCatchupWithLeader:End", "Follower::WaitForCatchup"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(OpenAsFollower());
-  TEST_SYNC_POINT("Leader::Start");
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Flush());
-  TEST_SYNC_POINT("Leader::Done");
-
-  TEST_SYNC_POINT("Follower::WaitForCatchup");
-  std::string val;
-  ASSERT_OK(follower()->Get(ReadOptions(), "k1", &val));
-  ASSERT_EQ(val, "v1");
-  CheckDirs();
-
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// This test creates 4 L0 files, immediately followed by a compaction to L1.
-// The follower replays the 4 flush records from the MANIFEST unsuccessfully,
-// and then successfully recovers a Version from the compaction record
-TEST_F(DBFollowerTest, RetryCatchup) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  Reopen(opts);
-
-  ASSERT_OK(OpenAsFollower());
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:Begin1", "Leader::Start"},
-      {"DBImpl::BackgroundCompaction:Start",
-       "DBImplFollower::TryCatchupWithLeader:Begin2"},
-      {"VersionEditHandlerPointInTime::MaybeCreateVersionBeforeApplyEdit:"
-       "Begin1",
-       "DBImpl::BackgroundCompaction:BeforeCompaction"},
-      {"DBImpl::BackgroundCallCompaction:PurgedObsoleteFiles",
-       "VersionEditHandlerPointInTime::MaybeCreateVersionBeforeApplyEdit:"
-       "Begin2"},
-      {"DBImplFollower::TryCatchupWithLeader:End", "Follower::WaitForCatchup"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  TEST_SYNC_POINT("Leader::Start");
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v3"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v4"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr, true));
-
-  TEST_SYNC_POINT("Follower::WaitForCatchup");
-  ASSERT_EQ(FollowerGet("k1"), "v4");
-  CheckDirs();
-
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// This test validates the same as the previous test, except there is a
-// MANIFEST rollover between the flushes and compaction. The follower
-// does not switch to a new MANIFEST in ReadAndApply. So it would require
-// another round of refresh before catching up.
-TEST_F(DBFollowerTest, RetryCatchupManifestRollover) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  Reopen(opts);
-
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v3"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(OpenAsFollower());
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:Begin1", "Leader::Start"},
-      {"Leader::Flushed", "DBImplFollower::TryCatchupWithLeader:Begin2"},
-      {"VersionEditHandlerPointInTime::MaybeCreateVersionBeforeApplyEdit:"
-       "Begin1",
-       "Leader::Done"},
-      {"DBImpl::BackgroundCallCompaction:PurgedObsoleteFiles",
-       "VersionEditHandlerPointInTime::MaybeCreateVersionBeforeApplyEdit:"
-       "Begin2"},
-      {"DBImplFollower::TryCatchupWithLeader:End",
-       "Follower::WaitForCatchup:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  TEST_SYNC_POINT("Leader::Start");
-  ASSERT_OK(Put("k1", "v4"));
-  ASSERT_OK(Flush());
-
-  TEST_SYNC_POINT("Leader::Flushed");
-  TEST_SYNC_POINT("Leader::Done");
-  Reopen(opts);
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr, true));
-
-  TEST_SYNC_POINT("Follower::WaitForCatchup:1");
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:End",
-       "Follower::WaitForCatchup:2"},
-  });
-  TEST_SYNC_POINT("Follower::WaitForCatchup:2");
-  ASSERT_EQ(FollowerGet("k1"), "v4");
-
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// This test creates 4 L0 files and compacts them. The follower, during catchup,
-// successfully instantiates 4 Versions corresponding to the 4 files (but
-// donesn't install them yet), followed by deleting those 4 and adding a new
-// file from compaction. The test verifies that the 4 L0 files are deleted
-// correctly by the follower.
-// We use teh Barrier* functions to ensure that the follower first sees the 4
-// L0 files and is able to link them, and then sees the compaction that
-// obsoletes those L0 files (so those L0 files are intermediates that it has
-// to explicitly delete). Suppose we don't have any barriers, its possible
-// the follower reads the L0 records and compaction records from the MANIFEST
-// in one read, which means those L0 files would have already been deleted
-// by the leader and the follower cannot link to them.
-TEST_F(DBFollowerTest, IntermediateObsoleteFiles) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  Reopen(opts);
-  ASSERT_OK(OpenAsFollower());
-
-  follower_fs()->BarrierInit(2);
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v3"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k1", "v4"));
-  ASSERT_OK(Flush());
-  follower_fs()->BarrierWaitAndReinit(2);
-
-  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, nullptr, true));
-  follower_fs()->BarrierWait();
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:End",
-       "Follower::WaitForCatchup:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  TEST_SYNC_POINT("Follower::WaitForCatchup:1");
-  CheckDirs();
-  ASSERT_EQ(FollowerGet("k1"), "v4");
-}
-
-// This test verifies a scenario where the follower can recover a Version
-// partially (i.e some of the additions cannot be found), and the files
-// that are found are obsoleted by a subsequent VersionEdit.
-TEST_F(DBFollowerTest, PartialVersionRecovery) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  opts.sst_partitioner_factory =
-      std::make_shared<DBFollowerTestSstPartitionerFactory>(1);
-  Reopen(opts);
-
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Put("k2", "v1"));
-  ASSERT_OK(Put("k3", "v1"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(2);
-
-  ASSERT_OK(Put("k1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k3", "v2"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-
-  ASSERT_OK(OpenAsFollower());
-  ASSERT_OK(dbfull()->SetOptions(dbfull()->DefaultColumnFamily(),
-                                 {{"max_compaction_bytes", "1"}}));
-
-  follower_fs()->BarrierInit(2);
-  Slice key("k1");
-  ASSERT_OK(dbfull()->TEST_CompactRange(1, &key, &key, nullptr, true));
-
-  follower_fs()->BarrierWaitAndReinit(2);
-
-  // The second compaction input overlaps the previous compaction outputs
-  // by one file. This file is never added to  VersionStorageInfo since it
-  // was added and deleted before the catch up completes. We later verify that
-  // the follower correctly deleted this file.
-  key = Slice("k3");
-  ASSERT_OK(dbfull()->TEST_CompactRange(1, &key, &key, nullptr, true));
-  follower_fs()->BarrierWait();
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:End",
-       "Follower::WaitForCatchup:1"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  TEST_SYNC_POINT("Follower::WaitForCatchup:1");
-  CheckDirs();
-  ASSERT_EQ(FollowerGet("k1"), "v2");
-  ASSERT_EQ(FollowerGet("k2"), "v1");
-  ASSERT_EQ(FollowerGet("k3"), "v2");
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// This test verifies a scenario similar to the PartialVersionRecovery, except
-// with a MANIFEST rollover in between. When there is a rollover, the
-// follower's attempt ends without installing a new Version. The next catch up
-// attempt will recover a full Version.
-TEST_F(DBFollowerTest, PartialVersionRecoveryWithRollover) {
-  Options opts = CurrentOptions();
-  opts.disable_auto_compactions = true;
-  opts.sst_partitioner_factory =
-      std::make_shared<DBFollowerTestSstPartitionerFactory>(1);
-  Reopen(opts);
-
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Put("k2", "v1"));
-  ASSERT_OK(Put("k3", "v1"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(2);
-
-  ASSERT_OK(Put("k1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("k3", "v2"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-
-  opts.max_compaction_bytes = 1;
-  Reopen(opts);
-
-  ASSERT_OK(OpenAsFollower());
-
-  follower_fs()->BarrierInit(2);
-  Slice key("k1");
-  ASSERT_OK(dbfull()->TEST_CompactRange(1, &key, &key, nullptr, true));
-
-  follower_fs()->BarrierWaitAndReinit(2);
-  Reopen(opts);
-  key = Slice("k3");
-  ASSERT_OK(dbfull()->TEST_CompactRange(1, &key, &key, nullptr, true));
-  follower_fs()->BarrierWait();
-
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:Begin1",
-       "Follower::WaitForCatchup:1"},
-      {"Follower::WaitForCatchup:2",
-       "DBImplFollower::TryCatchupWithLeader:Begin2"},
-  });
-  SyncPoint::GetInstance()->EnableProcessing();
-  TEST_SYNC_POINT("Follower::WaitForCatchup:1");
-  TEST_SYNC_POINT("Follower::WaitForCatchup:2");
-  SyncPoint::GetInstance()->LoadDependency({
-      {"DBImplFollower::TryCatchupWithLeader:End",
-       "Follower::WaitForCatchup:3"},
-  });
-  TEST_SYNC_POINT("Follower::WaitForCatchup:3");
-  CheckDirs();
-  ASSERT_EQ(FollowerGet("k1"), "v2");
-  ASSERT_EQ(FollowerGet("k2"), "v1");
-  ASSERT_EQ(FollowerGet("k3"), "v2");
-  SyncPoint::GetInstance()->DisableProcessing();
-}
 #endif
 }  // namespace ROCKSDB_NAMESPACE
 

db/db_impl/db_impl.cc

@@ -17,7 +17,6 @@
 #include <cstdio>
 #include <map>
 #include <memory>
-#include <optional>
 #include <set>
 #include <sstream>
 #include <stdexcept>
@@ -392,8 +391,8 @@ Status DBImpl::ResumeImpl(DBRecoverContext context) {
       if (!s.ok()) {
         io_s = versions_->io_status();
         if (!io_s.ok()) {
-          error_handler_.SetBGError(io_s,
-                                    BackgroundErrorReason::kManifestWrite);
+          s = error_handler_.SetBGError(io_s,
+                                        BackgroundErrorReason::kManifestWrite);
         }
       }
     }
@@ -473,7 +472,7 @@ Status DBImpl::ResumeImpl(DBRecoverContext context) {
 
   if (s.ok()) {
     for (auto cfd : *versions_->GetColumnFamilySet()) {
-      EnqueuePendingCompaction(cfd);
+      SchedulePendingCompaction(cfd);
     }
     MaybeScheduleFlushOrCompaction();
   }
@@ -530,11 +529,6 @@ Status DBImpl::MaybeReleaseTimestampedSnapshotsAndCheck() {
   return Status::OK();
 }
 
-void DBImpl::UntrackDataFiles() {
-  TrackOrUntrackFiles(/*existing_data_files=*/{},
-                      /*track=*/false);
-}
-
 Status DBImpl::CloseHelper() {
   // Guarantee that there is no background error recovery in progress before
   // continuing with the shutdown
@@ -643,7 +637,7 @@ Status DBImpl::CloseHelper() {
       if (!s.ok()) {
         ROCKS_LOG_WARN(
             immutable_db_options_.info_log,
-            "Unable to clear writer for WAL %s with error -- %s",
+            "Unable to Sync WAL file %s with error -- %s",
             LogFileName(immutable_db_options_.GetWalDir(), log_number).c_str(),
             s.ToString().c_str());
         // Retain the first error
@@ -659,9 +653,8 @@ Status DBImpl::CloseHelper() {
   // We need to release them before the block cache is destroyed. The block
   // cache may be destroyed inside versions_.reset(), when column family data
   // list is destroyed, so leaving handles in table cache after
-  // versions_.reset() may cause issues. Here we clean all unreferenced handles
-  // in table cache, and (for certain builds/conditions) assert that no obsolete
-  // files are hanging around unreferenced (leak) in the table/blob file cache.
+  // versions_.reset() may cause issues.
+  // Here we clean all unreferenced handles in table cache.
   // Now we assume all user queries have finished, so only version set itself
   // can possibly hold the blocks from block cache. After releasing unreferenced
   // handles here, only handles held by version set left and inside
@@ -669,22 +662,12 @@ Status DBImpl::CloseHelper() {
   // time a handle is released, we erase it from the cache too. By doing that,
   // we can guarantee that after versions_.reset(), table cache is empty
   // so the cache can be safely destroyed.
-#ifndef NDEBUG
-  TEST_VerifyNoObsoleteFilesCached(/*db_mutex_already_held=*/true);
-#endif  // !NDEBUG
   table_cache_->EraseUnRefEntries();
 
   for (auto& txn_entry : recovered_transactions_) {
     delete txn_entry.second;
   }
 
-  // Return an unowned SstFileManager to a consistent state
-  if (immutable_db_options_.sst_file_manager && !own_sfm_) {
-    mutex_.Unlock();
-    UntrackDataFiles();
-    mutex_.Lock();
-  }
-
   // versions need to be destroyed before table_cache since it can hold
   // references to table_cache.
   {
@@ -933,8 +916,8 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,
             read_options, write_options, &edit, &mutex_,
             directories_.GetDbDir());
         if (!s.ok() && versions_->io_status().IsIOError()) {
-          error_handler_.SetBGError(versions_->io_status(),
-                                    BackgroundErrorReason::kManifestWrite);
+          s = error_handler_.SetBGError(versions_->io_status(),
+                                        BackgroundErrorReason::kManifestWrite);
         }
       }
 
@@ -1542,7 +1525,7 @@ Status DBImpl::FlushWAL(const WriteOptions& write_options, bool sync) {
                       io_s.ToString().c_str());
       // In case there is a fs error we should set it globally to prevent the
       // future writes
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
       // whether sync or not, we should abort the rest of function upon error
       return static_cast<Status>(io_s);
     }
@@ -1566,132 +1549,64 @@ bool DBImpl::WALBufferIsEmpty() {
   return res;
 }
 
-Status DBImpl::GetOpenWalSizes(std::map<uint64_t, uint64_t>& number_to_size) {
-  assert(number_to_size.empty());
-  InstrumentedMutexLock l(&log_write_mutex_);
-  for (auto& log : logs_) {
-    auto* open_file = log.writer->file();
-    if (open_file) {
-      number_to_size[log.number] = open_file->GetFlushedSize();
-    }
-  }
-  return Status::OK();
-}
-
 Status DBImpl::SyncWAL() {
   TEST_SYNC_POINT("DBImpl::SyncWAL:Begin");
-  WriteOptions write_options;
-  VersionEdit synced_wals;
-  Status s = SyncWalImpl(/*include_current_wal=*/true, write_options,
-                         /*job_context=*/nullptr, &synced_wals,
-                         /*error_recovery_in_prog=*/false);
-
-  if (s.ok() && synced_wals.IsWalAddition()) {
-    InstrumentedMutexLock l(&mutex_);
-    // TODO: plumb Env::IOActivity, Env::IOPriority
-    const ReadOptions read_options;
-    s = ApplyWALToManifest(read_options, write_options, &synced_wals);
-  }
-
-  TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:2");
-  return s;
-}
-
-IOStatus DBImpl::SyncWalImpl(bool include_current_wal,
-                             const WriteOptions& write_options,
-                             JobContext* job_context, VersionEdit* synced_wals,
-                             bool error_recovery_in_prog) {
-  autovector<log::Writer*, 1> wals_to_sync;
-  bool need_wal_dir_sync;
-  // Number of a WAL that was active at the start of call and maybe is by
-  // the end of the call.
-  uint64_t maybe_active_number;
-  // Sync WALs up to this number
-  uint64_t up_to_number;
+  autovector<log::Writer*, 1> logs_to_sync;
+  bool need_log_dir_sync;
+  uint64_t current_log_number;
 
   {
     InstrumentedMutexLock l(&log_write_mutex_);
     assert(!logs_.empty());
 
-    maybe_active_number = logfile_number_;
-    up_to_number =
-        include_current_wal ? maybe_active_number : maybe_active_number - 1;
+    // This SyncWAL() call only cares about logs up to this number.
+    current_log_number = logfile_number_;
 
-    while (logs_.front().number <= up_to_number && logs_.front().IsSyncing()) {
+    while (logs_.front().number <= current_log_number &&
+           logs_.front().IsSyncing()) {
       log_sync_cv_.Wait();
     }
     // First check that logs are safe to sync in background.
-    if (include_current_wal &&
-        !logs_.back().writer->file()->writable_file()->IsSyncThreadSafe()) {
-      return IOStatus::NotSupported(
-          "SyncWAL() is not supported for this implementation of WAL file",
-          immutable_db_options_.allow_mmap_writes
-              ? "try setting Options::allow_mmap_writes to false"
-              : Slice());
+    for (auto it = logs_.begin();
+         it != logs_.end() && it->number <= current_log_number; ++it) {
+      if (!it->writer->file()->writable_file()->IsSyncThreadSafe()) {
+        return Status::NotSupported(
+            "SyncWAL() is not supported for this implementation of WAL file",
+            immutable_db_options_.allow_mmap_writes
+                ? "try setting Options::allow_mmap_writes to false"
+                : Slice());
+      }
     }
     for (auto it = logs_.begin();
-         it != logs_.end() && it->number <= up_to_number; ++it) {
+         it != logs_.end() && it->number <= current_log_number; ++it) {
       auto& log = *it;
-      // Ensure the head of logs_ is marked as getting_synced if any is.
       log.PrepareForSync();
-      // If last sync failed on a later WAL, this could be a fully synced
-      // and closed WAL that just needs to be recorded as synced in the
-      // manifest.
-      if (log.writer->file()) {
-        wals_to_sync.push_back(log.writer);
-      }
+      logs_to_sync.push_back(log.writer);
     }
 
-    need_wal_dir_sync = !log_dir_synced_;
+    need_log_dir_sync = !log_dir_synced_;
   }
 
-  if (include_current_wal) {
-    TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:1");
-  }
+  TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:1");
   RecordTick(stats_, WAL_FILE_SYNCED);
+  Status status;
+  IOStatus io_s;
+  // TODO: plumb Env::IOActivity, Env::IOPriority
+  const ReadOptions read_options;
+  const WriteOptions write_options;
   IOOptions opts;
-  IOStatus io_s = WritableFileWriter::PrepareIOOptions(write_options, opts);
-  std::list<log::Writer*> wals_internally_closed;
+  io_s = WritableFileWriter::PrepareIOOptions(write_options, opts);
+  if (!io_s.ok()) {
+    status = io_s;
+  }
   if (io_s.ok()) {
-    for (log::Writer* log : wals_to_sync) {
-      if (job_context) {
-        ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                       "[JOB %d] Syncing log #%" PRIu64, job_context->job_id,
-                       log->get_log_number());
-      }
-      if (error_recovery_in_prog) {
-        log->file()->reset_seen_error();
-      }
-      if (log->get_log_number() >= maybe_active_number) {
-        assert(log->get_log_number() == maybe_active_number);
-        io_s = log->file()->SyncWithoutFlush(opts,
-                                             immutable_db_options_.use_fsync);
-      } else {
-        io_s = log->file()->Sync(opts, immutable_db_options_.use_fsync);
-      }
+    for (log::Writer* log : logs_to_sync) {
+      io_s =
+          log->file()->SyncWithoutFlush(opts, immutable_db_options_.use_fsync);
       if (!io_s.ok()) {
+        status = io_s;
         break;
       }
-      // WALs can be closed when purging obsolete files, but if recycling is
-      // enabled, the log file is closed here so that it can be reused. And
-      // immediate closure here upon final sync makes it easier to guarantee
-      // that Checkpoint doesn't LinkFile on a WAL still open for write, which
-      // might be unsupported for some FileSystem implementations. Close here
-      // should be inexpensive because flush and sync are done, so the kill
-      // switch background_close_inactive_wals is expected to be removed in
-      // the future.
-      if (log->get_log_number() < maybe_active_number &&
-          (immutable_db_options_.recycle_log_file_num > 0 ||
-           !immutable_db_options_.background_close_inactive_wals)) {
-        if (error_recovery_in_prog) {
-          log->file()->reset_seen_error();
-        }
-        io_s = log->file()->Close(opts);
-        wals_internally_closed.push_back(log);
-        if (!io_s.ok()) {
-          break;
-        }
-      }
     }
   }
   if (!io_s.ok()) {
@@ -1699,36 +1614,33 @@ IOStatus DBImpl::SyncWalImpl(bool include_current_wal,
                     io_s.ToString().c_str());
     // In case there is a fs error we should set it globally to prevent the
     // future writes
-    WALIOStatusCheck(io_s);
+    IOStatusCheck(io_s);
   }
-  if (io_s.ok() && need_wal_dir_sync) {
-    io_s = directories_.GetWalDir()->FsyncWithDirOptions(
+  if (status.ok() && need_log_dir_sync) {
+    status = directories_.GetWalDir()->FsyncWithDirOptions(
         IOOptions(), nullptr,
         DirFsyncOptions(DirFsyncOptions::FsyncReason::kNewFileSynced));
   }
-  if (include_current_wal) {
-    TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:2");
+  TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:2");
 
-    TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:1");
-  } else {
-    TEST_SYNC_POINT_CALLBACK("DBImpl::SyncClosedWals:BeforeReLock",
-                             /*arg=*/nullptr);
-  }
+  TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:1");
+  VersionEdit synced_wals;
   {
     InstrumentedMutexLock l(&log_write_mutex_);
-    for (auto* wal : wals_internally_closed) {
-      // We can only modify the state of log::Writer under the mutex
-      bool was_closed = wal->PublishIfClosed();
-      assert(was_closed);
-      (void)was_closed;
-    }
-    if (io_s.ok()) {
-      MarkLogsSynced(up_to_number, need_wal_dir_sync, synced_wals);
+    if (status.ok()) {
+      MarkLogsSynced(current_log_number, need_log_dir_sync, &synced_wals);
     } else {
-      MarkLogsNotSynced(up_to_number);
+      MarkLogsNotSynced(current_log_number);
     }
   }
-  return io_s;
+  if (status.ok() && synced_wals.IsWalAddition()) {
+    InstrumentedMutexLock l(&mutex_);
+    status = ApplyWALToManifest(read_options, write_options, &synced_wals);
+  }
+
+  TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:2");
+
+  return status;
 }
 
 Status DBImpl::ApplyWALToManifest(const ReadOptions& read_options,
@@ -1741,8 +1653,8 @@ Status DBImpl::ApplyWALToManifest(const ReadOptions& read_options,
       read_options, write_options, synced_wals, &mutex_,
       directories_.GetDbDir());
   if (!status.ok() && versions_->io_status().IsIOError()) {
-    error_handler_.SetBGError(versions_->io_status(),
-                              BackgroundErrorReason::kManifestWrite);
+    status = error_handler_.SetBGError(versions_->io_status(),
+                                       BackgroundErrorReason::kManifestWrite);
   }
   return status;
 }
@@ -1846,19 +1758,16 @@ void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
           wal.GetPreSyncSize() > 0) {
         synced_wals->AddWal(wal.number, WalMetadata(wal.GetPreSyncSize()));
       }
-      // Reclaim closed WALs (wal.writer->file() == nullptr), and if we don't
-      // need to close before that (background_close_inactive_wals) we can
-      // opportunistically reclaim WALs that happen to be fully synced.
-      // (Probably not worth extra code and mutex release to opportunistically
-      // close WALs that became eligible since last holding the mutex.
-      // FindObsoleteFiles can take care of it.)
+      // Check if the file has been closed, i.e wal.writer->file() == nullptr
+      // which can happen if log recycling is enabled, or if all the data in
+      // the log has been synced
       if (wal.writer->file() == nullptr ||
-          (immutable_db_options_.background_close_inactive_wals &&
-           wal.GetPreSyncSize() == wal.writer->file()->GetFlushedSize())) {
+          wal.GetPreSyncSize() == wal.writer->file()->GetFlushedSize()) {
         // Fully synced
         logs_to_free_.push_back(wal.ReleaseWriter());
         it = logs_.erase(it);
       } else {
+        assert(wal.GetPreSyncSize() < wal.writer->file()->GetFlushedSize());
         wal.FinishSync();
         ++it;
       }
@@ -2070,34 +1979,30 @@ InternalIterator* DBImpl::NewInternalIterator(
     bool allow_unprepared_value, ArenaWrappedDBIter* db_iter) {
   InternalIterator* internal_iter;
   assert(arena != nullptr);
-  auto prefix_extractor =
-      super_version->mutable_cf_options.prefix_extractor.get();
   // Need to create internal iterator from the arena.
   MergeIteratorBuilder merge_iter_builder(
       &cfd->internal_comparator(), arena,
-      // FIXME? It's not clear what interpretation of prefix seek is needed
-      // here, and no unit test cares about the value provided here.
-      !read_options.total_order_seek && prefix_extractor != nullptr,
+      !read_options.total_order_seek &&
+          super_version->mutable_cf_options.prefix_extractor != nullptr,
       read_options.iterate_upper_bound);
   // Collect iterator for mutable memtable
   auto mem_iter = super_version->mem->NewIterator(
-      read_options, super_version->GetSeqnoToTimeMapping(), arena,
-      super_version->mutable_cf_options.prefix_extractor.get());
+      read_options, super_version->GetSeqnoToTimeMapping(), arena);
   Status s;
   if (!read_options.ignore_range_deletions) {
-    std::unique_ptr<TruncatedRangeDelIterator> mem_tombstone_iter;
+    TruncatedRangeDelIterator* mem_tombstone_iter = nullptr;
     auto range_del_iter = super_version->mem->NewRangeTombstoneIterator(
         read_options, sequence, false /* immutable_memtable */);
     if (range_del_iter == nullptr || range_del_iter->empty()) {
       delete range_del_iter;
     } else {
-      mem_tombstone_iter = std::make_unique<TruncatedRangeDelIterator>(
+      mem_tombstone_iter = new TruncatedRangeDelIterator(
           std::unique_ptr<FragmentedRangeTombstoneIterator>(range_del_iter),
           &cfd->ioptions()->internal_comparator, nullptr /* smallest */,
           nullptr /* largest */);
     }
-    merge_iter_builder.AddPointAndTombstoneIterator(
-        mem_iter, std::move(mem_tombstone_iter));
+    merge_iter_builder.AddPointAndTombstoneIterator(mem_iter,
+                                                    mem_tombstone_iter);
   } else {
     merge_iter_builder.AddIterator(mem_iter);
   }
@@ -2106,7 +2011,6 @@ InternalIterator* DBImpl::NewInternalIterator(
   if (s.ok()) {
     super_version->imm->AddIterators(
         read_options, super_version->GetSeqnoToTimeMapping(),
-        super_version->mutable_cf_options.prefix_extractor.get(),
         &merge_iter_builder, !read_options.ignore_range_deletions);
   }
   TEST_SYNC_POINT_CALLBACK("DBImpl::NewInternalIterator:StatusCallback", &s);
@@ -2195,7 +2099,7 @@ Status DBImpl::GetEntity(const ReadOptions& _read_options,
   if (_read_options.io_activity != Env::IOActivity::kUnknown &&
       _read_options.io_activity != Env::IOActivity::kGetEntity) {
     return Status::InvalidArgument(
-        "Can only call GetEntity with `ReadOptions::io_activity` set to "
+        "Cannot call GetEntity with `ReadOptions::io_activity` != "
         "`Env::IOActivity::kUnknown` or `Env::IOActivity::kGetEntity`");
   }
   ReadOptions read_options(_read_options);
@@ -2222,7 +2126,7 @@ Status DBImpl::GetEntity(const ReadOptions& _read_options, const Slice& key,
   if (_read_options.io_activity != Env::IOActivity::kUnknown &&
       _read_options.io_activity != Env::IOActivity::kGetEntity) {
     s = Status::InvalidArgument(
-        "Can only call GetEntity with `ReadOptions::io_activity` set to "
+        "Cannot call GetEntity with `ReadOptions::io_activity` != "
         "`Env::IOActivity::kUnknown` or `Env::IOActivity::kGetEntity`");
     for (size_t i = 0; i < num_column_families; ++i) {
       (*result)[i].SetStatus(s);
@@ -2497,8 +2401,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
         RecordTick(stats_, MEMTABLE_HIT);
       }
     }
-    if (!s.ok() && !s.IsMergeInProgress() && !s.IsNotFound()) {
-      assert(done);
+    if (!done && !s.ok() && !s.IsMergeInProgress()) {
       ReturnAndCleanupSuperVersion(cfd, sv);
       return s;
     }
@@ -3164,11 +3067,10 @@ Status DBImpl::MultiGetImpl(
   StopWatch sw(immutable_db_options_.clock, stats_, DB_MULTIGET);
 
   assert(sorted_keys);
-  assert(start_key + num_keys <= sorted_keys->size());
   // Clear the timestamps for returning results so that we can distinguish
   // between tombstone or key that has never been written
-  for (size_t i = start_key; i < start_key + num_keys; ++i) {
-    KeyContext* kctx = (*sorted_keys)[i];
+  for (auto* kctx : *sorted_keys) {
+    assert(kctx);
     if (kctx->timestamp) {
       kctx->timestamp->clear();
     }
@@ -3231,8 +3133,6 @@ Status DBImpl::MultiGetImpl(
       s = Status::Aborted();
       break;
     }
-    // This could be a long-running operation
-    ROCKSDB_THREAD_YIELD_HOOK();
   }
 
   // Post processing (decrement reference counts and record statistics)
@@ -3285,55 +3185,22 @@ void DBImpl::MultiGetEntity(const ReadOptions& _read_options, size_t num_keys,
                             ColumnFamilyHandle** column_families,
                             const Slice* keys, PinnableWideColumns* results,
                             Status* statuses, bool sorted_input) {
-  assert(statuses);
-
-  if (!column_families) {
-    const Status s = Status::InvalidArgument(
-        "Cannot call MultiGetEntity without column families");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
-  if (!keys) {
-    const Status s =
-        Status::InvalidArgument("Cannot call MultiGetEntity without keys");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
-  if (!results) {
-    const Status s = Status::InvalidArgument(
-        "Cannot call MultiGetEntity without PinnableWideColumns objects");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
   if (_read_options.io_activity != Env::IOActivity::kUnknown &&
       _read_options.io_activity != Env::IOActivity::kMultiGetEntity) {
-    const Status s = Status::InvalidArgument(
-        "Can only call MultiGetEntity with `ReadOptions::io_activity` set to "
+    Status s = Status::InvalidArgument(
+        "Can only call MultiGetEntity with `ReadOptions::io_activity` is "
         "`Env::IOActivity::kUnknown` or `Env::IOActivity::kMultiGetEntity`");
     for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
+      if (statuses[i].ok()) {
+        statuses[i] = s;
+      }
     }
-
     return;
   }
-
   ReadOptions read_options(_read_options);
   if (read_options.io_activity == Env::IOActivity::kUnknown) {
     read_options.io_activity = Env::IOActivity::kMultiGetEntity;
   }
-
   MultiGetCommon(read_options, num_keys, column_families, keys,
                  /* values */ nullptr, results, /* timestamps */ nullptr,
                  statuses, sorted_input);
@@ -3343,54 +3210,22 @@ void DBImpl::MultiGetEntity(const ReadOptions& _read_options,
                             ColumnFamilyHandle* column_family, size_t num_keys,
                             const Slice* keys, PinnableWideColumns* results,
                             Status* statuses, bool sorted_input) {
-  assert(statuses);
-
-  if (!column_family) {
-    const Status s = Status::InvalidArgument(
-        "Cannot call MultiGetEntity without a column family handle");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
-  if (!keys) {
-    const Status s =
-        Status::InvalidArgument("Cannot call MultiGetEntity without keys");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
-  if (!results) {
-    const Status s = Status::InvalidArgument(
-        "Cannot call MultiGetEntity without PinnableWideColumns objects");
-    for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
-    }
-
-    return;
-  }
-
   if (_read_options.io_activity != Env::IOActivity::kUnknown &&
       _read_options.io_activity != Env::IOActivity::kMultiGetEntity) {
-    const Status s = Status::InvalidArgument(
-        "Can only call MultiGetEntity with `ReadOptions::io_activity` set to "
+    Status s = Status::InvalidArgument(
+        "Can only call MultiGetEntity with `ReadOptions::io_activity` is "
         "`Env::IOActivity::kUnknown` or `Env::IOActivity::kMultiGetEntity`");
     for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = s;
+      if (statuses[i].ok()) {
+        statuses[i] = s;
+      }
     }
     return;
   }
-
   ReadOptions read_options(_read_options);
   if (read_options.io_activity == Env::IOActivity::kUnknown) {
     read_options.io_activity = Env::IOActivity::kMultiGetEntity;
   }
-
   MultiGetCommon(read_options, column_family, num_keys, keys,
                  /* values */ nullptr, results, /* timestamps */ nullptr,
                  statuses, sorted_input);
@@ -3399,34 +3234,18 @@ void DBImpl::MultiGetEntity(const ReadOptions& _read_options,
 void DBImpl::MultiGetEntity(const ReadOptions& _read_options, size_t num_keys,
                             const Slice* keys,
                             PinnableAttributeGroups* results) {
-  assert(results);
-
-  if (!keys) {
-    const Status s =
-        Status::InvalidArgument("Cannot call MultiGetEntity without keys");
-    for (size_t i = 0; i < num_keys; ++i) {
-      for (size_t j = 0; j < results[i].size(); ++j) {
-        results[i][j].SetStatus(s);
-      }
-    }
-
-    return;
-  }
-
   if (_read_options.io_activity != Env::IOActivity::kUnknown &&
       _read_options.io_activity != Env::IOActivity::kMultiGetEntity) {
-    const Status s = Status::InvalidArgument(
-        "Can only call MultiGetEntity with `ReadOptions::io_activity` set to "
+    Status s = Status::InvalidArgument(
+        "Can only call MultiGetEntity with ReadOptions::io_activity` is "
         "`Env::IOActivity::kUnknown` or `Env::IOActivity::kMultiGetEntity`");
     for (size_t i = 0; i < num_keys; ++i) {
       for (size_t j = 0; j < results[i].size(); ++j) {
         results[i][j].SetStatus(s);
       }
     }
-
     return;
   }
-
   ReadOptions read_options(_read_options);
   if (read_options.io_activity == Env::IOActivity::kUnknown) {
     read_options.io_activity = Env::IOActivity::kMultiGetEntity;
@@ -3444,7 +3263,6 @@ void DBImpl::MultiGetEntity(const ReadOptions& _read_options, size_t num_keys,
       ++total_count;
     }
   }
-
   std::vector<Status> statuses(total_count);
   std::vector<PinnableWideColumns> columns(total_count);
   MultiGetCommon(read_options, total_count, column_families.data(),
@@ -3465,15 +3283,6 @@ void DBImpl::MultiGetEntity(const ReadOptions& _read_options, size_t num_keys,
   }
 }
 
-void DBImpl::MultiGetEntityWithCallback(
-    const ReadOptions& read_options, ColumnFamilyHandle* column_family,
-    ReadCallback* callback,
-    autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE>* sorted_keys) {
-  assert(read_options.io_activity == Env::IOActivity::kMultiGetEntity);
-
-  MultiGetWithCallbackImpl(read_options, column_family, callback, sorted_keys);
-}
-
 Status DBImpl::WrapUpCreateColumnFamilies(
     const ReadOptions& read_options, const WriteOptions& write_options,
     const std::vector<const ColumnFamilyOptions*>& cf_options) {
@@ -3854,9 +3663,6 @@ Iterator* DBImpl::NewIterator(const ReadOptions& _read_options,
     }
   }
   if (read_options.tailing) {
-    read_options.total_order_seek |=
-        immutable_db_options_.prefix_seek_opt_in_only;
-
     auto iter = new ForwardIterator(this, read_options, cfd, sv,
                                     /* allow_unprepared_value */ true);
     result = NewDBIterator(
@@ -4058,9 +3864,6 @@ Status DBImpl::NewIterators(
 
   assert(cf_sv_pairs.size() == column_families.size());
   if (read_options.tailing) {
-    read_options.total_order_seek |=
-        immutable_db_options_.prefix_seek_opt_in_only;
-
     for (const auto& cf_sv_pair : cf_sv_pairs) {
       auto iter = new ForwardIterator(this, read_options, cf_sv_pair.cfd,
                                       cf_sv_pair.super_version,
@@ -4311,7 +4114,7 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
                    ->storage_info()
                    ->BottommostFilesMarkedForCompaction()
                    .empty()) {
-            EnqueuePendingCompaction(cfd);
+            SchedulePendingCompaction(cfd);
             MaybeScheduleFlushOrCompaction();
             cf_scheduled.push_back(cfd);
           }
@@ -4575,11 +4378,8 @@ bool DBImpl::GetAggregatedIntProperty(const Slice& property,
   if (property_info == nullptr || property_info->handle_int == nullptr) {
     return false;
   }
-  auto aggregator = CreateIntPropertyAggregator(property);
-  if (aggregator == nullptr) {
-    return false;
-  }
 
+  uint64_t sum = 0;
   bool ret = true;
   {
     // Needs mutex to protect the list of column families.
@@ -4593,14 +4393,14 @@ bool DBImpl::GetAggregatedIntProperty(const Slice& property,
       // GetIntPropertyInternal may release db mutex and re-acquire it.
       mutex_.AssertHeld();
       if (ret) {
-        aggregator->Add(cfd, value);
+        sum += value;
       } else {
         ret = false;
         break;
       }
     }
   }
-  *aggregated_value = aggregator->Aggregate();
+  *aggregated_value = sum;
   return ret;
 }
 
@@ -4785,24 +4585,6 @@ void DBImpl::ReleaseFileNumberFromPendingOutputs(
   }
 }
 
-std::list<uint64_t>::iterator DBImpl::CaptureOptionsFileNumber() {
-  // We need to remember the iterator of our insert, because after the
-  // compaction is done, we need to remove that element from
-  // min_options_file_numbers_.
-  min_options_file_numbers_.push_back(versions_->options_file_number());
-  auto min_options_file_numbers_inserted_elem = min_options_file_numbers_.end();
-  --min_options_file_numbers_inserted_elem;
-  return min_options_file_numbers_inserted_elem;
-}
-
-void DBImpl::ReleaseOptionsFileNumber(
-    std::unique_ptr<std::list<uint64_t>::iterator>& v) {
-  if (v.get() != nullptr) {
-    min_options_file_numbers_.erase(*v.get());
-    v.reset();
-  }
-}
-
 Status DBImpl::GetUpdatesSince(
     SequenceNumber seq, std::unique_ptr<TransactionLogIterator>* iter,
     const TransactionLogIterator::ReadOptions& read_options) {
@@ -5290,14 +5072,6 @@ Status DestroyDB(const std::string& dbname, const Options& options,
   Env* env = soptions.env;
   std::vector<std::string> filenames;
   bool wal_in_db_path = soptions.IsWalDirSameAsDBPath();
-  auto sfm = static_cast_with_check<SstFileManagerImpl>(
-      options.sst_file_manager.get());
-  // Allocate a separate trash bucket to be used by all the to be deleted
-  // files, so we can later wait for this bucket to be empty before return.
-  std::optional<int32_t> bucket;
-  if (sfm) {
-    bucket = sfm->NewTrashBucket();
-  }
 
   // Reset the logger because it holds a handle to the
   // log file and prevents cleanup and directory removal
@@ -5309,7 +5083,6 @@ Status DestroyDB(const std::string& dbname, const Options& options,
                     /*IODebugContext*=*/nullptr)
       .PermitUncheckedError();
 
-  std::set<std::string> paths_to_delete;
   FileLock* lock;
   const std::string lockname = LockFileName(dbname);
   Status result = env->LockFile(lockname, &lock);
@@ -5326,9 +5099,10 @@ Status DestroyDB(const std::string& dbname, const Options& options,
           del = DestroyDB(path_to_delete, options);
         } else if (type == kTableFile || type == kWalFile ||
                    type == kBlobFile) {
-          del = DeleteUnaccountedDBFile(&soptions, path_to_delete, dbname,
-                                        /*force_bg=*/false,
-                                        /*force_fg=*/false, bucket);
+          del = DeleteDBFile(
+              &soptions, path_to_delete, dbname,
+              /*force_bg=*/false,
+              /*force_fg=*/(type == kWalFile) ? !wal_in_db_path : false);
         } else {
           del = env->DeleteFile(path_to_delete);
         }
@@ -5337,7 +5111,6 @@ Status DestroyDB(const std::string& dbname, const Options& options,
         }
       }
     }
-    paths_to_delete.insert(dbname);
 
     std::set<std::string> paths;
     for (const DbPath& db_path : options.db_paths) {
@@ -5359,19 +5132,18 @@ Status DestroyDB(const std::string& dbname, const Options& options,
               (type == kTableFile ||
                type == kBlobFile)) {  // Lock file will be deleted at end
             std::string file_path = path + "/" + fname;
-            Status del = DeleteUnaccountedDBFile(&soptions, file_path, dbname,
-                                                 /*force_bg=*/false,
-                                                 /*force_fg=*/false, bucket);
+            Status del = DeleteDBFile(&soptions, file_path, dbname,
+                                      /*force_bg=*/false, /*force_fg=*/false);
             if (!del.ok() && result.ok()) {
               result = del;
             }
           }
         }
+        // TODO: Should we return an error if we cannot delete the directory?
+        env->DeleteDir(path).PermitUncheckedError();
       }
     }
 
-    paths_to_delete.merge(paths);
-
     std::vector<std::string> walDirFiles;
     std::string archivedir = ArchivalDirectory(dbname);
     bool wal_dir_exists = false;
@@ -5395,49 +5167,46 @@ Status DestroyDB(const std::string& dbname, const Options& options,
       // Delete archival files.
       for (const auto& file : archiveFiles) {
         if (ParseFileName(file, &number, &type) && type == kWalFile) {
-          Status del = DeleteUnaccountedDBFile(
-              &soptions, archivedir + "/" + file, archivedir,
-              /*force_bg=*/false, /*force_fg=*/!wal_in_db_path, bucket);
+          Status del =
+              DeleteDBFile(&soptions, archivedir + "/" + file, archivedir,
+                           /*force_bg=*/false, /*force_fg=*/!wal_in_db_path);
           if (!del.ok() && result.ok()) {
             result = del;
           }
         }
       }
-      paths_to_delete.insert(archivedir);
+      // Ignore error in case dir contains other files
+      env->DeleteDir(archivedir).PermitUncheckedError();
     }
 
     // Delete log files in the WAL dir
     if (wal_dir_exists) {
       for (const auto& file : walDirFiles) {
         if (ParseFileName(file, &number, &type) && type == kWalFile) {
-          Status del = DeleteUnaccountedDBFile(
-              &soptions, LogFileName(soptions.wal_dir, number),
-              soptions.wal_dir, /*force_bg=*/false,
-              /*force_fg=*/!wal_in_db_path, bucket);
+          Status del =
+              DeleteDBFile(&soptions, LogFileName(soptions.wal_dir, number),
+                           soptions.wal_dir, /*force_bg=*/false,
+                           /*force_fg=*/!wal_in_db_path);
           if (!del.ok() && result.ok()) {
             result = del;
           }
         }
       }
-      paths_to_delete.insert(soptions.wal_dir);
+      // Ignore error in case dir contains other files
+      env->DeleteDir(soptions.wal_dir).PermitUncheckedError();
     }
 
     // Ignore error since state is already gone
     env->UnlockFile(lock).PermitUncheckedError();
     env->DeleteFile(lockname).PermitUncheckedError();
 
-    // Make sure trash files are all cleared before return.
-    if (sfm && bucket.has_value()) {
-      sfm->WaitForEmptyTrashBucket(bucket.value());
-    }
     // sst_file_manager holds a ref to the logger. Make sure the logger is
     // gone before trying to remove the directory.
     soptions.sst_file_manager.reset();
 
     // Ignore error in case dir contains other files
-    for (const auto& path_to_delete : paths_to_delete) {
-      env->DeleteDir(path_to_delete).PermitUncheckedError();
-    }
+    env->DeleteDir(dbname).PermitUncheckedError();
+    ;
   }
   return result;
 }
@@ -5877,17 +5646,6 @@ Status DBImpl::IngestExternalFiles(
             "timestamps enabled doesn't support ingest behind.");
       }
     }
-    if (ingest_opts.allow_db_generated_files) {
-      if (ingest_opts.write_global_seqno) {
-        return Status::NotSupported(
-            "write_global_seqno is deprecated and does not work with "
-            "allow_db_generated_files.");
-      }
-    }
-    if (ingest_opts.move_files && ingest_opts.link_files) {
-      return Status::InvalidArgument(
-          "`move_files` and `link_files` can not both be true.");
-    }
   }
 
   // TODO (yanqin) maybe handle the case in which column_families have
@@ -6794,62 +6552,6 @@ void DBImpl::RecordSeqnoToTimeMapping(uint64_t populate_historical_seconds) {
   }
 }
 
-void DBImpl::TrackOrUntrackFiles(
-    const std::vector<std::string>& existing_data_files, bool track) {
-  auto sfm = static_cast_with_check<SstFileManagerImpl>(
-      immutable_db_options_.sst_file_manager.get());
-  assert(sfm);
-  std::vector<ColumnFamilyMetaData> metadata;
-  GetAllColumnFamilyMetaData(&metadata);
-  auto action = [&](const std::string& file_path,
-                    std::optional<uint64_t> size) {
-    if (track) {
-      if (size) {
-        sfm->OnAddFile(file_path, *size).PermitUncheckedError();
-      } else {
-        sfm->OnAddFile(file_path).PermitUncheckedError();
-      }
-    } else {
-      sfm->OnUntrackFile(file_path).PermitUncheckedError();
-    }
-  };
-
-  std::unordered_set<std::string> referenced_files;
-  for (const auto& md : metadata) {
-    for (const auto& lmd : md.levels) {
-      for (const auto& fmd : lmd.files) {
-        // We're assuming that each sst file name exists in at most one of
-        // the paths.
-        std::string file_path =
-            fmd.directory + kFilePathSeparator + fmd.relative_filename;
-        action(file_path, fmd.size);
-        referenced_files.insert(file_path);
-      }
-    }
-    for (const auto& bmd : md.blob_files) {
-      std::string name = bmd.blob_file_name;
-      // The BlobMetaData.blob_file_name may start with "/".
-      if (!name.empty() && name[0] == kFilePathSeparator) {
-        name = name.substr(1);
-      }
-      // We're assuming that each blob file name exists in at most one of
-      // the paths.
-      std::string file_path = bmd.blob_file_path + kFilePathSeparator + name;
-      action(file_path, bmd.blob_file_size);
-      referenced_files.insert(file_path);
-    }
-  }
-
-  for (const auto& file_path : existing_data_files) {
-    if (referenced_files.find(file_path) != referenced_files.end()) {
-      continue;
-    }
-    // There shouldn't be any duplicated files. In case there is, SstFileManager
-    // will take care of deduping it.
-    action(file_path, /*size=*/std::nullopt);
-  }
-}
-
 void DBImpl::InstallSeqnoToTimeMappingInSV(
     std::vector<SuperVersionContext>* sv_contexts) {
   mutex_.AssertHeld();

db/db_impl/db_impl.h

@@ -9,7 +9,6 @@
 #pragma once
 
 #include <atomic>
-#include <cstdint>
 #include <deque>
 #include <functional>
 #include <limits>
@@ -58,7 +57,6 @@
 #include "rocksdb/status.h"
 #include "rocksdb/trace_reader_writer.h"
 #include "rocksdb/transaction_log.h"
-#include "rocksdb/user_write_callback.h"
 #include "rocksdb/utilities/replayer.h"
 #include "rocksdb/write_buffer_manager.h"
 #include "table/merging_iterator.h"
@@ -233,10 +231,6 @@ class DBImpl : public DB {
   using DB::Write;
   Status Write(const WriteOptions& options, WriteBatch* updates) override;
 
-  using DB::WriteWithCallback;
-  Status WriteWithCallback(const WriteOptions& options, WriteBatch* updates,
-                           UserWriteCallback* user_write_cb) override;
-
   using DB::Get;
   Status Get(const ReadOptions& _read_options,
              ColumnFamilyHandle* column_family, const Slice& key,
@@ -297,11 +291,6 @@ class DBImpl : public DB {
                       const Slice* keys,
                       PinnableAttributeGroups* results) override;
 
-  void MultiGetEntityWithCallback(
-      const ReadOptions& read_options, ColumnFamilyHandle* column_family,
-      ReadCallback* callback,
-      autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE>* sorted_keys);
-
   Status CreateColumnFamily(const ColumnFamilyOptions& cf_options,
                             const std::string& column_family,
                             ColumnFamilyHandle** handle) override {
@@ -507,16 +496,8 @@ class DBImpl : public DB {
   // All the returned filenames start with "/"
   Status GetLiveFiles(std::vector<std::string>&, uint64_t* manifest_file_size,
                       bool flush_memtable = true) override;
-  Status GetSortedWalFiles(VectorWalPtr& files) override;
-  Status GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos);
-
-  // Get the known flushed sizes of WALs that might still be written to
-  // or have pending sync.
-  // NOTE: unlike alive_log_files_, this function includes WALs that might
-  // be obsolete (but not obsolete to a pending Checkpoint) and not yet fully
-  // synced.
-  Status GetOpenWalSizes(std::map<uint64_t, uint64_t>& number_to_size);
-  Status GetCurrentWalFile(std::unique_ptr<WalFile>* current_log_file) override;
+  Status GetSortedWalFiles(VectorLogPtr& files) override;
+  Status GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) override;
   Status GetCreationTimeOfOldestFile(uint64_t* creation_time) override;
 
   Status GetUpdatesSince(
@@ -702,8 +683,7 @@ class DBImpl : public DB {
   // thread to determine whether it is safe to perform the write.
   virtual Status WriteWithCallback(const WriteOptions& write_options,
                                    WriteBatch* my_batch,
-                                   WriteCallback* callback,
-                                   UserWriteCallback* user_write_cb = nullptr);
+                                   WriteCallback* callback);
 
   // Returns the sequence number that is guaranteed to be smaller than or equal
   // to the sequence number of any key that could be inserted into the current
@@ -853,8 +833,6 @@ class DBImpl : public DB {
 
   uint64_t GetObsoleteSstFilesSize();
 
-  uint64_t MinOptionsFileNumberToKeep();
-
   // Returns the list of live files in 'live' and the list
   // of all files in the filesystem in 'candidate_files'.
   // If force == false and the last call was less than
@@ -1153,8 +1131,6 @@ class DBImpl : public DB {
   // Get the background error status
   Status TEST_GetBGError();
 
-  bool TEST_IsRecoveryInProgress();
-
   // Return the maximum overlapping data (in bytes) at next level for any
   // file at a level >= 1.
   uint64_t TEST_MaxNextLevelOverlappingBytes(
@@ -1230,8 +1206,6 @@ class DBImpl : public DB {
     return logs_.back().number;
   }
 
-  void TEST_DeleteObsoleteFiles();
-
   const std::unordered_set<uint64_t>& TEST_GetFilesGrabbedForPurge() const {
     return files_grabbed_for_purge_;
   }
@@ -1241,13 +1215,8 @@ class DBImpl : public DB {
   static Status TEST_ValidateOptions(const DBOptions& db_options) {
     return ValidateOptions(db_options);
   }
-#endif  // NDEBUG
 
-  // In certain configurations, verify that the table/blob file cache only
-  // contains entries for live files, to check for effective leaks of open
-  // files. This can only be called when purging of obsolete files has
-  // "settled," such as during parts of DB Close().
-  void TEST_VerifyNoObsoleteFilesCached(bool db_mutex_already_held) const;
+#endif  // NDEBUG
 
   // persist stats to column family "_persistent_stats"
   void PersistStats();
@@ -1473,9 +1442,6 @@ class DBImpl : public DB {
   Status RenameTempFileToOptionsFile(const std::string& file_name);
   Status DeleteObsoleteOptionsFiles();
 
-  void NotifyOnManualFlushScheduled(autovector<ColumnFamilyData*> cfds,
-                                    FlushReason flush_reason);
-
   void NotifyOnFlushBegin(ColumnFamilyData* cfd, FileMetaData* file_meta,
                           const MutableCFOptions& mutable_cf_options,
                           int job_id, FlushReason flush_reason);
@@ -1526,7 +1492,6 @@ class DBImpl : public DB {
   // batch that does not have duplicate keys.
   Status WriteImpl(const WriteOptions& options, WriteBatch* updates,
                    WriteCallback* callback = nullptr,
-                   UserWriteCallback* user_write_cb = nullptr,
                    uint64_t* log_used = nullptr, uint64_t log_ref = 0,
                    bool disable_memtable = false, uint64_t* seq_used = nullptr,
                    size_t batch_cnt = 0,
@@ -1535,7 +1500,6 @@ class DBImpl : public DB {
 
   Status PipelinedWriteImpl(const WriteOptions& options, WriteBatch* updates,
                             WriteCallback* callback = nullptr,
-                            UserWriteCallback* user_write_cb = nullptr,
                             uint64_t* log_used = nullptr, uint64_t log_ref = 0,
                             bool disable_memtable = false,
                             uint64_t* seq_used = nullptr);
@@ -1562,8 +1526,7 @@ class DBImpl : public DB {
   // marks start of a new sub-batch.
   Status WriteImplWALOnly(
       WriteThread* write_thread, const WriteOptions& options,
-      WriteBatch* updates, WriteCallback* callback,
-      UserWriteCallback* user_write_cb, uint64_t* log_used,
+      WriteBatch* updates, WriteCallback* callback, uint64_t* log_used,
       const uint64_t log_ref, uint64_t* seq_used, const size_t sub_batch_cnt,
       PreReleaseCallback* pre_release_callback, const AssignOrder assign_order,
       const PublishLastSeq publish_last_seq, const bool disable_memtable);
@@ -1591,12 +1554,11 @@ class DBImpl : public DB {
 
   virtual bool OwnTablesAndLogs() const { return true; }
 
-  // Read/create DB identity file (as appropriate), and write DB ID to
-  // version_edit if provided.
+  // Setup DB identity file, and write DB ID to manifest if necessary.
   Status SetupDBId(const WriteOptions& write_options, bool read_only,
-                   bool is_new_db, VersionEdit* version_edit);
-  // Assign db_id_ and write DB ID to version_edit if provided.
-  void SetDBId(std::string&& id, bool read_only, VersionEdit* version_edit);
+                   RecoveryContext* recovery_ctx);
+  // Assign db_id_ and write DB ID to manifest if necessary.
+  void SetDBId(std::string&& id, bool read_only, RecoveryContext* recovery_ctx);
 
   // Collect a deduplicated collection of paths used by this DB, including
   // dbname_, DBOptions.db_paths, ColumnFamilyOptions.cf_paths.
@@ -1626,15 +1588,9 @@ class DBImpl : public DB {
   // vast majority of all files), since it already has the file size
   // on record, we don't need to query the file system. Otherwise, we query the
   // file system for the size of an unreferenced file.
-  // REQUIRES: mutex unlocked
   void TrackExistingDataFiles(
       const std::vector<std::string>& existing_data_files);
 
-  // Untrack data files in sst manager. This is only called during DB::Close on
-  // an unowned SstFileManager, to return it to a consistent state.
-  // REQUIRES: mutex unlocked
-  void UntrackDataFiles();
-
   // SetDbSessionId() should be called in the constuctor DBImpl()
   // to ensure that db_session_id_ gets updated every time the DB is opened
   void SetDbSessionId();
@@ -1687,7 +1643,6 @@ class DBImpl : public DB {
   friend class ForwardIterator;
   friend struct SuperVersion;
   friend class CompactedDBImpl;
-  friend class DBImplFollower;
 #ifndef NDEBUG
   friend class DBTest_ConcurrentFlushWAL_Test;
   friend class DBTest_MixedSlowdownOptionsStop_Test;
@@ -1701,8 +1656,6 @@ class DBImpl : public DB {
   friend class XFTransactionWriteHandler;
   friend class DBBlobIndexTest;
   friend class WriteUnpreparedTransactionTest_RecoveryTest_Test;
-  friend class CompactionServiceTest_PreservedOptionsLocalCompaction_Test;
-  friend class CompactionServiceTest_PreservedOptionsRemoteCompaction_Test;
 #endif
 
   struct CompactionState;
@@ -1744,11 +1697,8 @@ class DBImpl : public DB {
       return w;
     }
     Status ClearWriter() {
-      Status s;
-      if (writer->file()) {
-        // TODO: plumb Env::IOActivity, Env::IOPriority
-        s = writer->WriteBuffer(WriteOptions());
-      }
+      // TODO: plumb Env::IOActivity, Env::IOPriority
+      Status s = writer->WriteBuffer(WriteOptions());
       delete writer;
       writer = nullptr;
       return s;
@@ -1763,16 +1713,10 @@ class DBImpl : public DB {
 
     void PrepareForSync() {
       assert(!getting_synced);
-      // Ensure the head of logs_ is marked as getting_synced if any is.
+      // Size is expected to be monotonically increasing.
+      assert(writer->file()->GetFlushedSize() >= pre_sync_size);
       getting_synced = true;
-      // If last sync failed on a later WAL, this could be a fully synced
-      // and closed WAL that just needs to be recorded as synced in the
-      // manifest.
-      if (writer->file()) {
-        // Size is expected to be monotonically increasing.
-        assert(writer->file()->GetFlushedSize() >= pre_sync_size);
-        pre_sync_size = writer->file()->GetFlushedSize();
-      }
+      pre_sync_size = writer->file()->GetFlushedSize();
     }
 
     void FinishSync() {
@@ -1908,10 +1852,6 @@ class DBImpl : public DB {
     Env::Priority compaction_pri_;
   };
 
-  static bool IsRecoveryFlush(FlushReason flush_reason) {
-    return flush_reason == FlushReason::kErrorRecoveryRetryFlush ||
-           flush_reason == FlushReason::kErrorRecovery;
-  }
   // Initialize the built-in column family for persistent stats. Depending on
   // whether on-disk persistent stats have been enabled before, it may either
   // create a new column family and column family handle or just a column family
@@ -1974,14 +1914,7 @@ class DBImpl : public DB {
   void ReleaseFileNumberFromPendingOutputs(
       std::unique_ptr<std::list<uint64_t>::iterator>& v);
 
-  // Similar to pending_outputs, preserve OPTIONS file. Used for remote
-  // compaction.
-  std::list<uint64_t>::iterator CaptureOptionsFileNumber();
-  void ReleaseOptionsFileNumber(
-      std::unique_ptr<std::list<uint64_t>::iterator>& v);
-
-  // Sets bg error if there is an error writing to WAL.
-  IOStatus SyncClosedWals(const WriteOptions& write_options,
+  IOStatus SyncClosedLogs(const WriteOptions& write_options,
                           JobContext* job_context, VersionEdit* synced_wals,
                           bool error_recovery_in_prog);
 
@@ -2063,8 +1996,7 @@ class DBImpl : public DB {
   // REQUIRES: mutex held
   void SelectColumnFamiliesForAtomicFlush(
       autovector<ColumnFamilyData*>* selected_cfds,
-      const autovector<ColumnFamilyData*>& provided_candidate_cfds = {},
-      FlushReason flush_reason = FlushReason::kOthers);
+      const autovector<ColumnFamilyData*>& provided_candidate_cfds = {});
 
   // Force current memtable contents to be flushed.
   Status FlushMemTable(ColumnFamilyData* cfd, const FlushOptions& options,
@@ -2116,22 +2048,17 @@ class DBImpl : public DB {
       mutex_.Lock();
     }
 
-    if (immutable_db_options_.unordered_write) {
-      // Wait for the ones who already wrote to the WAL to finish their
-      // memtable write.
-      if (pending_memtable_writes_.load() != 0) {
-        // XXX: suspicious wait while holding DB mutex?
-        std::unique_lock<std::mutex> guard(switch_mutex_);
-        switch_cv_.wait(guard,
-                        [&] { return pending_memtable_writes_.load() == 0; });
-      }
-    } else {
-      // (Writes are finished before the next write group starts.)
+    if (!immutable_db_options_.unordered_write) {
+      // Then the writes are finished before the next write group starts
+      return;
     }
 
-    // Wait for any LockWAL to clear
-    while (lock_wal_count_ > 0) {
-      bg_cv_.Wait();
+    // Wait for the ones who already wrote to the WAL to finish their
+    // memtable write.
+    if (pending_memtable_writes_.load() != 0) {
+      std::unique_lock<std::mutex> guard(switch_mutex_);
+      switch_cv_.wait(guard,
+                      [&] { return pending_memtable_writes_.load() == 0; });
     }
   }
 
@@ -2199,7 +2126,7 @@ class DBImpl : public DB {
 
   // Used by WriteImpl to update bg_error_ when IO error happens, e.g., write
   // WAL, sync WAL fails, if paranoid check is enabled.
-  void WALIOStatusCheck(const IOStatus& status);
+  void IOStatusCheck(const IOStatus& status);
 
   // Used by WriteImpl to update bg_error_ in case of memtable insert error.
   void MemTableInsertStatusCheck(const Status& memtable_insert_status);
@@ -2212,10 +2139,6 @@ class DBImpl : public DB {
                           JobContext* job_context, LogBuffer* log_buffer,
                           CompactionJobInfo* compaction_job_info);
 
-  // REQUIRES: mutex unlocked
-  void TrackOrUntrackFiles(const std::vector<std::string>& existing_data_files,
-                           bool track);
-
   ColumnFamilyData* GetColumnFamilyDataByName(const std::string& cf_name);
 
   void MaybeScheduleFlushOrCompaction();
@@ -2245,27 +2168,9 @@ class DBImpl : public DB {
   void GenerateFlushRequest(const autovector<ColumnFamilyData*>& cfds,
                             FlushReason flush_reason, FlushRequest* req);
 
-  // Below functions are for executing flush, compaction in the background. A
-  // dequeue is the communication channel between threads that asks for the work
-  // to be done and the available threads in the thread pool that pick it up to
-  // execute it. We use these terminologies to describe the state of the work
-  // and its transitions:
-  // 1) It becomes pending once it's successfully enqueued into the
-  //    corresponding dequeue, a work in this state is also called unscheduled.
-  //    Counter `unscheduled_*_` counts work in this state.
-  // 2) When `MaybeScheduleFlushOrCompaction` schedule a thread to run `BGWork*`
-  //    for the work, it becomes scheduled
-  //    Counter `bg_*_scheduled_` counts work in this state.
-  // 3) Once the thread start to execute `BGWork*`, the work is popped from the
-  //    dequeue, it is now in running state
-  //    Counter `num_running_*_` counts work in this state.
-  // 4) Eventually, the work is finished. We don't need to specifically track
-  //    finished work.
+  void SchedulePendingFlush(const FlushRequest& req);
 
-  // Returns true if `req` is successfully enqueued.
-  bool EnqueuePendingFlush(const FlushRequest& req);
-
-  void EnqueuePendingCompaction(ColumnFamilyData* cfd);
+  void SchedulePendingCompaction(ColumnFamilyData* cfd);
   void SchedulePendingPurge(std::string fname, std::string dir_to_sync,
                             FileType type, uint64_t number, int job_id);
   static void BGWorkCompaction(void* arg);
@@ -2339,11 +2244,6 @@ class DBImpl : public DB {
   ColumnFamilyData* PickCompactionFromQueue(
       std::unique_ptr<TaskLimiterToken>* token, LogBuffer* log_buffer);
 
-  IOStatus SyncWalImpl(bool include_current_wal,
-                       const WriteOptions& write_options,
-                       JobContext* job_context, VersionEdit* synced_wals,
-                       bool error_recovery_in_prog);
-
   // helper function to call after some of the logs_ were synced
   void MarkLogsSynced(uint64_t up_to, bool synced_dir, VersionEdit* edit);
   Status ApplyWALToManifest(const ReadOptions& read_options,
@@ -2401,9 +2301,6 @@ class DBImpl : public DB {
   bool HaveManualCompaction(ColumnFamilyData* cfd);
   bool MCOverlap(ManualCompactionState* m, ManualCompactionState* m1);
   void UpdateDeletionCompactionStats(const std::unique_ptr<Compaction>& c);
-
-  // May open and read table files for table property.
-  // Should not be called while holding mutex_.
   void BuildCompactionJobInfo(const ColumnFamilyData* cfd, Compaction* c,
                               const Status& st,
                               const CompactionJobStats& compaction_job_stats,
@@ -2619,10 +2516,8 @@ class DBImpl : public DB {
 
   bool persistent_stats_cfd_exists_ = true;
 
-  // The current WAL file and those that have not been found obsolete from
-  // memtable flushes. A WAL not on this list might still be pending writer
-  // flush and/or sync and close and might still be in logs_. alive_log_files_
-  // is protected by mutex_ and log_write_mutex_ with details as follows:
+  // alive_log_files_ is protected by mutex_ and log_write_mutex_ with details
+  // as follows:
   // 1. read by FindObsoleteFiles() which can be called in either application
   //    thread or RocksDB bg threads, both mutex_ and log_write_mutex_ are
   //    held.
@@ -2673,7 +2568,7 @@ class DBImpl : public DB {
   // 8. read by MarkLogsNotSynced() and MarkLogsSynced() are protected by
   //    log_write_mutex_.
   // 9. erase() by MarkLogsSynced() protected by log_write_mutex_.
-  // 10. read by SyncClosedWals() protected by only log_write_mutex_. This can
+  // 10. read by SyncClosedLogs() protected by only log_write_mutex_. This can
   //     happen in bg flush threads after DB::Open() returns success to
   //     applications.
   // 11. reads, e.g. front(), iteration, and back() called by PreprocessWrite()
@@ -2686,7 +2581,7 @@ class DBImpl : public DB {
   // 13. emplace_back() by SwitchMemtable() hold both mutex_ and
   //     log_write_mutex_. This happens in the write group leader. Can conflict
   //     with bg threads calling FindObsoleteFiles(), MarkLogsSynced(),
-  //     SyncClosedWals(), etc. as well as application threads calling
+  //     SyncClosedLogs(), etc. as well as application threads calling
   //     FlushWAL(), SyncWAL(), LockWAL(). This is fine because all parties
   //     require at least log_write_mutex_.
   // 14. iteration called in WriteToWAL(write_group) protected by
@@ -2770,11 +2665,6 @@ class DBImpl : public DB {
   // State is protected with db mutex.
   std::list<uint64_t> pending_outputs_;
 
-  // Similar to pending_outputs_, FindObsoleteFiles()/PurgeObsoleteFiles() never
-  // deletes any OPTIONS file that has number bigger than any of the file number
-  // in min_options_file_numbers_.
-  std::list<uint64_t> min_options_file_numbers_;
-
   // flush_queue_ and compaction_queue_ hold column families that we need to
   // flush and compact, respectively.
   // A column family is inserted into flush_queue_ when it satisfies condition
@@ -2997,14 +2887,6 @@ DBOptions SanitizeOptions(const std::string& db, const DBOptions& src,
 CompressionType GetCompressionFlush(const ImmutableCFOptions& ioptions,
                                     const MutableCFOptions& mutable_cf_options);
 
-// Return a VersionEdit for the DB's recovery when the `memtables` of the
-// specified column family are obsolete. Specifically, the min log number to
-// keep, and the WAL files that can be deleted.
-VersionEdit GetDBRecoveryEditForObsoletingMemTables(
-    VersionSet* vset, const ColumnFamilyData& cfd,
-    const autovector<VersionEdit*>& edit_list,
-    const autovector<MemTable*>& memtables, LogsWithPrepTracker* prep_tracker);
-
 // Return the earliest log file to keep after the memtable flush is
 // finalized.
 // `cfd_to_flush` is the column family whose memtable (specified in
@@ -3105,9 +2987,9 @@ inline Status DBImpl::FailIfReadCollapsedHistory(const ColumnFamilyData* cfd,
   if (!full_history_ts_low.empty() &&
       ucmp->CompareTimestamp(ts, full_history_ts_low) < 0) {
     std::stringstream oss;
-    oss << "Read timestamp: " << ucmp->TimestampToString(ts)
+    oss << "Read timestamp: " << ts.ToString(true)
         << " is smaller than full_history_ts_low: "
-        << ucmp->TimestampToString(full_history_ts_low) << std::endl;
+        << Slice(full_history_ts_low).ToString(true) << std::endl;
     return Status::InvalidArgument(oss.str());
   }
   return Status::OK();

db/db_impl/db_impl_compaction_flush.cc

@@ -87,9 +87,6 @@ bool DBImpl::ShouldRescheduleFlushRequestToRetainUDT(
   mutex_.AssertHeld();
   assert(flush_req.cfd_to_max_mem_id_to_persist.size() == 1);
   ColumnFamilyData* cfd = flush_req.cfd_to_max_mem_id_to_persist.begin()->first;
-  if (cfd->GetAndClearFlushSkipReschedule()) {
-    return false;
-  }
   uint64_t max_memtable_id =
       flush_req.cfd_to_max_mem_id_to_persist.begin()->second;
   if (cfd->IsDropped() ||
@@ -101,20 +98,15 @@ bool DBImpl::ShouldRescheduleFlushRequestToRetainUDT(
   // alleviated if we continue with the flush instead of postponing it.
   const auto& mutable_cf_options = *cfd->GetLatestMutableCFOptions();
 
-  // Use the same criteria as WaitUntilFlushWouldNotStallWrites does w.r.t
-  // defining what a write stall is about to happen means. If this uses a
-  // stricter criteria, for example, a write stall is about to happen if the
-  // last memtable is 10% full, there is a possibility that manual flush could
-  // be waiting in `WaitUntilFlushWouldNotStallWrites` with the incorrect
-  // expectation that others will clear up the excessive memtables and
-  // eventually let it proceed. The others in this case won't start clearing
-  // until the last memtable is 10% full. To avoid that scenario, the criteria
-  // this uses should be the same or less strict than
-  // `WaitUntilFlushWouldNotStallWrites` does.
+  // Taking the status of the active Memtable into consideration so that we are
+  // not just checking if DB is currently already in write stall mode.
+  int mem_to_flush = cfd->mem()->ApproximateMemoryUsageFast() >=
+                             cfd->mem()->write_buffer_size() / 2
+                         ? 1
+                         : 0;
   WriteStallCondition write_stall =
       ColumnFamilyData::GetWriteStallConditionAndCause(
-          cfd->GetUnflushedMemTableCountForWriteStallCheck(),
-          /*num_l0_files=*/0,
+          cfd->imm()->NumNotFlushed() + mem_to_flush, /*num_l0_files=*/0,
           /*num_compaction_needed_bytes=*/0, mutable_cf_options,
           *cfd->ioptions())
           .first;
@@ -124,19 +116,89 @@ bool DBImpl::ShouldRescheduleFlushRequestToRetainUDT(
   return true;
 }
 
-IOStatus DBImpl::SyncClosedWals(const WriteOptions& write_options,
+IOStatus DBImpl::SyncClosedLogs(const WriteOptions& write_options,
                                 JobContext* job_context,
                                 VersionEdit* synced_wals,
                                 bool error_recovery_in_prog) {
-  TEST_SYNC_POINT("DBImpl::SyncClosedWals:Start");
-
-  IOStatus io_s = SyncWalImpl(/*include_current_wal*/ false, write_options,
-                              job_context, synced_wals, error_recovery_in_prog);
-  if (!io_s.ok()) {
-    TEST_SYNC_POINT("DBImpl::SyncClosedWals:Failed");
-  } else {
-    TEST_SYNC_POINT("DBImpl::SyncClosedWals:end");
+  TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
+  InstrumentedMutexLock l(&log_write_mutex_);
+  autovector<log::Writer*, 1> logs_to_sync;
+  uint64_t current_log_number = logfile_number_;
+  while (logs_.front().number < current_log_number &&
+         logs_.front().IsSyncing()) {
+    log_sync_cv_.Wait();
   }
+  for (auto it = logs_.begin();
+       it != logs_.end() && it->number < current_log_number; ++it) {
+    auto& log = *it;
+    log.PrepareForSync();
+    logs_to_sync.push_back(log.writer);
+  }
+
+  IOStatus io_s;
+  if (!logs_to_sync.empty()) {
+    log_write_mutex_.Unlock();
+
+    assert(job_context);
+
+    for (log::Writer* log : logs_to_sync) {
+      ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                     "[JOB %d] Syncing log #%" PRIu64, job_context->job_id,
+                     log->get_log_number());
+      if (error_recovery_in_prog) {
+        log->file()->reset_seen_error();
+      }
+
+      IOOptions io_options;
+      io_s = WritableFileWriter::PrepareIOOptions(write_options, io_options);
+      if (!io_s.ok()) {
+        break;
+      }
+      io_s = log->file()->Sync(io_options, immutable_db_options_.use_fsync);
+      if (!io_s.ok()) {
+        break;
+      }
+
+      if (immutable_db_options_.recycle_log_file_num > 0) {
+        if (error_recovery_in_prog) {
+          log->file()->reset_seen_error();
+        }
+        // Normally the log file is closed when purging obsolete file, but if
+        // log recycling is enabled, the log file is closed here so that it
+        // can be reused.
+        io_s = log->Close(write_options);
+        if (!io_s.ok()) {
+          break;
+        }
+      }
+    }
+    if (io_s.ok()) {
+      IOOptions io_options;
+      io_s = WritableFileWriter::PrepareIOOptions(write_options, io_options);
+      if (io_s.ok()) {
+        io_s = directories_.GetWalDir()->FsyncWithDirOptions(
+            io_options, nullptr,
+            DirFsyncOptions(DirFsyncOptions::FsyncReason::kNewFileSynced));
+      }
+    }
+
+    TEST_SYNC_POINT_CALLBACK("DBImpl::SyncClosedLogs:BeforeReLock",
+                             /*arg=*/nullptr);
+    log_write_mutex_.Lock();
+
+    // "number <= current_log_number - 1" is equivalent to
+    // "number < current_log_number".
+    if (io_s.ok()) {
+      MarkLogsSynced(current_log_number - 1, true, synced_wals);
+    } else {
+      MarkLogsNotSynced(current_log_number - 1);
+    }
+    if (!io_s.ok()) {
+      TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Failed");
+      return io_s;
+    }
+  }
+  TEST_SYNC_POINT("DBImpl::SyncClosedLogs:end");
   return io_s;
 }
 
@@ -162,25 +224,19 @@ Status DBImpl::FlushMemTableToOutputFile(
   // the host crashes after flushing and before WAL is persistent, the
   // flushed SST may contain data from write batches whose updates to
   // other (unflushed) column families are missing.
-  //
-  // When 2PC is enabled, non-recent WAL(s) may be needed for crash-recovery,
-  // even when there is only one CF in the DB, for prepared transactions that
-  // had not been committed yet. Make sure we sync them to keep the persisted
-  // WAL state at least as new as the persisted SST state.
   const bool needs_to_sync_closed_wals =
       logfile_number_ > 0 &&
-      (versions_->GetColumnFamilySet()->NumberOfColumnFamilies() > 1 ||
-       allow_2pc());
+      versions_->GetColumnFamilySet()->NumberOfColumnFamilies() > 1;
 
   // If needs_to_sync_closed_wals is true, we need to record the current
   // maximum memtable ID of this column family so that a later PickMemtables()
   // call will not pick memtables whose IDs are higher. This is due to the fact
-  // that SyncClosedWals() may release the db mutex, and memtable switch can
+  // that SyncClosedLogs() may release the db mutex, and memtable switch can
   // happen for this column family in the meantime. The newly created memtables
   // have their data backed by unsynced WALs, thus they cannot be included in
   // this flush job.
   // Another reason why we must record the current maximum memtable ID of this
-  // column family: SyncClosedWals() may release db mutex, thus it's possible
+  // column family: SyncClosedLogs() may release db mutex, thus it's possible
   // for application to continue to insert into memtables increasing db's
   // sequence number. The application may take a snapshot, but this snapshot is
   // not included in `snapshot_seqs` which will be passed to flush job because
@@ -194,7 +250,7 @@ Status DBImpl::FlushMemTableToOutputFile(
 
   // If needs_to_sync_closed_wals is false, then the flush job will pick ALL
   // existing memtables of the column family when PickMemTable() is called
-  // later. Although we won't call SyncClosedWals() in this case, we may still
+  // later. Although we won't call SyncClosedLogs() in this case, we may still
   // call the callbacks of the listeners, i.e. NotifyOnFlushBegin() which also
   // releases and re-acquires the db mutex. In the meantime, the application
   // can still insert into the memtables and increase the db's sequence number.
@@ -224,12 +280,12 @@ Status DBImpl::FlushMemTableToOutputFile(
   bool need_cancel = false;
   IOStatus log_io_s = IOStatus::OK();
   if (needs_to_sync_closed_wals) {
-    // SyncClosedWals() may unlock and re-lock the log_write_mutex multiple
+    // SyncClosedLogs() may unlock and re-lock the log_write_mutex multiple
     // times.
     VersionEdit synced_wals;
     bool error_recovery_in_prog = error_handler_.IsRecoveryInProgress();
     mutex_.Unlock();
-    log_io_s = SyncClosedWals(write_options, job_context, &synced_wals,
+    log_io_s = SyncClosedLogs(write_options, job_context, &synced_wals,
                               error_recovery_in_prog);
     mutex_.Lock();
     if (log_io_s.ok() && synced_wals.IsWalAddition()) {
@@ -244,7 +300,7 @@ Status DBImpl::FlushMemTableToOutputFile(
       error_handler_.SetBGError(log_io_s, BackgroundErrorReason::kFlush);
     }
   } else {
-    TEST_SYNC_POINT("DBImpl::SyncClosedWals:Skip");
+    TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Skip");
   }
   s = log_io_s;
 
@@ -518,7 +574,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
     VersionEdit synced_wals;
     bool error_recovery_in_prog = error_handler_.IsRecoveryInProgress();
     mutex_.Unlock();
-    log_io_s = SyncClosedWals(write_options, job_context, &synced_wals,
+    log_io_s = SyncClosedLogs(write_options, job_context, &synced_wals,
                               error_recovery_in_prog);
     mutex_.Lock();
     if (log_io_s.ok() && synced_wals.IsWalAddition()) {
@@ -1032,12 +1088,7 @@ Status DBImpl::IncreaseFullHistoryTsLowImpl(ColumnFamilyData* cfd,
   assert(ucmp->timestamp_size() == ts_low.size() && !ts_low.empty());
   if (!current_ts_low.empty() &&
       ucmp->CompareTimestamp(ts_low, current_ts_low) < 0) {
-    std::stringstream oss;
-    oss << "Current full_history_ts_low: "
-        << ucmp->TimestampToString(current_ts_low)
-        << " is higher than provided ts: " << ucmp->TimestampToString(ts_low)
-        << std::endl;
-    return Status::InvalidArgument(oss.str());
+    return Status::InvalidArgument("Cannot decrease full_history_ts_low");
   }
 
   Status s = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
@@ -1069,11 +1120,6 @@ Status DBImpl::CompactRangeInternal(const CompactRangeOptions& options,
   if (options.target_path_id >= cfd->ioptions()->cf_paths.size()) {
     return Status::InvalidArgument("Invalid target path ID");
   }
-  if (options.change_level &&
-      cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
-    return Status::NotSupported(
-        "FIFO compaction does not support change_level.");
-  }
 
   bool flush_needed = true;
 
@@ -1134,16 +1180,6 @@ Status DBImpl::CompactRangeInternal(const CompactRangeOptions& options,
                             final_output_level, options, begin, end, exclusive,
                             false /* disable_trivial_move */,
                             std::numeric_limits<uint64_t>::max(), trim_ts);
-  } else if (cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
-    // FIFOCompactionPicker::CompactRange() will ignore the input key range
-    // [begin, end] and just try to pick compaction based on the configured
-    // option `compaction_options_fifo`. So we skip checking if [begin, end]
-    // overlaps with the DB here.
-    final_output_level = 0;
-    s = RunManualCompaction(cfd, /*input_level=*/0, final_output_level, options,
-                            begin, end, exclusive,
-                            false /* disable_trivial_move */,
-                            std::numeric_limits<uint64_t>::max(), trim_ts);
   } else {
     int first_overlapped_level = kInvalidLevel;
     {
@@ -1228,7 +1264,8 @@ Status DBImpl::CompactRangeInternal(const CompactRangeOptions& options,
       CleanupSuperVersion(super_version);
     }
     if (s.ok() && first_overlapped_level != kInvalidLevel) {
-      if (cfd->ioptions()->compaction_style == kCompactionStyleUniversal) {
+      if (cfd->ioptions()->compaction_style == kCompactionStyleUniversal ||
+          cfd->ioptions()->compaction_style == kCompactionStyleFIFO) {
         assert(first_overlapped_level == 0);
         s = RunManualCompaction(
             cfd, first_overlapped_level, first_overlapped_level, options, begin,
@@ -1480,11 +1517,16 @@ Status DBImpl::CompactFilesImpl(
         std::to_string(cfd->ioptions()->num_levels - 1));
   }
 
+  Status s = cfd->compaction_picker()->SanitizeCompactionInputFiles(
+      &input_set, cf_meta, output_level);
+  TEST_SYNC_POINT("DBImpl::CompactFilesImpl::PostSanitizeCompactionInputFiles");
+  if (!s.ok()) {
+    return s;
+  }
+
   std::vector<CompactionInputFiles> input_files;
-  Status s = cfd->compaction_picker()->SanitizeAndConvertCompactionInputFiles(
-      &input_set, cf_meta, output_level, version->storage_info(), &input_files);
-  TEST_SYNC_POINT(
-      "DBImpl::CompactFilesImpl::PostSanitizeAndConvertCompactionInputFiles");
+  s = cfd->compaction_picker()->GetCompactionInputsFromFileNumbers(
+      &input_files, &input_set, version->storage_info(), compact_options);
   if (!s.ok()) {
     return s;
   }
@@ -1561,12 +1603,6 @@ Status DBImpl::CompactFilesImpl(
 
   compaction_job.Prepare();
 
-  std::unique_ptr<std::list<uint64_t>::iterator> min_options_file_number_elem;
-  if (immutable_db_options().compaction_service != nullptr) {
-    min_options_file_number_elem.reset(
-        new std::list<uint64_t>::iterator(CaptureOptionsFileNumber()));
-  }
-
   mutex_.Unlock();
   TEST_SYNC_POINT("CompactFilesImpl:0");
   TEST_SYNC_POINT("CompactFilesImpl:1");
@@ -1576,10 +1612,6 @@ Status DBImpl::CompactFilesImpl(
   TEST_SYNC_POINT("CompactFilesImpl:3");
   mutex_.Lock();
 
-  if (immutable_db_options().compaction_service != nullptr) {
-    ReleaseOptionsFileNumber(min_options_file_number_elem);
-  }
-
   bool compaction_released = false;
   Status status =
       compaction_job.Install(*c->mutable_cf_options(), &compaction_released);
@@ -1605,12 +1637,10 @@ Status DBImpl::CompactFilesImpl(
 
   ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem);
 
-  mutex_.Unlock();
   if (compaction_job_info != nullptr) {
     BuildCompactionJobInfo(cfd, c.get(), s, compaction_job_stats,
                            job_context->job_id, compaction_job_info);
   }
-  mutex_.Lock();
 
   if (status.ok()) {
     // Done
@@ -1890,7 +1920,7 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
     Status status = versions_->LogAndApply(cfd, mutable_cf_options,
                                            read_options, write_options, &edit,
                                            &mutex_, directories_.GetDbDir());
-    c->MarkFilesBeingCompacted(false);
+
     cfd->compaction_picker()->UnregisterCompaction(c.get());
     c.reset();
 
@@ -2260,23 +2290,6 @@ void DBImpl::GenerateFlushRequest(const autovector<ColumnFamilyData*>& cfds,
   }
 }
 
-void DBImpl::NotifyOnManualFlushScheduled(autovector<ColumnFamilyData*> cfds,
-                                          FlushReason flush_reason) {
-  if (immutable_db_options_.listeners.size() == 0U) {
-    return;
-  }
-  if (shutting_down_.load(std::memory_order_acquire)) {
-    return;
-  }
-  std::vector<ManualFlushInfo> info;
-  for (ColumnFamilyData* cfd : cfds) {
-    info.push_back({cfd->GetID(), cfd->GetName(), flush_reason});
-  }
-  for (const auto& listener : immutable_db_options_.listeners) {
-    listener->OnManualFlushScheduled(this, info);
-  }
-}
-
 Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
                              const FlushOptions& flush_options,
                              FlushReason flush_reason,
@@ -2316,15 +2329,13 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
     }
     WaitForPendingWrites();
 
-    if (!cfd->mem()->IsEmpty() || !cached_recoverable_state_empty_.load() ||
-        IsRecoveryFlush(flush_reason)) {
+    if (!cfd->mem()->IsEmpty() || !cached_recoverable_state_empty_.load()) {
       s = SwitchMemtable(cfd, &context);
     }
     const uint64_t flush_memtable_id = std::numeric_limits<uint64_t>::max();
     if (s.ok()) {
       if (cfd->imm()->NumNotFlushed() != 0 || !cfd->mem()->IsEmpty() ||
-          !cached_recoverable_state_empty_.load() ||
-          IsRecoveryFlush(flush_reason)) {
+          !cached_recoverable_state_empty_.load()) {
         FlushRequest req{flush_reason, {{cfd, flush_memtable_id}}};
         flush_reqs.emplace_back(std::move(req));
         memtable_ids_to_wait.emplace_back(
@@ -2383,14 +2394,7 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
         }
       }
       for (const auto& req : flush_reqs) {
-        assert(req.cfd_to_max_mem_id_to_persist.size() == 1);
-        ColumnFamilyData* loop_cfd =
-            req.cfd_to_max_mem_id_to_persist.begin()->first;
-        bool already_queued_for_flush = loop_cfd->queued_for_flush();
-        bool flush_req_enqueued = EnqueuePendingFlush(req);
-        if (already_queued_for_flush || flush_req_enqueued) {
-          loop_cfd->SetFlushSkipReschedule();
-        }
+        SchedulePendingFlush(req);
       }
       MaybeScheduleFlushOrCompaction();
     }
@@ -2402,8 +2406,6 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
       }
     }
   }
-
-  NotifyOnManualFlushScheduled({cfd}, flush_reason);
   TEST_SYNC_POINT("DBImpl::FlushMemTable:AfterScheduleFlush");
   TEST_SYNC_POINT("DBImpl::FlushMemTable:BeforeWaitForBgFlush");
   if (s.ok() && flush_options.wait) {
@@ -2501,7 +2503,7 @@ Status DBImpl::AtomicFlushMemTables(
     }
     WaitForPendingWrites();
 
-    SelectColumnFamiliesForAtomicFlush(&cfds, candidate_cfds, flush_reason);
+    SelectColumnFamiliesForAtomicFlush(&cfds, candidate_cfds);
 
     // Unref the newly generated candidate cfds (when not provided) in
     // `candidate_cfds`
@@ -2512,8 +2514,7 @@ Status DBImpl::AtomicFlushMemTables(
     }
 
     for (auto cfd : cfds) {
-      if (cfd->mem()->IsEmpty() && cached_recoverable_state_empty_.load() &&
-          !IsRecoveryFlush(flush_reason)) {
+      if (cfd->mem()->IsEmpty() && cached_recoverable_state_empty_.load()) {
         continue;
       }
       cfd->Ref();
@@ -2538,7 +2539,7 @@ Status DBImpl::AtomicFlushMemTables(
         }
       }
       GenerateFlushRequest(cfds, flush_reason, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
       MaybeScheduleFlushOrCompaction();
     }
 
@@ -2549,7 +2550,6 @@ Status DBImpl::AtomicFlushMemTables(
       }
     }
   }
-  NotifyOnManualFlushScheduled(cfds, flush_reason);
   TEST_SYNC_POINT("DBImpl::AtomicFlushMemTables:AfterScheduleFlush");
   TEST_SYNC_POINT("DBImpl::AtomicFlushMemTables:BeforeWaitForBgFlush");
   if (s.ok() && flush_options.wait) {
@@ -2593,7 +2593,7 @@ Status DBImpl::RetryFlushesForErrorRecovery(FlushReason flush_reason,
   if (immutable_db_options_.atomic_flush) {
     FlushRequest flush_req;
     GenerateFlushRequest(cfds, flush_reason, &flush_req);
-    EnqueuePendingFlush(flush_req);
+    SchedulePendingFlush(flush_req);
     for (auto& iter : flush_req.cfd_to_max_mem_id_to_persist) {
       flush_memtable_ids.push_back(iter.second);
     }
@@ -2607,9 +2607,7 @@ Status DBImpl::RetryFlushesForErrorRecovery(FlushReason flush_reason,
           flush_reason,
           {{cfd,
             std::numeric_limits<uint64_t>::max() /* max_mem_id_to_persist */}}};
-      if (EnqueuePendingFlush(flush_req)) {
-        cfd->SetFlushSkipReschedule();
-      };
+      SchedulePendingFlush(flush_req);
     }
   }
   MaybeScheduleFlushOrCompaction();
@@ -2697,13 +2695,13 @@ Status DBImpl::WaitUntilFlushWouldNotStallWrites(ColumnFamilyData* cfd,
       // mode due to pending compaction bytes, but that's less common
       // No extra immutable Memtable will be created if the current Memtable is
       // empty.
-      write_stall_condition =
-          ColumnFamilyData::GetWriteStallConditionAndCause(
-              cfd->GetUnflushedMemTableCountForWriteStallCheck(),
-              vstorage->l0_delay_trigger_count() + 1,
-              vstorage->estimated_compaction_needed_bytes(), mutable_cf_options,
-              *cfd->ioptions())
-              .first;
+      int mem_to_flush = cfd->mem()->IsEmpty() ? 0 : 1;
+      write_stall_condition = ColumnFamilyData::GetWriteStallConditionAndCause(
+                                  cfd->imm()->NumNotFlushed() + mem_to_flush,
+                                  vstorage->l0_delay_trigger_count() + 1,
+                                  vstorage->estimated_compaction_needed_bytes(),
+                                  mutable_cf_options, *cfd->ioptions())
+                                  .first;
     } while (write_stall_condition != WriteStallCondition::kNormal);
   }
   return Status::OK();
@@ -2960,7 +2958,6 @@ void DBImpl::AddToCompactionQueue(ColumnFamilyData* cfd) {
   cfd->Ref();
   compaction_queue_.push_back(cfd);
   cfd->set_queued_for_compaction(true);
-  ++unscheduled_compactions_;
 }
 
 ColumnFamilyData* DBImpl::PopFirstFromCompactionQueue() {
@@ -3016,14 +3013,13 @@ ColumnFamilyData* DBImpl::PickCompactionFromQueue(
   return cfd;
 }
 
-bool DBImpl::EnqueuePendingFlush(const FlushRequest& flush_req) {
+void DBImpl::SchedulePendingFlush(const FlushRequest& flush_req) {
   mutex_.AssertHeld();
-  bool enqueued = false;
   if (reject_new_background_jobs_) {
-    return enqueued;
+    return;
   }
   if (flush_req.cfd_to_max_mem_id_to_persist.empty()) {
-    return enqueued;
+    return;
   }
   if (!immutable_db_options_.atomic_flush) {
     // For the non-atomic flush case, we never schedule multiple column
@@ -3038,7 +3034,6 @@ bool DBImpl::EnqueuePendingFlush(const FlushRequest& flush_req) {
       cfd->set_queued_for_flush(true);
       ++unscheduled_flushes_;
       flush_queue_.push_back(flush_req);
-      enqueued = true;
     }
   } else {
     for (auto& iter : flush_req.cfd_to_max_mem_id_to_persist) {
@@ -3047,20 +3042,19 @@ bool DBImpl::EnqueuePendingFlush(const FlushRequest& flush_req) {
     }
     ++unscheduled_flushes_;
     flush_queue_.push_back(flush_req);
-    enqueued = true;
   }
-  return enqueued;
 }
 
-void DBImpl::EnqueuePendingCompaction(ColumnFamilyData* cfd) {
+void DBImpl::SchedulePendingCompaction(ColumnFamilyData* cfd) {
   mutex_.AssertHeld();
   if (reject_new_background_jobs_) {
     return;
   }
   if (!cfd->queued_for_compaction() && cfd->NeedsCompaction()) {
-    TEST_SYNC_POINT_CALLBACK("EnqueuePendingCompaction::cfd",
+    TEST_SYNC_POINT_CALLBACK("SchedulePendingCompaction::cfd",
                              static_cast<void*>(cfd));
     AddToCompactionQueue(cfd);
+    ++unscheduled_compactions_;
   }
 }
 
@@ -3228,7 +3222,7 @@ Status DBImpl::BackgroundFlush(bool* made_progress, JobContext* job_context,
 #ifndef NDEBUG
       flush_req.reschedule_count += 1;
 #endif /* !NDEBUG */
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
       *reason = flush_reason;
       *flush_rescheduled_to_retain_udt = true;
       return Status::TryAgain();
@@ -3346,7 +3340,7 @@ void DBImpl::BackgroundCallFlush(Env::Priority thread_pri) {
       bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
       mutex_.Unlock();
       ROCKS_LOG_ERROR(immutable_db_options_.info_log,
-                      "[JOB %d] Waiting after background flush error: %s, "
+                      "[JOB %d] Waiting after background flush error: %s"
                       "Accumulated background error counts: %" PRIu64,
                       job_context.job_id, s.ToString().c_str(), error_cnt);
       log_buffer.FlushBufferToLog();
@@ -3551,14 +3545,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
       is_manual && manual_compaction->disallow_trivial_move;
 
   CompactionJobStats compaction_job_stats;
-  // Set is_remote_compaction to true on CompactionBegin Event if
-  // compaction_service is set except for trivial moves. We do not know whether
-  // remote compaction will actually be successfully scheduled, or fall back to
-  // local at this time. CompactionCompleted event will tell the truth where
-  // the compaction actually happened.
-  compaction_job_stats.is_remote_compaction =
-      immutable_db_options().compaction_service != nullptr;
-
   Status status;
   if (!error_handler_.IsBGWorkStopped()) {
     if (shutting_down_.load(std::memory_order_acquire)) {
@@ -3696,6 +3682,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
               ->ComputeCompactionScore(*(c->immutable_options()),
                                        *(c->mutable_cf_options()));
           AddToCompactionQueue(cfd);
+          ++unscheduled_compactions_;
 
           c.reset();
           // Don't need to sleep here, because BackgroundCallCompaction
@@ -3724,6 +3711,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
           if (cfd->NeedsCompaction()) {
             // Yes, we need more compactions!
             AddToCompactionQueue(cfd);
+            ++unscheduled_compactions_;
             MaybeScheduleFlushOrCompaction();
           }
         }
@@ -3784,8 +3772,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);
 
     compaction_job_stats.num_input_files = c->num_input_files(0);
-    // Trivial moves do not get compacted remotely
-    compaction_job_stats.is_remote_compaction = false;
 
     NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                             compaction_job_stats, job_context->job_id);
@@ -3921,12 +3907,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
         &bg_bottom_compaction_scheduled_);
     compaction_job.Prepare();
 
-    std::unique_ptr<std::list<uint64_t>::iterator> min_options_file_number_elem;
-    if (immutable_db_options().compaction_service != nullptr) {
-      min_options_file_number_elem.reset(
-          new std::list<uint64_t>::iterator(CaptureOptionsFileNumber()));
-    }
-
     NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                             compaction_job_stats, job_context->job_id);
     mutex_.Unlock();
@@ -3936,11 +3916,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     compaction_job.Run().PermitUncheckedError();
     TEST_SYNC_POINT("DBImpl::BackgroundCompaction:NonTrivial:AfterRun");
     mutex_.Lock();
-
-    if (immutable_db_options().compaction_service != nullptr) {
-      ReleaseOptionsFileNumber(min_options_file_number_elem);
-    }
-
     status =
         compaction_job.Install(*c->mutable_cf_options(), &compaction_released);
     io_s = compaction_job.io_status();
@@ -4026,6 +4001,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                    *(c->mutable_cf_options()));
       if (!cfd->queued_for_compaction()) {
         AddToCompactionQueue(cfd);
+        ++unscheduled_compactions_;
       }
     }
   }
@@ -4194,7 +4170,7 @@ void DBImpl::BuildCompactionJobInfo(
   compaction_job_info->base_input_level = c->start_level();
   compaction_job_info->output_level = c->output_level();
   compaction_job_info->stats = compaction_job_stats;
-  const auto& input_table_properties = c->GetOrInitInputTableProperties();
+  const auto& input_table_properties = c->GetInputTableProperties();
   const auto& output_table_properties = c->GetOutputTableProperties();
   compaction_job_info->table_properties.insert(input_table_properties.begin(),
                                                input_table_properties.end());
@@ -4297,7 +4273,7 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
 
   // Whenever we install new SuperVersion, we might need to issue new flushes or
   // compactions.
-  EnqueuePendingCompaction(cfd);
+  SchedulePendingCompaction(cfd);
   MaybeScheduleFlushOrCompaction();
 
   // Update max_total_in_memory_state_

db/db_impl/db_impl_debug.cc

@@ -9,7 +9,6 @@
 
 #ifndef NDEBUG
 
-#include "db/blob/blob_file_cache.h"
 #include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
@@ -200,11 +199,6 @@ Status DBImpl::TEST_GetBGError() {
   return error_handler_.GetBGError();
 }
 
-bool DBImpl::TEST_IsRecoveryInProgress() {
-  InstrumentedMutexLock l(&mutex_);
-  return error_handler_.IsRecoveryInProgress();
-}
-
 void DBImpl::TEST_LockMutex() { mutex_.Lock(); }
 
 void DBImpl::TEST_UnlockMutex() { mutex_.Unlock(); }
@@ -320,58 +314,9 @@ const autovector<uint64_t>& DBImpl::TEST_GetFilesToQuarantine() const {
   return error_handler_.GetFilesToQuarantine();
 }
 
-void DBImpl::TEST_DeleteObsoleteFiles() {
-  InstrumentedMutexLock l(&mutex_);
-  DeleteObsoleteFiles();
-}
-
 size_t DBImpl::TEST_EstimateInMemoryStatsHistorySize() const {
   InstrumentedMutexLock l(&const_cast<DBImpl*>(this)->stats_history_mutex_);
   return EstimateInMemoryStatsHistorySize();
 }
-
-void DBImpl::TEST_VerifyNoObsoleteFilesCached(
-    bool db_mutex_already_held) const {
-  // This check is somewhat expensive and obscure to make a part of every
-  // unit test in every build variety. Thus, we only enable it for ASAN builds.
-  if (!kMustFreeHeapAllocations) {
-    return;
-  }
-
-  std::optional<InstrumentedMutexLock> l;
-  if (db_mutex_already_held) {
-    mutex_.AssertHeld();
-  } else {
-    l.emplace(&mutex_);
-  }
-
-  std::vector<uint64_t> live_files;
-  for (auto cfd : *versions_->GetColumnFamilySet()) {
-    if (cfd->IsDropped()) {
-      continue;
-    }
-    // Sneakily add both SST and blob files to the same list
-    cfd->current()->AddLiveFiles(&live_files, &live_files);
-  }
-  std::sort(live_files.begin(), live_files.end());
-
-  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
-                          const Cache::CacheItemHelper* helper) {
-    if (helper != BlobFileCache::GetHelper()) {
-      // Skip non-blob files for now
-      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
-      // unit tests.
-      return;
-    }
-    // See TableCache and BlobFileCache
-    assert(key.size() == sizeof(uint64_t));
-    uint64_t file_number;
-    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
-    // Assert file is in sorted live_files
-    assert(
-        std::binary_search(live_files.begin(), live_files.end(), file_number));
-  };
-  table_cache_->ApplyToAllEntries(fn, {});
-}
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // NDEBUG

db/db_impl/db_impl_experimental.cc

@@ -47,7 +47,7 @@ Status DBImpl::SuggestCompactRange(ColumnFamilyHandle* column_family,
     // compaction score
     vstorage->ComputeCompactionScore(*cfd->ioptions(),
                                      *cfd->GetLatestMutableCFOptions());
-    EnqueuePendingCompaction(cfd);
+    SchedulePendingCompaction(cfd);
     MaybeScheduleFlushOrCompaction();
   }
   return Status::OK();

db/db_impl/db_impl_files.cc

@@ -43,14 +43,6 @@ uint64_t DBImpl::GetObsoleteSstFilesSize() {
   return versions_->GetObsoleteSstFilesSize();
 }
 
-uint64_t DBImpl::MinOptionsFileNumberToKeep() {
-  mutex_.AssertHeld();
-  if (!min_options_file_numbers_.empty()) {
-    return *min_options_file_numbers_.begin();
-  }
-  return std::numeric_limits<uint64_t>::max();
-}
-
 Status DBImpl::DisableFileDeletions() {
   Status s;
   int my_disable_delete_obsolete_files;
@@ -155,7 +147,6 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
   // here but later find newer generated unfinalized files while scanning.
   job_context->min_pending_output = MinObsoleteSstNumberToKeep();
   job_context->files_to_quarantine = error_handler_.GetFilesToQuarantine();
-  job_context->min_options_file_number = MinOptionsFileNumberToKeep();
 
   // Get obsolete files.  This function will also update the list of
   // pending files in VersionSet().
@@ -321,26 +312,6 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
         // logs_ could have changed while we were waiting.
         continue;
       }
-      // This WAL file is not live, so it's OK if we never sync the rest of it.
-      // If it's already closed, then it's been fully synced. If
-      // !background_close_inactive_wals then we need to Close it before
-      // removing from logs_ but not blocking while holding log_write_mutex_.
-      if (!immutable_db_options_.background_close_inactive_wals &&
-          log.writer->file()) {
-        // We are taking ownership of and pinning the front entry, so we can
-        // expect it to be the same after releasing and re-acquiring the lock
-        log.PrepareForSync();
-        log_write_mutex_.Unlock();
-        // TODO: maybe check the return value of Close.
-        // TODO: plumb Env::IOActivity, Env::IOPriority
-        auto s = log.writer->file()->Close({});
-        s.PermitUncheckedError();
-        log_write_mutex_.Lock();
-        log.writer->PublishIfClosed();
-        assert(&log == &logs_.front());
-        log.FinishSync();
-        log_sync_cv_.SignalAll();
-      }
       logs_to_free_.push_back(log.ReleaseWriter());
       logs_.pop_front();
     }
@@ -439,24 +410,12 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
       state.manifest_delete_files.size());
   // We may ignore the dbname when generating the file names.
   for (auto& file : state.sst_delete_files) {
-    auto* handle = file.metadata->table_reader_handle;
-    if (file.only_delete_metadata) {
-      if (handle) {
-        // Simply release handle of file that is not being deleted
-        table_cache_->Release(handle);
-      }
-    } else {
-      // File is being deleted (actually obsolete)
-      auto number = file.metadata->fd.GetNumber();
-      candidate_files.emplace_back(MakeTableFileName(number), file.path);
-      if (handle == nullptr) {
-        // For files not "pinned" in table cache
-        handle = TableCache::Lookup(table_cache_.get(), number);
-      }
-      if (handle) {
-        TableCache::ReleaseObsolete(table_cache_.get(), handle,
-                                    file.uncache_aggressiveness);
-      }
+    if (!file.only_delete_metadata) {
+      candidate_files.emplace_back(
+          MakeTableFileName(file.metadata->fd.GetNumber()), file.path);
+    }
+    if (file.metadata->table_reader_handle) {
+      table_cache_->Release(file.metadata->table_reader_handle);
     }
     file.DeleteMetadata();
   }
@@ -507,7 +466,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
                                 dbname_);
 
   // File numbers of most recent two OPTIONS file in candidate_files (found in
-  // previous FindObsoleteFiles(full_scan=true))
+  // previos FindObsoleteFiles(full_scan=true))
   // At this point, there must not be any duplicate file numbers in
   // candidate_files.
   uint64_t optsfile_num1 = std::numeric_limits<uint64_t>::min();
@@ -528,16 +487,11 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
     }
   }
 
-  // For remote compactions, we need to keep OPTIONS file that may get
-  // referenced by the remote worker
-
-  optsfile_num2 = std::min(optsfile_num2, state.min_options_file_number);
-
   // Close WALs before trying to delete them.
   for (const auto w : state.logs_to_free) {
     // TODO: maybe check the return value of Close.
     // TODO: plumb Env::IOActivity, Env::IOPriority
-    auto s = w->Close({});
+    auto s = w->Close(WriteOptions());
     s.PermitUncheckedError();
   }
 
@@ -623,6 +577,8 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
     std::string fname;
     std::string dir_to_sync;
     if (type == kTableFile) {
+      // evict from cache
+      TableCache::Evict(table_cache_.get(), number);
       fname = MakeTableFileName(candidate_file.file_path, number);
       dir_to_sync = candidate_file.file_path;
     } else if (type == kBlobFile) {
@@ -736,38 +692,6 @@ void DBImpl::DeleteObsoleteFiles() {
   mutex_.Lock();
 }
 
-VersionEdit GetDBRecoveryEditForObsoletingMemTables(
-    VersionSet* vset, const ColumnFamilyData& cfd,
-    const autovector<VersionEdit*>& edit_list,
-    const autovector<MemTable*>& memtables, LogsWithPrepTracker* prep_tracker) {
-  VersionEdit wal_deletion_edit;
-  uint64_t min_wal_number_to_keep = 0;
-  assert(edit_list.size() > 0);
-  if (vset->db_options()->allow_2pc) {
-    // Note that if mempurge is successful, the edit_list will
-    // not be applicable (contains info of new min_log number to keep,
-    // and level 0 file path of SST file created during normal flush,
-    // so both pieces of information are irrelevant after a successful
-    // mempurge operation).
-    min_wal_number_to_keep = PrecomputeMinLogNumberToKeep2PC(
-        vset, cfd, edit_list, memtables, prep_tracker);
-
-    // We piggyback the information of earliest log file to keep in the
-    // manifest entry for the last file flushed.
-  } else {
-    min_wal_number_to_keep =
-        PrecomputeMinLogNumberToKeepNon2PC(vset, cfd, edit_list);
-  }
-
-  wal_deletion_edit.SetMinLogNumberToKeep(min_wal_number_to_keep);
-  if (vset->db_options()->track_and_verify_wals_in_manifest) {
-    if (min_wal_number_to_keep > vset->GetWalSet().GetMinWalNumberToKeep()) {
-      wal_deletion_edit.DeleteWalsBefore(min_wal_number_to_keep);
-    }
-  }
-  return wal_deletion_edit;
-}
-
 uint64_t FindMinPrepLogReferencedByMemTable(
     VersionSet* vset, const autovector<MemTable*>& memtables_to_flush) {
   uint64_t min_log = 0;
@@ -967,60 +891,57 @@ uint64_t PrecomputeMinLogNumberToKeep2PC(
 }
 
 void DBImpl::SetDBId(std::string&& id, bool read_only,
-                     VersionEdit* version_edit) {
+                     RecoveryContext* recovery_ctx) {
   assert(db_id_.empty());
   assert(!id.empty());
   db_id_ = std::move(id);
-  if (!read_only && version_edit) {
-    assert(version_edit != nullptr);
+  if (!read_only && immutable_db_options_.write_dbid_to_manifest) {
+    assert(recovery_ctx != nullptr);
     assert(versions_->GetColumnFamilySet() != nullptr);
-    version_edit->SetDBId(db_id_);
+    VersionEdit edit;
+    edit.SetDBId(db_id_);
     versions_->db_id_ = db_id_;
+    recovery_ctx->UpdateVersionEdits(
+        versions_->GetColumnFamilySet()->GetDefault(), edit);
   }
 }
 
 Status DBImpl::SetupDBId(const WriteOptions& write_options, bool read_only,
-                         bool is_new_db, VersionEdit* version_edit) {
+                         RecoveryContext* recovery_ctx) {
   Status s;
-  if (!is_new_db) {
-    // Check for the IDENTITY file and create it if not there or
-    // broken or not matching manifest
-    std::string db_id_in_file;
-    s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
-    if (s.ok()) {
-      s = GetDbIdentityFromIdentityFile(&db_id_in_file);
-      if (s.ok() && !db_id_in_file.empty()) {
-        if (db_id_.empty()) {
-          // Loaded from file and wasn't already known from manifest
-          SetDBId(std::move(db_id_in_file), read_only, version_edit);
-          return s;
-        } else if (db_id_ == db_id_in_file) {
-          // Loaded from file and matches manifest
-          return s;
-        }
+  // Check for the IDENTITY file and create it if not there or
+  // broken or not matching manifest
+  std::string db_id_in_file;
+  s = fs_->FileExists(IdentityFileName(dbname_), IOOptions(), nullptr);
+  if (s.ok()) {
+    s = GetDbIdentityFromIdentityFile(&db_id_in_file);
+    if (s.ok() && !db_id_in_file.empty()) {
+      if (db_id_.empty()) {
+        // Loaded from file and wasn't already known from manifest
+        SetDBId(std::move(db_id_in_file), read_only, recovery_ctx);
+        return s;
+      } else if (db_id_ == db_id_in_file) {
+        // Loaded from file and matches manifest
+        return s;
       }
     }
-    if (s.IsNotFound()) {
-      s = Status::OK();
-    }
-    if (!s.ok()) {
-      assert(s.IsIOError());
-      return s;
-    }
+  }
+  if (s.IsNotFound()) {
+    s = Status::OK();
+  }
+  if (!s.ok()) {
+    assert(s.IsIOError());
+    return s;
   }
   // Otherwise IDENTITY file is missing or no good.
   // Generate new id if needed
   if (db_id_.empty()) {
-    SetDBId(env_->GenerateUniqueId(), read_only, version_edit);
+    SetDBId(env_->GenerateUniqueId(), read_only, recovery_ctx);
   }
   // Persist it to IDENTITY file if allowed
-  if (!read_only && immutable_db_options_.write_identity_file) {
-    s = SetIdentityFile(write_options, env_, dbname_,
-                        immutable_db_options_.metadata_write_temperature,
-                        db_id_);
+  if (!read_only) {
+    s = SetIdentityFile(write_options, env_, dbname_, db_id_);
   }
-  // NOTE: an obsolete IDENTITY file with write_identity_file=false is handled
-  // elsewhere, so that it's only deleted after successful recovery
   return s;
 }
 

db/db_impl/db_impl_follower.cc

@@ -5,7 +5,6 @@
 
 #include "db/db_impl/db_impl_follower.h"
 
-#include <algorithm>
 #include <cinttypes>
 
 #include "db/arena_wrapped_db_iter.h"
@@ -96,28 +95,17 @@ Status DBImplFollower::TryCatchUpWithLeader() {
   assert(versions_.get() != nullptr);
   assert(manifest_reader_.get() != nullptr);
   Status s;
-
-  TEST_SYNC_POINT("DBImplFollower::TryCatchupWithLeader:Begin1");
-  TEST_SYNC_POINT("DBImplFollower::TryCatchupWithLeader:Begin2");
   // read the manifest and apply new changes to the follower instance
   std::unordered_set<ColumnFamilyData*> cfds_changed;
   JobContext job_context(0, true /*create_superversion*/);
   {
     InstrumentedMutexLock lock_guard(&mutex_);
-    std::vector<std::string> files_to_delete;
     s = static_cast_with_check<ReactiveVersionSet>(versions_.get())
             ->ReadAndApply(&mutex_, &manifest_reader_,
-                           manifest_reader_status_.get(), &cfds_changed,
-                           &files_to_delete);
-    ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem_);
-    pending_outputs_inserted_elem_.reset(new std::list<uint64_t>::iterator(
-        CaptureCurrentFileNumberInPendingOutputs()));
+                           manifest_reader_status_.get(), &cfds_changed);
 
     ROCKS_LOG_INFO(immutable_db_options_.info_log, "Last sequence is %" PRIu64,
                    static_cast<uint64_t>(versions_->LastSequence()));
-    ROCKS_LOG_INFO(
-        immutable_db_options_.info_log, "Next file number is %" PRIu64,
-        static_cast<uint64_t>(versions_->current_next_file_number()));
     for (ColumnFamilyData* cfd : cfds_changed) {
       if (cfd->IsDropped()) {
         ROCKS_LOG_DEBUG(immutable_db_options_.info_log, "[%s] is dropped\n",
@@ -159,33 +147,9 @@ Status DBImplFollower::TryCatchUpWithLeader() {
         sv_context.NewSuperVersion();
       }
     }
-
-    for (auto& file : files_to_delete) {
-      IOStatus io_s = fs_->DeleteFile(file, IOOptions(), nullptr);
-      if (!io_s.ok()) {
-        ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                       "Cannot delete file %s: %s", file.c_str(),
-                       io_s.ToString().c_str());
-      }
-    }
   }
   job_context.Clean();
 
-  // Cleanup unused, obsolete files.
-  JobContext purge_files_job_context(0);
-  {
-    InstrumentedMutexLock lock_guard(&mutex_);
-    // Currently, follower instance does not create any database files, thus
-    // is unnecessary for the follower to force full scan.
-    FindObsoleteFiles(&purge_files_job_context, /*force=*/false);
-  }
-  if (purge_files_job_context.HaveSomethingToDelete()) {
-    PurgeObsoleteFiles(purge_files_job_context);
-  }
-  purge_files_job_context.Clean();
-
-  TEST_SYNC_POINT("DBImplFollower::TryCatchupWithLeader:End");
-
   return s;
 }
 
@@ -235,8 +199,6 @@ Status DBImplFollower::Close() {
     catch_up_thread_.reset();
   }
 
-  ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem_);
-
   return DBImpl::Close();
 }
 

db/db_impl/db_impl_follower.h

@@ -27,7 +27,7 @@ class DBImplFollower : public DBImplSecondary {
   bool OwnTablesAndLogs() const override {
     // TODO: Change this to true once we've properly implemented file
     // deletion for the read scaling case
-    return true;
+    return false;
   }
 
   Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families,
@@ -49,6 +49,5 @@ class DBImplFollower : public DBImplSecondary {
   std::string src_path_;
   port::Mutex mu_;
   port::CondVar cv_;
-  std::unique_ptr<std::list<uint64_t>::iterator> pending_outputs_inserted_elem_;
 };
 }  // namespace ROCKSDB_NAMESPACE

db/db_impl/db_impl_open.cc

@@ -289,25 +289,24 @@ Status DBImpl::ValidateOptions(const DBOptions& db_options) {
           "start_time and end_time cannot be the same");
     }
   }
-
-  if (!db_options.write_dbid_to_manifest && !db_options.write_identity_file) {
-    return Status::InvalidArgument(
-        "write_dbid_to_manifest and write_identity_file cannot both be false");
-  }
   return Status::OK();
 }
 
 Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
-  VersionEdit new_db_edit;
+  VersionEdit new_db;
   const WriteOptions write_options(Env::IOActivity::kDBOpen);
-  Status s = SetupDBId(write_options, /*read_only=*/false, /*is_new_db=*/true,
-                       &new_db_edit);
+  Status s = SetIdentityFile(write_options, env_, dbname_);
   if (!s.ok()) {
     return s;
   }
-  new_db_edit.SetLogNumber(0);
-  new_db_edit.SetNextFile(2);
-  new_db_edit.SetLastSequence(0);
+  if (immutable_db_options_.write_dbid_to_manifest) {
+    std::string temp_db_id;
+    GetDbIdentityFromIdentityFile(&temp_db_id);
+    new_db.SetDBId(temp_db_id);
+  }
+  new_db.SetLogNumber(0);
+  new_db.SetNextFile(2);
+  new_db.SetLastSequence(0);
 
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "Creating manifest 1 \n");
   const std::string manifest = DescriptorFileName(dbname_, 1);
@@ -317,12 +316,6 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
     }
     std::unique_ptr<FSWritableFile> file;
     FileOptions file_options = fs_->OptimizeForManifestWrite(file_options_);
-    // DB option takes precedence when not kUnknown
-    if (immutable_db_options_.metadata_write_temperature !=
-        Temperature::kUnknown) {
-      file_options.temperature =
-          immutable_db_options_.metadata_write_temperature;
-    }
     s = NewWritableFile(fs_.get(), manifest, &file, file_options);
     if (!s.ok()) {
       return s;
@@ -339,7 +332,7 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
         tmp_set.Contains(FileType::kDescriptorFile)));
     log::Writer log(std::move(file_writer), 0, false);
     std::string record;
-    new_db_edit.EncodeTo(&record);
+    new_db.EncodeTo(&record);
     s = log.AddRecord(write_options, record);
     if (s.ok()) {
       s = SyncManifest(&immutable_db_options_, write_options, log.file());
@@ -348,7 +341,6 @@ Status DBImpl::NewDB(std::vector<std::string>* new_filenames) {
   if (s.ok()) {
     // Make "CURRENT" file that points to the new manifest file.
     s = SetCurrentFile(write_options, fs_.get(), dbname_, 1,
-                       immutable_db_options_.metadata_write_temperature,
                        directories_.GetDbDir());
     if (new_filenames) {
       new_filenames->emplace_back(
@@ -525,7 +517,7 @@ Status DBImpl::Recover(
     }
     assert(s.ok());
   }
-  assert(is_new_db || db_id_.empty());
+  assert(db_id_.empty());
   Status s;
   bool missing_table_file = false;
   if (!immutable_db_options_.best_efforts_recovery) {
@@ -535,12 +527,6 @@ Status DBImpl::Recover(
                            /*no_error_if_files_missing=*/false, is_retry,
                            &desc_status);
     desc_status.PermitUncheckedError();
-    if (is_retry) {
-      RecordTick(stats_, FILE_READ_CORRUPTION_RETRY_COUNT);
-      if (desc_status.ok()) {
-        RecordTick(stats_, FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT);
-      }
-    }
     if (can_retry) {
       // If we're opening for the first time and the failure is likely due to
       // a corrupt MANIFEST file (could result in either the log::Reader
@@ -651,7 +637,7 @@ Status DBImpl::Recover(
                            f->fd.smallest_seqno, f->fd.largest_seqno,
                            f->marked_for_compaction,
                            f->temperature,  // this can be different from
-                           // `last_level_temperature`
+                                            // `last_level_temperature`
                            f->oldest_blob_file_number, f->oldest_ancester_time,
                            f->file_creation_time, f->epoch_number,
                            f->file_checksum, f->file_checksum_func_name,
@@ -671,17 +657,7 @@ Status DBImpl::Recover(
       }
     }
   }
-  if (is_new_db) {
-    // Already set up DB ID in NewDB
-  } else if (immutable_db_options_.write_dbid_to_manifest && recovery_ctx) {
-    VersionEdit edit;
-    s = SetupDBId(write_options, read_only, is_new_db, &edit);
-    recovery_ctx->UpdateVersionEdits(
-        versions_->GetColumnFamilySet()->GetDefault(), edit);
-  } else {
-    s = SetupDBId(write_options, read_only, is_new_db, nullptr);
-  }
-  assert(!s.ok() || !db_id_.empty());
+  s = SetupDBId(write_options, read_only, recovery_ctx);
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "DB ID: %s\n", db_id_.c_str());
   if (s.ok() && !read_only) {
     s = MaybeUpdateNextFileNumber(recovery_ctx);
@@ -1669,8 +1645,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
   TableProperties table_properties;
   {
     ScopedArenaPtr<InternalIterator> iter(
-        mem->NewIterator(ro, /*seqno_to_time_mapping=*/nullptr, &arena,
-                         /*prefix_extractor=*/nullptr));
+        mem->NewIterator(ro, /*seqno_to_time_mapping=*/nullptr, &arena));
     ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
                     "[%s] [WriteLevel0TableForRecovery]"
                     " Level-0 table #%" PRIu64 ": started",
@@ -1689,15 +1664,12 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
     meta.oldest_ancester_time = current_time;
     meta.epoch_number = cfd->NewEpochNumber();
     {
-      auto write_hint =
-          cfd->current()->storage_info()->CalculateSSTWriteHint(/*level=*/0);
+      auto write_hint = cfd->CalculateSSTWriteHint(0);
       mutex_.Unlock();
 
       SequenceNumber earliest_write_conflict_snapshot;
       std::vector<SequenceNumber> snapshot_seqs =
           snapshots_.GetAll(&earliest_write_conflict_snapshot);
-      SequenceNumber earliest_snapshot =
-          (snapshot_seqs.empty() ? kMaxSequenceNumber : snapshot_seqs.at(0));
       auto snapshot_checker = snapshot_checker_.get();
       if (use_custom_gc_ && snapshot_checker == nullptr) {
         snapshot_checker = DisableGCSnapshotChecker::Instance();
@@ -1717,7 +1689,6 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
       IOStatus io_s;
       const ReadOptions read_option(Env::IOActivity::kDBOpen);
       const WriteOptions write_option(Env::IO_HIGH, Env::IOActivity::kDBOpen);
-
       TableBuilderOptions tboptions(
           *cfd->ioptions(), mutable_cf_options, read_option, write_option,
           cfd->internal_comparator(), cfd->internal_tbl_prop_coll_factories(),
@@ -1726,22 +1697,21 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
           0 /* level */, false /* is_bottommost */,
           TableFileCreationReason::kRecovery, 0 /* oldest_key_time */,
           0 /* file_creation_time */, db_id_, db_session_id_,
-          0 /* target_file_size */, meta.fd.GetNumber(), kMaxSequenceNumber);
+          0 /* target_file_size */, meta.fd.GetNumber());
       Version* version = cfd->current();
       version->Ref();
       uint64_t num_input_entries = 0;
-      s = BuildTable(dbname_, versions_.get(), immutable_db_options_, tboptions,
-                     file_options_for_compaction_, cfd->table_cache(),
-                     iter.get(), std::move(range_del_iters), &meta,
-                     &blob_file_additions, snapshot_seqs, earliest_snapshot,
-                     earliest_write_conflict_snapshot, kMaxSequenceNumber,
-                     snapshot_checker, paranoid_file_checks,
-                     cfd->internal_stats(), &io_s, io_tracer_,
-                     BlobFileCreationReason::kRecovery,
-                     nullptr /* seqno_to_time_mapping */, &event_logger_,
-                     job_id, nullptr /* table_properties */, write_hint,
-                     nullptr /*full_history_ts_low*/, &blob_callback_, version,
-                     &num_input_entries);
+      s = BuildTable(
+          dbname_, versions_.get(), immutable_db_options_, tboptions,
+          file_options_for_compaction_, cfd->table_cache(), iter.get(),
+          std::move(range_del_iters), &meta, &blob_file_additions,
+          snapshot_seqs, earliest_write_conflict_snapshot, kMaxSequenceNumber,
+          snapshot_checker, paranoid_file_checks, cfd->internal_stats(), &io_s,
+          io_tracer_, BlobFileCreationReason::kRecovery,
+          nullptr /* seqno_to_time_mapping */, &event_logger_, job_id,
+          nullptr /* table_properties */, write_hint,
+          nullptr /*full_history_ts_low*/, &blob_callback_, version,
+          &num_input_entries);
       version->Unref();
       LogFlush(immutable_db_options_.info_log);
       ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
@@ -1953,10 +1923,6 @@ IOStatus DBImpl::CreateWAL(const WriteOptions& write_options,
       BuildDBOptions(immutable_db_options_, mutable_db_options_);
   FileOptions opt_file_options =
       fs_->OptimizeForLogWrite(file_options_, db_options);
-  // DB option takes precedence when not kUnknown
-  if (immutable_db_options_.wal_write_temperature != Temperature::kUnknown) {
-    opt_file_options.temperature = immutable_db_options_.wal_write_temperature;
-  }
   std::string wal_dir = immutable_db_options_.GetWalDir();
   std::string log_fname = LogFileName(wal_dir, log_file_num);
 
@@ -1996,7 +1962,46 @@ IOStatus DBImpl::CreateWAL(const WriteOptions& write_options,
 
 void DBImpl::TrackExistingDataFiles(
     const std::vector<std::string>& existing_data_files) {
-  TrackOrUntrackFiles(existing_data_files, /*track=*/true);
+  auto sfm = static_cast<SstFileManagerImpl*>(
+      immutable_db_options_.sst_file_manager.get());
+  assert(sfm);
+  std::vector<ColumnFamilyMetaData> metadata;
+  GetAllColumnFamilyMetaData(&metadata);
+
+  std::unordered_set<std::string> referenced_files;
+  for (const auto& md : metadata) {
+    for (const auto& lmd : md.levels) {
+      for (const auto& fmd : lmd.files) {
+        // We're assuming that each sst file name exists in at most one of
+        // the paths.
+        std::string file_path =
+            fmd.directory + kFilePathSeparator + fmd.relative_filename;
+        sfm->OnAddFile(file_path, fmd.size).PermitUncheckedError();
+        referenced_files.insert(file_path);
+      }
+    }
+    for (const auto& bmd : md.blob_files) {
+      std::string name = bmd.blob_file_name;
+      // The BlobMetaData.blob_file_name may start with "/".
+      if (!name.empty() && name[0] == kFilePathSeparator) {
+        name = name.substr(1);
+      }
+      // We're assuming that each blob file name exists in at most one of
+      // the paths.
+      std::string file_path = bmd.blob_file_path + kFilePathSeparator + name;
+      sfm->OnAddFile(file_path, bmd.blob_file_size).PermitUncheckedError();
+      referenced_files.insert(file_path);
+    }
+  }
+
+  for (const auto& file_path : existing_data_files) {
+    if (referenced_files.find(file_path) != referenced_files.end()) {
+      continue;
+    }
+    // There shouldn't be any duplicated files. In case there is, SstFileManager
+    // will take care of deduping it.
+    sfm->OnAddFile(file_path).PermitUncheckedError();
+  }
 }
 
 Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
@@ -2140,13 +2145,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
     s = impl->LogAndApplyForRecovery(recovery_ctx);
   }
 
-  if (s.ok() && !impl->immutable_db_options_.write_identity_file) {
-    // On successful recovery, delete an obsolete IDENTITY file to avoid DB ID
-    // inconsistency
-    impl->env_->DeleteFile(IdentityFileName(impl->dbname_))
-        .PermitUncheckedError();
-  }
-
   if (s.ok() && impl->immutable_db_options_.persist_stats_to_disk) {
     impl->mutex_.AssertHeld();
     s = impl->InitPersistStatsColumnFamily();

db/db_impl/db_impl_secondary.cc

@@ -12,8 +12,7 @@
 #include "logging/auto_roll_logger.h"
 #include "logging/logging.h"
 #include "monitoring/perf_context_imp.h"
-#include "rocksdb/convenience.h"
-#include "rocksdb/utilities/options_util.h"
+#include "rocksdb/configurable.h"
 #include "util/cast_util.h"
 #include "util/write_batch_util.h"
 
@@ -681,8 +680,7 @@ Status DBImplSecondary::TryCatchUpWithPrimary() {
     InstrumentedMutexLock lock_guard(&mutex_);
     s = static_cast_with_check<ReactiveVersionSet>(versions_.get())
             ->ReadAndApply(&mutex_, &manifest_reader_,
-                           manifest_reader_status_.get(), &cfds_changed,
-                           /*files_to_delete=*/nullptr);
+                           manifest_reader_status_.get(), &cfds_changed);
 
     ROCKS_LOG_INFO(immutable_db_options_.info_log, "Last sequence is %" PRIu64,
                    static_cast<uint64_t>(versions_->LastSequence()));
@@ -939,101 +937,69 @@ Status DB::OpenAndCompact(
     const std::string& output_directory, const std::string& input,
     std::string* output,
     const CompactionServiceOptionsOverride& override_options) {
-  // Check for cancellation
   if (options.canceled && options.canceled->load(std::memory_order_acquire)) {
     return Status::Incomplete(Status::SubCode::kManualCompactionPaused);
   }
-
-  // 1. Deserialize Compaction Input
   CompactionServiceInput compaction_input;
   Status s = CompactionServiceInput::Read(input, &compaction_input);
   if (!s.ok()) {
     return s;
   }
 
-  // 2. Load the options
-  DBOptions db_options;
-  ConfigOptions config_options;
-  config_options.env = override_options.env;
-  std::vector<ColumnFamilyDescriptor> all_column_families;
-
-  std::string options_file_name =
-      OptionsFileName(name, compaction_input.options_file_number);
-
-  s = LoadOptionsFromFile(config_options, options_file_name, &db_options,
-                          &all_column_families);
-  if (!s.ok()) {
-    return s;
+  compaction_input.db_options.max_open_files = -1;
+  compaction_input.db_options.compaction_service = nullptr;
+  if (compaction_input.db_options.statistics) {
+    compaction_input.db_options.statistics.reset();
   }
-
-  // 3. Override pointer configurations in DBOptions with
-  // CompactionServiceOptionsOverride
-  db_options.env = override_options.env;
-  db_options.file_checksum_gen_factory =
+  compaction_input.db_options.env = override_options.env;
+  compaction_input.db_options.file_checksum_gen_factory =
       override_options.file_checksum_gen_factory;
-  db_options.statistics = override_options.statistics;
-  db_options.listeners = override_options.listeners;
-  db_options.compaction_service = nullptr;
-  // We will close the DB after the compaction anyway.
-  // Open as many files as needed for the compaction.
-  db_options.max_open_files = -1;
+  compaction_input.db_options.statistics = override_options.statistics;
+  compaction_input.column_family.options.comparator =
+      override_options.comparator;
+  compaction_input.column_family.options.merge_operator =
+      override_options.merge_operator;
+  compaction_input.column_family.options.compaction_filter =
+      override_options.compaction_filter;
+  compaction_input.column_family.options.compaction_filter_factory =
+      override_options.compaction_filter_factory;
+  compaction_input.column_family.options.prefix_extractor =
+      override_options.prefix_extractor;
+  compaction_input.column_family.options.table_factory =
+      override_options.table_factory;
+  compaction_input.column_family.options.sst_partitioner_factory =
+      override_options.sst_partitioner_factory;
+  compaction_input.column_family.options.table_properties_collector_factories =
+      override_options.table_properties_collector_factories;
+  compaction_input.db_options.listeners = override_options.listeners;
 
-  // 4. Filter CFs that are needed for OpenAndCompact()
-  // We do not need to open all column families for the remote compaction.
-  // Only open default CF + target CF. If target CF == default CF, we will open
-  // just the default CF (Due to current limitation, DB cannot open without the
-  // default CF)
   std::vector<ColumnFamilyDescriptor> column_families;
-  for (auto& cf : all_column_families) {
-    if (cf.name == compaction_input.cf_name) {
-      cf.options.comparator = override_options.comparator;
-      cf.options.merge_operator = override_options.merge_operator;
-      cf.options.compaction_filter = override_options.compaction_filter;
-      cf.options.compaction_filter_factory =
-          override_options.compaction_filter_factory;
-      cf.options.prefix_extractor = override_options.prefix_extractor;
-      cf.options.table_factory = override_options.table_factory;
-      cf.options.sst_partitioner_factory =
-          override_options.sst_partitioner_factory;
-      cf.options.table_properties_collector_factories =
-          override_options.table_properties_collector_factories;
-      column_families.emplace_back(cf);
-    } else if (cf.name == kDefaultColumnFamilyName) {
-      column_families.emplace_back(cf);
-    }
+  column_families.push_back(compaction_input.column_family);
+  // TODO: we have to open default CF, because of an implementation limitation,
+  // currently we just use the same CF option from input, which is not collect
+  // and open may fail.
+  if (compaction_input.column_family.name != kDefaultColumnFamilyName) {
+    column_families.emplace_back(kDefaultColumnFamilyName,
+                                 compaction_input.column_family.options);
   }
 
-  // 5. Open db As Secondary
   DB* db;
   std::vector<ColumnFamilyHandle*> handles;
-  s = DB::OpenAsSecondary(db_options, name, output_directory, column_families,
-                          &handles, &db);
+
+  s = DB::OpenAsSecondary(compaction_input.db_options, name, output_directory,
+                          column_families, &handles, &db);
   if (!s.ok()) {
     return s;
   }
-  assert(db);
 
-  // 6. Find the handle of the Column Family that this will compact
-  ColumnFamilyHandle* cfh = nullptr;
-  for (auto* handle : handles) {
-    if (compaction_input.cf_name == handle->GetName()) {
-      cfh = handle;
-      break;
-    }
-  }
-  assert(cfh);
-
-  // 7. Run the compaction without installation.
-  // Output will be stored in the directory specified by output_directory
   CompactionServiceResult compaction_result;
   DBImplSecondary* db_secondary = static_cast_with_check<DBImplSecondary>(db);
-  s = db_secondary->CompactWithoutInstallation(options, cfh, compaction_input,
-                                               &compaction_result);
+  assert(handles.size() > 0);
+  s = db_secondary->CompactWithoutInstallation(
+      options, handles[0], compaction_input, &compaction_result);
 
-  // 8. Serialize the result
   Status serialization_status = compaction_result.Write(output);
 
-  // 9. Close the db and return
   for (auto& handle : handles) {
     delete handle;
   }

db/db_impl/db_impl_write.cc

@@ -155,36 +155,21 @@ Status DBImpl::Write(const WriteOptions& write_options, WriteBatch* my_batch) {
   }
   if (s.ok()) {
     s = WriteImpl(write_options, my_batch, /*callback=*/nullptr,
-                  /*user_write_cb=*/nullptr,
                   /*log_used=*/nullptr);
   }
   return s;
 }
 
-Status DBImpl::WriteWithCallback(const WriteOptions& write_options,
-                                 WriteBatch* my_batch, WriteCallback* callback,
-                                 UserWriteCallback* user_write_cb) {
-  Status s;
-  if (write_options.protection_bytes_per_key > 0) {
-    s = WriteBatchInternal::UpdateProtectionInfo(
-        my_batch, write_options.protection_bytes_per_key);
-  }
-  if (s.ok()) {
-    s = WriteImpl(write_options, my_batch, callback, user_write_cb);
-  }
-  return s;
-}
-
 Status DBImpl::WriteWithCallback(const WriteOptions& write_options,
                                  WriteBatch* my_batch,
-                                 UserWriteCallback* user_write_cb) {
+                                 WriteCallback* callback) {
   Status s;
   if (write_options.protection_bytes_per_key > 0) {
     s = WriteBatchInternal::UpdateProtectionInfo(
         my_batch, write_options.protection_bytes_per_key);
   }
   if (s.ok()) {
-    s = WriteImpl(write_options, my_batch, /*callback=*/nullptr, user_write_cb);
+    s = WriteImpl(write_options, my_batch, callback, nullptr);
   }
   return s;
 }
@@ -194,9 +179,9 @@ Status DBImpl::WriteWithCallback(const WriteOptions& write_options,
 // published sequence.
 Status DBImpl::WriteImpl(const WriteOptions& write_options,
                          WriteBatch* my_batch, WriteCallback* callback,
-                         UserWriteCallback* user_write_cb, uint64_t* log_used,
-                         uint64_t log_ref, bool disable_memtable,
-                         uint64_t* seq_used, size_t batch_cnt,
+                         uint64_t* log_used, uint64_t log_ref,
+                         bool disable_memtable, uint64_t* seq_used,
+                         size_t batch_cnt,
                          PreReleaseCallback* pre_release_callback,
                          PostMemTableCallback* post_memtable_callback) {
   assert(!seq_per_batch_ || batch_cnt != 0);
@@ -236,11 +221,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     return Status::InvalidArgument(
         "`WriteOptions::protection_bytes_per_key` must be zero or eight");
   } else if (write_options.disableWAL &&
-             immutable_db_options_.recycle_log_file_num > 0 &&
-             !(two_write_queues_ && disable_memtable)) {
-    // Corruption detection in recycled WALs relies on sequential sequence
-    // numbers, but WritePreparedTxnDB uses disableWAL internally for split
-    // writes
+             immutable_db_options_.recycle_log_file_num > 0) {
     return Status::InvalidArgument(
         "WriteOptions::disableWAL option is not supported if "
         "DBOptions::recycle_log_file_num > 0");
@@ -283,10 +264,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     return Status::NotSupported(
         "seq_per_batch currently does not honor post_memtable_callback");
   }
-  if (my_batch->HasDeleteRange() && immutable_db_options_.row_cache) {
-    return Status::NotSupported(
-        "DeleteRange is not compatible with row cache.");
-  }
   // Otherwise IsLatestPersistentState optimization does not make sense
   assert(!WriteBatchInternal::IsLatestPersistentState(my_batch) ||
          disable_memtable);
@@ -303,10 +280,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
         seq_per_batch_ ? kDoAssignOrder : kDontAssignOrder;
     // Otherwise it is WAL-only Prepare batches in WriteCommitted policy and
     // they don't consume sequence.
-    return WriteImplWALOnly(
-        &nonmem_write_thread_, write_options, my_batch, callback, user_write_cb,
-        log_used, log_ref, seq_used, batch_cnt, pre_release_callback,
-        assign_order, kDontPublishLastSeq, disable_memtable);
+    return WriteImplWALOnly(&nonmem_write_thread_, write_options, my_batch,
+                            callback, log_used, log_ref, seq_used, batch_cnt,
+                            pre_release_callback, assign_order,
+                            kDontPublishLastSeq, disable_memtable);
   }
 
   if (immutable_db_options_.unordered_write) {
@@ -318,9 +295,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     // Use a write thread to i) optimize for WAL write, ii) publish last
     // sequence in in increasing order, iii) call pre_release_callback serially
     Status status = WriteImplWALOnly(
-        &write_thread_, write_options, my_batch, callback, user_write_cb,
-        log_used, log_ref, &seq, sub_batch_cnt, pre_release_callback,
-        kDoAssignOrder, kDoPublishLastSeq, disable_memtable);
+        &write_thread_, write_options, my_batch, callback, log_used, log_ref,
+        &seq, sub_batch_cnt, pre_release_callback, kDoAssignOrder,
+        kDoPublishLastSeq, disable_memtable);
     TEST_SYNC_POINT("DBImpl::WriteImpl:UnorderedWriteAfterWriteWAL");
     if (!status.ok()) {
       return status;
@@ -337,20 +314,17 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   }
 
   if (immutable_db_options_.enable_pipelined_write) {
-    return PipelinedWriteImpl(write_options, my_batch, callback, user_write_cb,
-                              log_used, log_ref, disable_memtable, seq_used);
+    return PipelinedWriteImpl(write_options, my_batch, callback, log_used,
+                              log_ref, disable_memtable, seq_used);
   }
 
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
-  WriteThread::Writer w(write_options, my_batch, callback, user_write_cb,
-                        log_ref, disable_memtable, batch_cnt,
-                        pre_release_callback, post_memtable_callback);
+  WriteThread::Writer w(write_options, my_batch, callback, log_ref,
+                        disable_memtable, batch_cnt, pre_release_callback,
+                        post_memtable_callback);
   StopWatch write_sw(immutable_db_options_.clock, stats_, DB_WRITE);
 
   write_thread_.JoinBatchGroup(&w);
-  if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_CALLER) {
-    write_thread_.SetMemWritersEachStride(&w);
-  }
   if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) {
     // we are a non-leader in a parallel group
 
@@ -556,35 +530,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     const SequenceNumber current_sequence = last_sequence + 1;
     last_sequence += seq_inc;
 
-    if (log_context.need_log_sync) {
-      VersionEdit synced_wals;
-      log_write_mutex_.Lock();
-      if (status.ok()) {
-        MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
-                       &synced_wals);
-      } else {
-        MarkLogsNotSynced(logfile_number_);
-      }
-      log_write_mutex_.Unlock();
-      if (status.ok() && synced_wals.IsWalAddition()) {
-        InstrumentedMutexLock l(&mutex_);
-        // TODO: plumb Env::IOActivity, Env::IOPriority
-        const ReadOptions read_options;
-        status = ApplyWALToManifest(read_options, write_options, &synced_wals);
-      }
-
-      // Requesting sync with two_write_queues_ is expected to be very rare. We
-      // hence provide a simple implementation that is not necessarily
-      // efficient.
-      if (status.ok() && two_write_queues_) {
-        if (manual_wal_flush_) {
-          status = FlushWAL(true);
-        } else {
-          status = SyncWAL();
-        }
-      }
-    }
-
     // PreReleaseCallback is called after WAL write and before memtable write
     if (status.ok()) {
       SequenceNumber next_sequence = current_sequence;
@@ -656,7 +601,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
   if (!io_s.ok()) {
     // Check WriteToWAL status
-    WALIOStatusCheck(io_s);
+    IOStatusCheck(io_s);
   }
   if (!w.CallbackFailed()) {
     if (!io_s.ok()) {
@@ -668,6 +613,34 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     assert(pre_release_cb_status.ok());
   }
 
+  if (log_context.need_log_sync) {
+    VersionEdit synced_wals;
+    log_write_mutex_.Lock();
+    if (status.ok()) {
+      MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
+                     &synced_wals);
+    } else {
+      MarkLogsNotSynced(logfile_number_);
+    }
+    log_write_mutex_.Unlock();
+    if (status.ok() && synced_wals.IsWalAddition()) {
+      InstrumentedMutexLock l(&mutex_);
+      // TODO: plumb Env::IOActivity, Env::IOPriority
+      const ReadOptions read_options;
+      status = ApplyWALToManifest(read_options, write_options, &synced_wals);
+    }
+
+    // Requesting sync with two_write_queues_ is expected to be very rare. We
+    // hence provide a simple implementation that is not necessarily efficient.
+    if (two_write_queues_) {
+      if (manual_wal_flush_) {
+        status = FlushWAL(true);
+      } else {
+        status = SyncWAL();
+      }
+    }
+  }
+
   bool should_exit_batch_group = true;
   if (in_parallel_group) {
     // CompleteParallelWorker returns true if this thread should
@@ -702,7 +675,6 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
 Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
                                   WriteBatch* my_batch, WriteCallback* callback,
-                                  UserWriteCallback* user_write_cb,
                                   uint64_t* log_used, uint64_t log_ref,
                                   bool disable_memtable, uint64_t* seq_used) {
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
@@ -710,8 +682,8 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
 
   WriteContext write_context;
 
-  WriteThread::Writer w(write_options, my_batch, callback, user_write_cb,
-                        log_ref, disable_memtable, /*_batch_cnt=*/0,
+  WriteThread::Writer w(write_options, my_batch, callback, log_ref,
+                        disable_memtable, /*_batch_cnt=*/0,
                         /*_pre_release_callback=*/nullptr);
   write_thread_.JoinBatchGroup(&w);
   TEST_SYNC_POINT("DBImplWrite::PipelinedWriteImpl:AfterJoinBatchGroup");
@@ -799,7 +771,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
 
     if (!io_s.ok()) {
       // Check WriteToWAL status
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
     } else if (!w.CallbackFailed()) {
       WriteStatusCheck(w.status);
     }
@@ -850,9 +822,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
     // so we need to set its status to pass ASSERT_STATUS_CHECKED
     memtable_write_group.status.PermitUncheckedError();
   }
-  if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_CALLER) {
-    write_thread_.SetMemWritersEachStride(&w);
-  }
+
   if (w.state == WriteThread::STATE_PARALLEL_MEMTABLE_WRITER) {
     PERF_TIMER_STOP(write_pre_and_post_process_time);
     PERF_TIMER_FOR_WAIT_GUARD(write_memtable_time);
@@ -892,8 +862,7 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options,
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
   StopWatch write_sw(immutable_db_options_.clock, stats_, DB_WRITE);
 
-  WriteThread::Writer w(write_options, my_batch, callback,
-                        /*user_write_cb=*/nullptr, log_ref,
+  WriteThread::Writer w(write_options, my_batch, callback, log_ref,
                         false /*disable_memtable*/);
 
   if (w.CheckCallback(this) && w.ShouldWriteToMemtable()) {
@@ -943,15 +912,13 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options,
 // applicable in a two-queue setting.
 Status DBImpl::WriteImplWALOnly(
     WriteThread* write_thread, const WriteOptions& write_options,
-    WriteBatch* my_batch, WriteCallback* callback,
-    UserWriteCallback* user_write_cb, uint64_t* log_used,
+    WriteBatch* my_batch, WriteCallback* callback, uint64_t* log_used,
     const uint64_t log_ref, uint64_t* seq_used, const size_t sub_batch_cnt,
     PreReleaseCallback* pre_release_callback, const AssignOrder assign_order,
     const PublishLastSeq publish_last_seq, const bool disable_memtable) {
   PERF_TIMER_GUARD(write_pre_and_post_process_time);
-  WriteThread::Writer w(write_options, my_batch, callback, user_write_cb,
-                        log_ref, disable_memtable, sub_batch_cnt,
-                        pre_release_callback);
+  WriteThread::Writer w(write_options, my_batch, callback, log_ref,
+                        disable_memtable, sub_batch_cnt, pre_release_callback);
   StopWatch write_sw(immutable_db_options_.clock, stats_, DB_WRITE);
 
   write_thread->JoinBatchGroup(&w);
@@ -969,17 +936,21 @@ Status DBImpl::WriteImplWALOnly(
   assert(w.state == WriteThread::STATE_GROUP_LEADER);
 
   if (publish_last_seq == kDoPublishLastSeq) {
+    Status status;
+
     // Currently we only use kDoPublishLastSeq in unordered_write
     assert(immutable_db_options_.unordered_write);
-
+    WriteContext write_context;
+    if (error_handler_.IsDBStopped()) {
+      status = error_handler_.GetBGError();
+    }
     // TODO(myabandeh): Make preliminary checks thread-safe so we could do them
     // without paying the cost of obtaining the mutex.
-    LogContext log_context;
-    WriteContext write_context;
-    Status status =
-        PreprocessWrite(write_options, &log_context, &write_context);
-    WriteStatusCheckOnLocked(status);
-
+    if (status.ok()) {
+      LogContext log_context;
+      status = PreprocessWrite(write_options, &log_context, &write_context);
+      WriteStatusCheckOnLocked(status);
+    }
     if (!status.ok()) {
       WriteThread::WriteGroup write_group;
       write_thread->EnterAsBatchGroupLeader(&w, &write_group);
@@ -1077,7 +1048,7 @@ Status DBImpl::WriteImplWALOnly(
     // This error checking and return is moved up to avoid using uninitialized
     // last_sequence.
     if (!io_s.ok()) {
-      WALIOStatusCheck(io_s);
+      IOStatusCheck(io_s);
       write_thread->ExitAsBatchGroupLeader(write_group, status);
       return status;
     }
@@ -1175,7 +1146,7 @@ void DBImpl::WriteStatusCheck(const Status& status) {
   }
 }
 
-void DBImpl::WALIOStatusCheck(const IOStatus& io_status) {
+void DBImpl::IOStatusCheck(const IOStatus& io_status) {
   // Is setting bg_error_ enough here?  This will at least stop
   // compaction and fail any further writes.
   if ((immutable_db_options_.paranoid_checks && !io_status.ok() &&
@@ -1183,8 +1154,7 @@ void DBImpl::WALIOStatusCheck(const IOStatus& io_status) {
       io_status.IsIOFenced()) {
     mutex_.Lock();
     // Maybe change the return status to void?
-    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback,
-                              /*wal_related=*/true);
+    error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback);
     mutex_.Unlock();
   } else {
     // Force writable file to be continue writable.
@@ -1202,7 +1172,8 @@ void DBImpl::MemTableInsertStatusCheck(const Status& status) {
     mutex_.Lock();
     assert(!error_handler_.IsBGWorkStopped());
     // Maybe change the return status to void?
-    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable);
+    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable)
+        .PermitUncheckedError();
     mutex_.Unlock();
   }
 }
@@ -1408,7 +1379,6 @@ IOStatus DBImpl::WriteToWAL(const WriteBatch& merged_batch,
   total_log_size_ += log_entry.size();
   log_file_number_size.AddSize(*log_size);
   log_empty_ = false;
-
   return io_s;
 }
 
@@ -1481,14 +1451,9 @@ IOStatus DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
         if (!io_s.ok()) {
           break;
         }
-        // If last sync failed on a later WAL, this could be a fully synced
-        // and closed WAL that just needs to be recorded as synced in the
-        // manifest.
-        if (auto* f = log.writer->file()) {
-          io_s = f->Sync(opts, immutable_db_options_.use_fsync);
-          if (!io_s.ok()) {
-            break;
-          }
+        io_s = log.writer->file()->Sync(opts, immutable_db_options_.use_fsync);
+        if (!io_s.ok()) {
+          break;
         }
       }
     }
@@ -1520,11 +1485,6 @@ IOStatus DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
     RecordTick(stats_, WAL_FILE_BYTES, log_size);
     stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal);
     RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
-    for (auto* writer : write_group) {
-      if (!writer->CallbackFailed()) {
-        writer->CheckPostWalWriteCallback();
-      }
-    }
   }
   return io_s;
 }
@@ -1589,11 +1549,6 @@ IOStatus DBImpl::ConcurrentWriteToWAL(
     stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal,
                       concurrent);
     RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
-    for (auto* writer : write_group) {
-      if (!writer->CallbackFailed()) {
-        writer->CheckPostWalWriteCallback();
-      }
-    }
   }
   return io_s;
 }
@@ -1653,8 +1608,7 @@ Status DBImpl::WriteRecoverableState() {
 
 void DBImpl::SelectColumnFamiliesForAtomicFlush(
     autovector<ColumnFamilyData*>* selected_cfds,
-    const autovector<ColumnFamilyData*>& provided_candidate_cfds,
-    FlushReason flush_reason) {
+    const autovector<ColumnFamilyData*>& provided_candidate_cfds) {
   mutex_.AssertHeld();
   assert(selected_cfds);
 
@@ -1677,8 +1631,7 @@ void DBImpl::SelectColumnFamiliesForAtomicFlush(
       continue;
     }
     if (cfd->imm()->NumNotFlushed() != 0 || !cfd->mem()->IsEmpty() ||
-        !cached_recoverable_state_empty_.load() ||
-        IsRecoveryFlush(flush_reason)) {
+        !cached_recoverable_state_empty_.load()) {
       selected_cfds->push_back(cfd);
     }
   }
@@ -1790,13 +1743,13 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
       if (!immutable_db_options_.atomic_flush) {
         FlushRequest flush_req;
         GenerateFlushRequest({cfd}, FlushReason::kWalFull, &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
       }
     }
     if (immutable_db_options_.atomic_flush) {
       FlushRequest flush_req;
       GenerateFlushRequest(cfds, FlushReason::kWalFull, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
     }
     MaybeScheduleFlushOrCompaction();
   }
@@ -1882,13 +1835,13 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
         FlushRequest flush_req;
         GenerateFlushRequest({cfd}, FlushReason::kWriteBufferManager,
                              &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
       }
     }
     if (immutable_db_options_.atomic_flush) {
       FlushRequest flush_req;
       GenerateFlushRequest(cfds, FlushReason::kWriteBufferManager, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
     }
     MaybeScheduleFlushOrCompaction();
   }
@@ -2164,12 +2117,12 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) {
       AssignAtomicFlushSeq(cfds);
       FlushRequest flush_req;
       GenerateFlushRequest(cfds, FlushReason::kWriteBufferFull, &flush_req);
-      EnqueuePendingFlush(flush_req);
+      SchedulePendingFlush(flush_req);
     } else {
       for (auto* cfd : cfds) {
         FlushRequest flush_req;
         GenerateFlushRequest({cfd}, FlushReason::kWriteBufferFull, &flush_req);
-        EnqueuePendingFlush(flush_req);
+        SchedulePendingFlush(flush_req);
       }
     }
     MaybeScheduleFlushOrCompaction();
@@ -2199,8 +2152,6 @@ void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/,
 // two_write_queues_ is true (This is to simplify the reasoning.)
 Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   mutex_.AssertHeld();
-  assert(lock_wal_count_ == 0);
-
   // TODO: plumb Env::IOActivity, Env::IOPriority
   const ReadOptions read_options;
   const WriteOptions write_options;
@@ -2244,11 +2195,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   memtable_info.earliest_seqno = cfd->mem()->GetEarliestSequenceNumber();
   memtable_info.num_entries = cfd->mem()->num_entries();
   memtable_info.num_deletes = cfd->mem()->num_deletes();
-  if (!cfd->ioptions()->persist_user_defined_timestamps &&
-      cfd->user_comparator()->timestamp_size() > 0) {
-    const Slice& newest_udt = cfd->mem()->GetNewestUDT();
-    memtable_info.newest_udt.assign(newest_udt.data(), newest_udt.size());
-  }
   // Log this later after lock release. It may be outdated, e.g., if background
   // flush happens before logging, but that should be ok.
   int num_imm_unflushed = cfd->imm()->NumNotFlushed();
@@ -2268,15 +2214,14 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
     SequenceNumber seq = versions_->LastSequence();
     new_mem = cfd->ConstructNewMemtable(mutable_cf_options, seq);
     context->superversion_context.NewSuperVersion();
-
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "[%s] New memtable created with log file: #%" PRIu64
-                   ". Immutable memtables: %d.\n",
-                   cfd->GetName().c_str(), new_log_number, num_imm_unflushed);
-    // There should be no concurrent write as the thread is at the front of
-    // writer queue
-    cfd->mem()->ConstructFragmentedRangeTombstones();
   }
+  ROCKS_LOG_INFO(immutable_db_options_.info_log,
+                 "[%s] New memtable created with log file: #%" PRIu64
+                 ". Immutable memtables: %d.\n",
+                 cfd->GetName().c_str(), new_log_number, num_imm_unflushed);
+  // There should be no concurrent write as the thread is at the front of
+  // writer queue
+  cfd->mem()->ConstructFragmentedRangeTombstones();
 
   mutex_.Lock();
   if (recycle_log_number != 0) {
@@ -2327,8 +2272,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
     // We may have lost data from the WritableFileBuffer in-memory buffer for
     // the current log, so treat it as a fatal error and set bg_error
     if (!io_s.ok()) {
-      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable,
-                                /*wal_related=*/true);
+      error_handler_.SetBGError(io_s, BackgroundErrorReason::kMemTable);
     } else {
       error_handler_.SetBGError(s, BackgroundErrorReason::kMemTable);
     }
@@ -2369,8 +2313,8 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
           read_options, write_options, &wal_deletion, &mutex_,
           directories_.GetDbDir());
       if (!s.ok() && versions_->io_status().IsIOError()) {
-        error_handler_.SetBGError(versions_->io_status(),
-                                  BackgroundErrorReason::kManifestWrite);
+        s = error_handler_.SetBGError(versions_->io_status(),
+                                      BackgroundErrorReason::kManifestWrite);
       }
       if (!s.ok()) {
         return s;

db/db_io_failure_test.cc

@@ -705,7 +705,6 @@ class DBIOCorruptionTest
   DBIOCorruptionTest() : DBIOFailureTest() {
     BlockBasedTableOptions bbto;
     options_ = CurrentOptions();
-    options_.statistics = CreateDBStatistics();
 
     base_env_ = env_;
     EXPECT_NE(base_env_, nullptr);
@@ -728,8 +727,6 @@ class DBIOCorruptionTest
 
   Status ReopenDB() { return TryReopen(options_); }
 
-  Statistics* stats() { return options_.statistics.get(); }
-
  protected:
   std::unique_ptr<Env> env_guard_;
   std::shared_ptr<CorruptionFS> fs_;
@@ -752,12 +749,8 @@ TEST_P(DBIOCorruptionTest, GetReadCorruptionRetry) {
   if (std::get<2>(GetParam())) {
     ASSERT_OK(s);
     ASSERT_EQ(val, "val1");
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
   } else {
     ASSERT_TRUE(s.IsCorruption());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
 }
 
@@ -780,12 +773,8 @@ TEST_P(DBIOCorruptionTest, IterReadCorruptionRetry) {
   }
   if (std::get<2>(GetParam())) {
     ASSERT_OK(iter->status());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
   } else {
     ASSERT_TRUE(iter->status().IsCorruption());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
   delete iter;
 }
@@ -810,13 +799,9 @@ TEST_P(DBIOCorruptionTest, MultiGetReadCorruptionRetry) {
   if (std::get<2>(GetParam())) {
     ASSERT_EQ(values[0].ToString(), "val1");
     ASSERT_EQ(values[1].ToString(), "val2");
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
   } else {
     ASSERT_TRUE(statuses[0].IsCorruption());
     ASSERT_TRUE(statuses[1].IsCorruption());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
 }
 
@@ -833,9 +818,6 @@ TEST_P(DBIOCorruptionTest, CompactionReadCorruptionRetry) {
   Status s = dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr);
   if (std::get<2>(GetParam())) {
     ASSERT_OK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
 
     std::string val;
     ReadOptions ro;
@@ -844,7 +826,6 @@ TEST_P(DBIOCorruptionTest, CompactionReadCorruptionRetry) {
     ASSERT_EQ(val, "val1");
   } else {
     ASSERT_TRUE(s.IsCorruption());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
 }
 
@@ -857,9 +838,6 @@ TEST_P(DBIOCorruptionTest, FlushReadCorruptionRetry) {
   Status s = Flush();
   if (std::get<2>(GetParam())) {
     ASSERT_OK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
 
     std::string val;
     ReadOptions ro;
@@ -868,7 +846,6 @@ TEST_P(DBIOCorruptionTest, FlushReadCorruptionRetry) {
     ASSERT_EQ(val, "val1");
   } else {
     ASSERT_NOK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
 }
 
@@ -885,91 +862,12 @@ TEST_P(DBIOCorruptionTest, ManifestCorruptionRetry) {
 
   if (std::get<2>(GetParam())) {
     ASSERT_OK(ReopenDB());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
   } else {
     ASSERT_EQ(ReopenDB(), Status::Corruption());
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
   }
   SyncPoint::GetInstance()->DisableProcessing();
 }
 
-TEST_P(DBIOCorruptionTest, FooterReadCorruptionRetry) {
-  Random rnd(300);
-  bool retry = false;
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "ReadFooterFromFileInternal:0", [&](void* arg) {
-        Slice* data = static_cast<Slice*>(arg);
-        if (!retry) {
-          std::memcpy(const_cast<char*>(data->data()),
-                      rnd.RandomString(static_cast<int>(data->size())).c_str(),
-                      data->size());
-          retry = true;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put("key1", "val1"));
-  Status s = Flush();
-  if (std::get<2>(GetParam())) {
-    ASSERT_OK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
-
-    std::string val;
-    ReadOptions ro;
-    ro.async_io = std::get<1>(GetParam());
-    ASSERT_OK(dbfull()->Get(ro, "key1", &val));
-    ASSERT_EQ(val, "val1");
-  } else {
-    ASSERT_NOK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
-    ASSERT_GT(stats()->getTickerCount(SST_FOOTER_CORRUPTION_COUNT), 0);
-  }
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_P(DBIOCorruptionTest, TablePropertiesCorruptionRetry) {
-  Random rnd(300);
-  bool retry = false;
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "ReadTablePropertiesHelper:0", [&](void* arg) {
-        Slice* data = static_cast<Slice*>(arg);
-        if (!retry) {
-          std::memcpy(const_cast<char*>(data->data()),
-                      rnd.RandomString(static_cast<int>(data->size())).c_str(),
-                      data->size());
-          retry = true;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put("key1", "val1"));
-  Status s = Flush();
-  if (std::get<2>(GetParam())) {
-    ASSERT_OK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 1);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT),
-              1);
-
-    std::string val;
-    ReadOptions ro;
-    ro.async_io = std::get<1>(GetParam());
-    ASSERT_OK(dbfull()->Get(ro, "key1", &val));
-    ASSERT_EQ(val, "val1");
-  } else {
-    ASSERT_NOK(s);
-    ASSERT_EQ(stats()->getTickerCount(FILE_READ_CORRUPTION_RETRY_COUNT), 0);
-  }
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 // The parameters are - 1. Use FS provided buffer, 2. Use async IO ReadOption,
 // 3. Retry with verify_and_reconstruct_read IOOption
 INSTANTIATE_TEST_CASE_P(DBIOCorruptionTest, DBIOCorruptionTest,

db/db_iter.cc

@@ -65,8 +65,9 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
       valid_(false),
       current_entry_is_merged_(false),
       is_key_seqnum_zero_(false),
-      prefix_same_as_start_(
-          prefix_extractor_ ? read_options.prefix_same_as_start : false),
+      prefix_same_as_start_(mutable_cf_options.prefix_extractor
+                                ? read_options.prefix_same_as_start
+                                : false),
       pin_thru_lifetime_(read_options.pin_data),
       expect_total_order_inner_iter_(prefix_extractor_ == nullptr ||
                                      read_options.total_order_seek ||
@@ -92,9 +93,6 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
   status_.PermitUncheckedError();
   assert(timestamp_size_ ==
          user_comparator_.user_comparator()->timestamp_size());
-  // prefix_seek_opt_in_only should force total_order_seek whereever the caller
-  // is duplicating the original ReadOptions
-  assert(!ioptions.prefix_seek_opt_in_only || read_options.total_order_seek);
 }
 
 Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
@@ -111,16 +109,6 @@ Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
       *prop = "Iterator is not valid.";
     }
     return Status::OK();
-  } else if (prop_name == "rocksdb.iterator.is-value-pinned") {
-    if (valid_) {
-      *prop = (pin_thru_lifetime_ && iter_.Valid() &&
-               iter_.value().data() == value_.data())
-                  ? "1"
-                  : "0";
-    } else {
-      *prop = "Iterator is not valid.";
-    }
-    return Status::OK();
   } else if (prop_name == "rocksdb.iterator.internal-key") {
     *prop = saved_key_.GetUserKey().ToString();
     return Status::OK();
@@ -540,8 +528,6 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
     } else {
       iter_.Next();
     }
-    // This could be a long-running operation due to tombstones, etc.
-    ROCKSDB_THREAD_YIELD_HOOK();
   } while (iter_.Valid());
 
   valid_ = false;

db/db_iterator_test.cc

@@ -133,17 +133,11 @@ TEST_P(DBIteratorTest, IteratorProperty) {
     ASSERT_NOK(iter->GetProperty("non_existing.value", &prop_value));
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("0", prop_value);
-    ASSERT_OK(
-        iter->GetProperty("rocksdb.iterator.is-value-pinned", &prop_value));
-    ASSERT_EQ("0", prop_value);
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.internal-key", &prop_value));
     ASSERT_EQ("1", prop_value);
     iter->Next();
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("Iterator is not valid.", prop_value);
-    ASSERT_OK(
-        iter->GetProperty("rocksdb.iterator.is-value-pinned", &prop_value));
-    ASSERT_EQ("Iterator is not valid.", prop_value);
 
     // Get internal key at which the iteration stopped (tombstone in this case).
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.internal-key", &prop_value));
@@ -1686,15 +1680,12 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMultipleFiles) {
   ro.pin_data = true;
   auto iter = NewIterator(ro);
 
-  std::vector<std::pair<Slice, Slice>> results;
+  std::vector<std::pair<Slice, std::string>> results;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     std::string prop_value;
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("1", prop_value);
-    ASSERT_OK(
-        iter->GetProperty("rocksdb.iterator.is-value-pinned", &prop_value));
-    ASSERT_EQ("1", prop_value);
-    results.emplace_back(iter->key(), iter->value());
+    results.emplace_back(iter->key(), iter->value().ToString());
   }
 
   ASSERT_EQ(results.size(), true_data.size());
@@ -1748,9 +1739,6 @@ TEST_P(DBIteratorTest, PinnedDataIteratorMergeOperator) {
     std::string prop_value;
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("1", prop_value);
-    ASSERT_OK(
-        iter->GetProperty("rocksdb.iterator.is-value-pinned", &prop_value));
-    ASSERT_EQ("0", prop_value);
     results.emplace_back(iter->key(), iter->value().ToString());
   }
   ASSERT_OK(iter->status());
@@ -1804,15 +1792,12 @@ TEST_P(DBIteratorTest, PinnedDataIteratorReadAfterUpdate) {
     }
   }
 
-  std::vector<std::pair<Slice, Slice>> results;
+  std::vector<std::pair<Slice, std::string>> results;
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     std::string prop_value;
     ASSERT_OK(iter->GetProperty("rocksdb.iterator.is-key-pinned", &prop_value));
     ASSERT_EQ("1", prop_value);
-    ASSERT_OK(
-        iter->GetProperty("rocksdb.iterator.is-value-pinned", &prop_value));
-    ASSERT_EQ("1", prop_value);
-    results.emplace_back(iter->key(), iter->value());
+    results.emplace_back(iter->key(), iter->value().ToString());
   }
   ASSERT_OK(iter->status());
 

db/db_kv_checksum_test.cc

@@ -684,14 +684,13 @@ class DbMemtableKVChecksumTest : public DbKvChecksumTest {
   DbMemtableKVChecksumTest() : DbKvChecksumTest() {}
 
  protected:
-  const size_t kValueLenOffset = 12;
   // Indices in the memtable entry that we will not corrupt.
   // For memtable entry format, see comments in MemTable::Add().
   // We do not corrupt key length and value length fields in this test
   // case since it causes segfault and ASAN will complain.
   // For this test case, key and value are all of length 3, so
   // key length field is at index 0 and value length field is at index 12.
-  const std::set<size_t> index_not_to_corrupt{0, kValueLenOffset};
+  const std::set<size_t> index_not_to_corrupt{0, 12};
 
   void SkipNotToCorruptEntry() {
     if (index_not_to_corrupt.find(corrupt_byte_offset_) !=
@@ -733,13 +732,11 @@ TEST_P(DbMemtableKVChecksumTest, GetWithCorruptAfterMemtableInsert) {
       });
 
   SyncPoint::GetInstance()->SetCallBack(
-      "Memtable::SaveValue:Found:entry", [&](void* entry) {
+      "Memtable::SaveValue:Begin:entry", [&](void* entry) {
         char* buf = *static_cast<char**>(entry);
         buf[corrupt_byte_offset_] += corrupt_byte_addend_;
         ++corrupt_byte_offset_;
       });
-  // Corrupt value only so that MultiGet below can find the key.
-  corrupt_byte_offset_ = kValueLenOffset + 1;
   SyncPoint::GetInstance()->EnableProcessing();
   Options options = CurrentOptions();
   options.memtable_protection_bytes_per_key =
@@ -748,17 +745,12 @@ TEST_P(DbMemtableKVChecksumTest, GetWithCorruptAfterMemtableInsert) {
     options.merge_operator = MergeOperators::CreateStringAppendOperator();
   }
 
-  std::string key = "key";
   SkipNotToCorruptEntry();
   while (MoreBytesToCorrupt()) {
     Reopen(options);
     ASSERT_OK(ExecuteWrite(nullptr));
     std::string val;
-    ASSERT_TRUE(db_->Get(ReadOptions(), key, &val).IsCorruption());
-    std::vector<std::string> vals = {val};
-    std::vector<Status> statuses = db_->MultiGet(
-        ReadOptions(), {db_->DefaultColumnFamily()}, {key}, &vals, nullptr);
-    ASSERT_TRUE(statuses[0].IsCorruption());
+    ASSERT_TRUE(db_->Get(ReadOptions(), "key", &val).IsCorruption());
     Destroy(options);
     SkipNotToCorruptEntry();
   }
@@ -777,7 +769,7 @@ TEST_P(DbMemtableKVChecksumTest,
       });
 
   SyncPoint::GetInstance()->SetCallBack(
-      "Memtable::SaveValue:Found:entry", [&](void* entry) {
+      "Memtable::SaveValue:Begin:entry", [&](void* entry) {
         char* buf = *static_cast<char**>(entry);
         buf[corrupt_byte_offset_] += corrupt_byte_addend_;
         ++corrupt_byte_offset_;

db/db_memtable_test.cc

@@ -339,91 +339,6 @@ TEST_F(DBMemTableTest, ColumnFamilyId) {
   }
 }
 
-TEST_F(DBMemTableTest, IntegrityChecks) {
-  // We insert keys key000000, key000001 and key000002 into skiplist at fixed
-  // height 1 (smallest height). Then we corrupt the second key to aey000001 to
-  // make it smaller. With `paranoid_memory_checks` set to true, if the
-  // skip list sees key000000 and then aey000001, then it will report out of
-  // order keys with corruption status. With `paranoid_memory_checks` set
-  // to false, read/scan may return wrong results.
-  for (bool allow_data_in_error : {false, true}) {
-    Options options = CurrentOptions();
-    options.allow_data_in_errors = allow_data_in_error;
-    options.paranoid_memory_checks = true;
-    DestroyAndReopen(options);
-    SyncPoint::GetInstance()->SetCallBack(
-        "InlineSkipList::RandomHeight::height", [](void* h) {
-          auto height_ptr = static_cast<int*>(h);
-          *height_ptr = 1;
-        });
-    SyncPoint::GetInstance()->EnableProcessing();
-    ASSERT_OK(Put(Key(0), "val0"));
-    ASSERT_OK(Put(Key(2), "val2"));
-    // p will point to the buffer for encoded key000001
-    char* p = nullptr;
-    SyncPoint::GetInstance()->SetCallBack(
-        "MemTable::Add:BeforeReturn:Encoded", [&](void* encoded) {
-          p = const_cast<char*>(static_cast<Slice*>(encoded)->data());
-        });
-    ASSERT_OK(Put(Key(1), "val1"));
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-    ASSERT_TRUE(p);
-    // Offset 0 is key size, key bytes start at offset 1.
-    // "key000001 -> aey000001"
-    p[1] = 'a';
-
-    ReadOptions rops;
-    std::string val;
-    Status s = db_->Get(rops, Key(1), &val);
-    ASSERT_TRUE(s.IsCorruption());
-    std::string key0 = Slice(Key(0)).ToString(true);
-    ASSERT_EQ(s.ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-    // Without `paranoid_memory_checks`, NotFound will be returned.
-    // This would fail an assertion in InlineSkipList::FindGreaterOrEqual().
-    // If we remove the assertion, this passes.
-    // ASSERT_TRUE(db_->Get(ReadOptions(), Key(1), &val).IsNotFound());
-
-    std::vector<std::string> vals;
-    std::vector<Status> statuses = db_->MultiGet(
-        rops, {db_->DefaultColumnFamily()}, {Key(1)}, &vals, nullptr);
-    ASSERT_TRUE(statuses[0].IsCorruption());
-    ASSERT_EQ(statuses[0].ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-
-    std::unique_ptr<Iterator> iter{db_->NewIterator(rops)};
-    ASSERT_OK(iter->status());
-    iter->Seek(Key(1));
-    ASSERT_TRUE(iter->status().IsCorruption());
-    ASSERT_EQ(iter->status().ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-
-    iter->Seek(Key(0));
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    // iterating through skip list at height at 1 should catch out-of-order keys
-    iter->Next();
-    ASSERT_TRUE(iter->status().IsCorruption());
-    ASSERT_EQ(iter->status().ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-    ASSERT_FALSE(iter->Valid());
-
-    iter->SeekForPrev(Key(2));
-    ASSERT_TRUE(iter->status().IsCorruption());
-    ASSERT_EQ(iter->status().ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-
-    // Internally DB Iter will iterate backwards (call Prev()) after
-    // SeekToLast() to find the correct internal key with the last user key.
-    // Prev() will do integrity checks and catch corruption.
-    iter->SeekToLast();
-    ASSERT_TRUE(iter->status().IsCorruption());
-    ASSERT_EQ(iter->status().ToString().find(key0) != std::string::npos,
-              allow_data_in_error);
-    ASSERT_FALSE(iter->Valid());
-  }
-}
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_properties_test.cc

@@ -192,49 +192,6 @@ TEST_F(DBPropertiesTest, GetAggregatedIntPropertyTest) {
   }
 }
 
-TEST_F(DBPropertiesTest, AggregateBlockCacheProperty) {
-  constexpr size_t kCapacity = 1000;
-  LRUCacheOptions co;
-  co.capacity = kCapacity;
-  co.num_shard_bits = 0;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  auto block_cache = NewLRUCache(co);
-
-  // All columns families share the same block cache.
-  Options options = CurrentOptions();
-  BlockBasedTableOptions table_opt;
-  table_opt.no_block_cache = false;
-  table_opt.block_cache = block_cache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_opt));
-
-  CreateAndReopenWithCF({"one", "two", "three", "four"}, options);
-
-  // Insert unpinned block to the cache
-  constexpr size_t kSize1 = 100;
-  ASSERT_OK(block_cache->Insert("block1", nullptr /*value*/,
-                                &kNoopCacheItemHelper, kSize1));
-  // Insert pinned block to the cache
-  constexpr size_t kSize2 = 200;
-  Cache::Handle* block2 = nullptr;
-  ASSERT_OK(block_cache->Insert("block2", nullptr /*value*/,
-                                &kNoopCacheItemHelper, kSize2, &block2));
-
-  uint64_t value;
-  ASSERT_TRUE(db_->GetAggregatedIntProperty(DB::Properties::kBlockCacheCapacity,
-                                            &value));
-  ASSERT_EQ(value, kCapacity);
-
-  ASSERT_TRUE(
-      db_->GetAggregatedIntProperty(DB::Properties::kBlockCacheUsage, &value));
-  ASSERT_EQ(value, kSize1 + kSize2);
-
-  ASSERT_TRUE(db_->GetAggregatedIntProperty(
-      DB::Properties::kBlockCachePinnedUsage, &value));
-  ASSERT_EQ(value, kSize2);
-
-  block_cache->Release(block2);
-}
-
 namespace {
 void VerifySimilar(uint64_t a, uint64_t b, double bias) {
   ASSERT_EQ(a == 0U, b == 0U);
@@ -1126,6 +1083,7 @@ TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
   ASSERT_GT(CompressionRatioAtLevel(1), 10.0);
 }
 
+
 class CountingUserTblPropCollector : public TablePropertiesCollector {
  public:
   const char* Name() const override { return "CountingUserTblPropCollector"; }
@@ -2408,6 +2366,7 @@ TEST_F(DBPropertiesTest, TableMetaIndexKeys) {
   } while (ChangeOptions());
 }
 
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_range_del_test.cc

@@ -3820,10 +3820,6 @@ TEST_F(DBRangeDelTest, RowCache) {
   ASSERT_OK(wb.DeleteRange(Key(1), Key(5)));
   ASSERT_TRUE(db_->Write(WriteOptions(), &wb).IsNotSupported());
   ASSERT_EQ(Get(Key(3)), "val");
-  // By default, memtable insertion failure will turn the DB to read-only mode.
-  // The check for delete range should happen before that to fail early
-  // and should not turn db into read-only mdoe.
-  ASSERT_OK(Put(Key(5), "foo"));
 }
 }  // namespace ROCKSDB_NAMESPACE
 

db/db_rate_limiter_test.cc

@@ -245,13 +245,7 @@ TEST_P(DBRateLimiterOnReadTest, VerifyChecksum) {
   // In DirectIO, where we support tail prefetching, during table open, we only
   // do 1 read instead of 4 as described above. Actual checksum verification
   // reads stay the same.
-#ifdef OS_WIN
-  // No file system prefetch implemented for OS Win. During table open,
-  // we only do 1 read for BufferedIO.
-  int num_read_per_file = 4;
-#else
   int num_read_per_file = (!use_direct_io_) ? 7 : 4;
-#endif
   int expected = kNumFiles * num_read_per_file;
 
   ASSERT_EQ(expected, options_.rate_limiter->GetTotalRequests(Env::IO_USER));

db/db_secondary_test.cc

@@ -244,7 +244,7 @@ TEST_F(DBSecondaryTest, SimpleInternalCompaction) {
   ASSERT_EQ(largest.user_key().ToString(), "foo");
   ASSERT_EQ(result.output_level, 1);
   ASSERT_EQ(result.output_path, this->secondary_path_);
-  ASSERT_EQ(result.stats.num_output_records, 2);
+  ASSERT_EQ(result.num_output_records, 2);
   ASSERT_GT(result.bytes_written, 0);
   ASSERT_OK(result.status);
 }

db/db_sst_test.cc

@@ -383,16 +383,12 @@ TEST_F(DBSSTTest, DBWithSstFileManager) {
   ASSERT_EQ(files_moved, 0);
 
   Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
   Reopen(options);
   ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
   ASSERT_EQ(sfm->GetTotalSize(), total_files_size);
 
   // Verify that we track all the files again after the DB is closed and opened
   Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
   sst_file_manager.reset(NewSstFileManager(env_));
   options.sst_file_manager = sst_file_manager;
   sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
@@ -443,11 +439,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
       "SstFileManagerImpl::OnMoveFile", [&](void* /*arg*/) { files_moved++; });
-
-  int64_t untracked_files = 0;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::OnUntrackFile",
-      [&](void* /*arg*/) { ++untracked_files; });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
   Options options = CurrentOptions();
@@ -494,10 +485,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
   }
   ASSERT_EQ(sfm->GetTotalSize(), total_files_size);
   Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
 
   Reopen(options);
   ASSERT_EQ(sfm->GetTrackedFiles(), files_in_db);
@@ -505,10 +492,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
 
   // Verify that we track all the files again after the DB is closed and opened.
   Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
 
   sst_file_manager.reset(NewSstFileManager(env_));
   options.sst_file_manager = sst_file_manager;
@@ -524,27 +507,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFiles) {
   ASSERT_EQ(files_deleted, 0);
   ASSERT_EQ(files_scheduled_to_delete, 0);
   Close();
-  ASSERT_EQ(untracked_files, files_in_db.size());
-  untracked_files = 0;
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
-        assert(arg);
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          ++files_scheduled_to_delete;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::OnDeleteFile", [&](void* arg) {
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          files_deleted++;
-        }
-      });
   ASSERT_OK(DestroyDB(dbname_, options));
   ASSERT_EQ(files_deleted, blob_files.size());
   ASSERT_EQ(files_scheduled_to_delete, blob_files.size());
@@ -687,26 +649,6 @@ TEST_F(DBSSTTest, DBWithSstFileManagerForBlobFilesWithGC) {
   }
 
   Close();
-  ASSERT_EQ(sfm->GetTrackedFiles().size(), 0) << "sfm should be empty";
-  ASSERT_EQ(sfm->GetTotalSize(), 0) << "sfm should be empty";
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
-        assert(arg);
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          ++files_scheduled_to_delete;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::OnDeleteFile", [&](void* arg) {
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          files_deleted++;
-        }
-      });
   ASSERT_OK(DestroyDB(dbname_, options));
   sfm->WaitForEmptyTrash();
   ASSERT_EQ(files_deleted, 5);
@@ -941,9 +883,8 @@ TEST_P(DBWALTestWithParam, WALTrashCleanupOnOpen) {
   // Create 4 files in L0
   for (char v = 'a'; v <= 'd'; v++) {
     if (v == 'c') {
-      // Maximize the chance that the last log file will be preserved in trash
-      // before restarting the DB. (Enable slow deletion but at a very slow
-      // deletion rate)
+      // Maximize the change that the last log file will be preserved in trash
+      // before restarting the DB.
       // We have to set this on the 2nd to last file for it to delay deletion
       // on the last file. (Quirk of DeleteScheduler::BackgroundEmptyTrash())
       options.sst_file_manager->SetDeleteRateBytesPerSecond(1);
@@ -1961,24 +1902,6 @@ TEST_F(DBSSTTest, DBWithSFMForBlobFilesAtomicFlush) {
   ASSERT_EQ(files_deleted, 1);
 
   Close();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::ScheduleUnaccountedFileDeletion", [&](void* arg) {
-        assert(arg);
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          ++files_scheduled_to_delete;
-        }
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::OnDeleteFile", [&](void* arg) {
-        const std::string* const file_path =
-            static_cast<const std::string*>(arg);
-        if (EndsWith(*file_path, ".blob")) {
-          files_deleted++;
-        }
-      });
   ASSERT_OK(DestroyDB(dbname_, options));
 
   ASSERT_EQ(files_scheduled_to_delete, 4);

db/db_test.cc

@@ -3844,9 +3844,6 @@ TEST_P(DBTestWithParam, FIFOCompactionTest) {
     } else {
       CompactRangeOptions cro;
       cro.exclusive_manual_compaction = exclusive_manual_compaction_;
-      cro.change_level = true;
-      ASSERT_TRUE(db_->CompactRange(cro, nullptr, nullptr).IsNotSupported());
-      cro.change_level = false;
       ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
     }
     // only 5 files should survive
@@ -4677,27 +4674,24 @@ TEST_F(DBTest, DynamicMemtableOptions) {
 
 #ifdef ROCKSDB_USING_THREAD_STATUS
 namespace {
-bool VerifyOperationCount(Env* env, ThreadStatus::OperationType op_type,
+void VerifyOperationCount(Env* env, ThreadStatus::OperationType op_type,
                           int expected_count) {
   int op_count = 0;
   std::vector<ThreadStatus> thread_list;
-  EXPECT_OK(env->GetThreadList(&thread_list));
+  ASSERT_OK(env->GetThreadList(&thread_list));
   for (const auto& thread : thread_list) {
     if (thread.operation_type == op_type) {
       op_count++;
     }
   }
   if (op_count != expected_count) {
-    fprintf(stderr, "op_count: %d, expected_count %d\n", op_count,
-            expected_count);
     for (const auto& thread : thread_list) {
-      fprintf(stderr, "thread id: %" PRIu64 ", thread status: %s, cf_name %s\n",
+      fprintf(stderr, "thread id: %" PRIu64 ", thread status: %s\n",
               thread.thread_id,
-              thread.GetOperationName(thread.operation_type).c_str(),
-              thread.cf_name.c_str());
+              thread.GetOperationName(thread.operation_type).c_str());
     }
   }
-  return op_count == expected_count;
+  ASSERT_EQ(op_count, expected_count);
 }
 }  // anonymous namespace
 
@@ -4797,11 +4791,11 @@ TEST_F(DBTest, ThreadStatusFlush) {
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
   CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_TRUE(VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0));
+  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);
 
   ASSERT_OK(Put(1, "foo", "v1"));
   ASSERT_EQ("v1", Get(1, "foo"));
-  ASSERT_TRUE(VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0));
+  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 0);
 
   uint64_t num_running_flushes = 0;
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningFlushes,
@@ -4814,7 +4808,7 @@ TEST_F(DBTest, ThreadStatusFlush) {
   // The first sync point is to make sure there's one flush job
   // running when we perform VerifyOperationCount().
   TEST_SYNC_POINT("DBTest::ThreadStatusFlush:1");
-  ASSERT_TRUE(VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 1));
+  VerifyOperationCount(env_, ThreadStatus::OP_FLUSH, 1);
   ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningFlushes,
                                   &num_running_flushes));
   ASSERT_EQ(num_running_flushes, 1);
@@ -4825,11 +4819,17 @@ TEST_F(DBTest, ThreadStatusFlush) {
 }
 
 TEST_P(DBTestWithParam, ThreadStatusSingleCompaction) {
+  const int kTestKeySize = 16;
   const int kTestValueSize = 984;
+  const int kEntrySize = kTestKeySize + kTestValueSize;
   const int kEntriesPerBuffer = 100;
   Options options;
   options.create_if_missing = true;
+  options.write_buffer_size = kEntrySize * kEntriesPerBuffer;
   options.compaction_style = kCompactionStyleLevel;
+  options.target_file_size_base = options.write_buffer_size;
+  options.max_bytes_for_level_base = options.target_file_size_base * 2;
+  options.max_bytes_for_level_multiplier = 2;
   options.compression = kNoCompression;
   options = CurrentOptions(options);
   options.env = env_;
@@ -4864,7 +4864,7 @@ TEST_P(DBTestWithParam, ThreadStatusSingleCompaction) {
                                     &num_running_compactions));
     ASSERT_EQ(num_running_compactions, 0);
     TEST_SYNC_POINT("DBTest::ThreadStatusSingleCompaction:0");
-    ASSERT_EQ(NumTableFilesAtLevel(0),
+    ASSERT_GE(NumTableFilesAtLevel(0),
               options.level0_file_num_compaction_trigger);
 
     // This makes sure at least one compaction is running.
@@ -4872,18 +4872,10 @@ TEST_P(DBTestWithParam, ThreadStatusSingleCompaction) {
 
     if (options.enable_thread_tracking) {
       // expecting one single L0 to L1 compaction
-      // This test is flaky and fails here.
-      bool match = VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 1);
-      if (!match) {
-        ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningCompactions,
-                                        &num_running_compactions));
-        fprintf(stderr, "running compaction: %" PRIu64 " lsm state: %s\n",
-                num_running_compactions, FilesPerLevel().c_str());
-      }
-      ASSERT_TRUE(match);
+      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 1);
     } else {
       // If thread tracking is not enabled, compaction count should be 0.
-      ASSERT_TRUE(VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 0));
+      VerifyOperationCount(env_, ThreadStatus::OP_COMPACTION, 0);
     }
     ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kNumRunningCompactions,
                                     &num_running_compactions));
@@ -5645,8 +5637,6 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {
   ASSERT_EQ(
       dbfull()->GetOptions().compaction_options_universal.allow_trivial_move,
       false);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_read_amp,
-            -1);
 
   ASSERT_OK(dbfull()->SetOptions(
       {{"compaction_options_universal", "{size_ratio=7;}"}}));
@@ -5668,11 +5658,9 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {
   ASSERT_EQ(
       dbfull()->GetOptions().compaction_options_universal.allow_trivial_move,
       false);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_read_amp,
-            -1);
 
-  ASSERT_OK(dbfull()->SetOptions({{"compaction_options_universal",
-                                   "{min_merge_width=11;max_read_amp=0;}"}}));
+  ASSERT_OK(dbfull()->SetOptions(
+      {{"compaction_options_universal", "{min_merge_width=11;}"}}));
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 7u);
   ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.min_merge_width,
             11u);
@@ -5691,8 +5679,6 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {
   ASSERT_EQ(
       dbfull()->GetOptions().compaction_options_universal.allow_trivial_move,
       false);
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_read_amp,
-            0);
 }
 
 TEST_F(DBTest, FileCreationRandomFailure) {
@@ -6353,8 +6339,6 @@ TEST_F(DBTest, PromoteL0) {
   Options options = CurrentOptions();
   options.disable_auto_compactions = true;
   options.write_buffer_size = 10 * 1024 * 1024;
-  // Exercise what was a use-after-free (ASAN failure) under ~VersionSet()
-  options.uncache_aggressiveness = 300;
   DestroyAndReopen(options);
 
   // non overlapping ranges

db/db_test2.cc

@@ -10,7 +10,6 @@
 #include <atomic>
 #include <cstdlib>
 #include <functional>
-#include <iostream>
 #include <memory>
 
 #include "db/db_test_util.h"
@@ -27,7 +26,6 @@
 #include "rocksdb/utilities/replayer.h"
 #include "rocksdb/wal_filter.h"
 #include "test_util/testutil.h"
-#include "util/defer.h"
 #include "util/random.h"
 #include "utilities/fault_injection_env.h"
 
@@ -4156,7 +4154,7 @@ TEST_F(DBTest2, LiveFilesOmitObsoleteFiles) {
   TEST_SYNC_POINT("DBTest2::LiveFilesOmitObsoleteFiles:FlushTriggered");
 
   ASSERT_OK(db_->DisableFileDeletions());
-  VectorWalPtr log_files;
+  VectorLogPtr log_files;
   ASSERT_OK(db_->GetSortedWalFiles(log_files));
   TEST_SYNC_POINT("DBTest2::LiveFilesOmitObsoleteFiles:LiveFilesCaptured");
   for (const auto& log_file : log_files) {
@@ -5597,45 +5595,32 @@ TEST_F(DBTest2, PrefixBloomFilteredOut) {
   bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
   bbto.whole_key_filtering = false;
   options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  DestroyAndReopen(options);
 
-  // This test is also the primary test for prefix_seek_opt_in_only
-  for (bool opt_in : {false, true}) {
-    options.prefix_seek_opt_in_only = opt_in;
-    DestroyAndReopen(options);
+  // Construct two L1 files with keys:
+  // f1:[aaa1 ccc1] f2:[ddd0]
+  ASSERT_OK(Put("aaa1", ""));
+  ASSERT_OK(Put("ccc1", ""));
+  ASSERT_OK(Flush());
+  ASSERT_OK(Put("ddd0", ""));
+  ASSERT_OK(Flush());
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
 
-    // Construct two L1 files with keys:
-    // f1:[aaa1 ccc1] f2:[ddd0]
-    ASSERT_OK(Put("aaa1", ""));
-    ASSERT_OK(Put("ccc1", ""));
-    ASSERT_OK(Flush());
-    ASSERT_OK(Put("ddd0", ""));
-    ASSERT_OK(Flush());
-    CompactRangeOptions cro;
-    cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
-    ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  Iterator* iter = db_->NewIterator(ReadOptions());
+  ASSERT_OK(iter->status());
 
-    ReadOptions ropts;
-    for (bool same : {false, true}) {
-      ropts.prefix_same_as_start = same;
-      std::unique_ptr<Iterator> iter(db_->NewIterator(ropts));
-      ASSERT_OK(iter->status());
+  // Bloom filter is filterd out by f1.
+  // This is just one of several valid position following the contract.
+  // Postioning to ccc1 or ddd0 is also valid. This is just to validate
+  // the behavior of the current implementation. If underlying implementation
+  // changes, the test might fail here.
+  iter->Seek("bbb1");
+  ASSERT_OK(iter->status());
+  ASSERT_FALSE(iter->Valid());
 
-      iter->Seek("bbb1");
-      ASSERT_OK(iter->status());
-      if (opt_in && !same) {
-        // Unbounded total order seek
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key(), "ccc1");
-      } else {
-        // Bloom filter is filterd out by f1. When same == false, this is just
-        // one valid position following the contract. Postioning to ccc1 or ddd0
-        // is also valid. This is just to validate the behavior of the current
-        // implementation. If underlying implementation changes, the test might
-        // fail here.
-        ASSERT_FALSE(iter->Valid());
-      }
-    }
-  }
+  delete iter;
 }
 
 TEST_F(DBTest2, RowCacheSnapshot) {
@@ -6000,7 +5985,6 @@ TEST_F(DBTest2, ChangePrefixExtractor) {
     // create a DB with block prefix index
     BlockBasedTableOptions table_options;
     Options options = CurrentOptions();
-    options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
 
     // Sometimes filter is checked based on upper bound. Assert counters
     // for that case. Otherwise, only check data correctness.
@@ -6560,235 +6544,6 @@ TEST_P(RenameCurrentTest, Compaction) {
   ASSERT_EQ("d_value", Get("d"));
 }
 
-TEST_F(DBTest2, VariousFileTemperatures) {
-  constexpr size_t kNumberFileTypes = static_cast<size_t>(kBlobFile) + 1U;
-
-  struct MyTestFS : public FileTemperatureTestFS {
-    explicit MyTestFS(const std::shared_ptr<FileSystem>& fs)
-        : FileTemperatureTestFS(fs) {
-      Reset();
-    }
-
-    IOStatus NewWritableFile(const std::string& fname, const FileOptions& opts,
-                             std::unique_ptr<FSWritableFile>* result,
-                             IODebugContext* dbg) override {
-      IOStatus ios =
-          FileTemperatureTestFS::NewWritableFile(fname, opts, result, dbg);
-      if (ios.ok()) {
-        uint64_t number;
-        FileType type;
-        if (ParseFileName(GetFileName(fname), &number, "LOG", &type)) {
-          if (type == kTableFile) {
-            // Not checked here
-          } else if (type == kWalFile) {
-            if (opts.temperature != expected_wal_temperature) {
-              std::cerr << "Attempt to open " << fname << " with temperature "
-                        << temperature_to_string[opts.temperature]
-                        << " rather than "
-                        << temperature_to_string[expected_wal_temperature]
-                        << std::endl;
-              assert(false);
-            }
-          } else if (type == kDescriptorFile) {
-            if (opts.temperature != expected_manifest_temperature) {
-              std::cerr << "Attempt to open " << fname << " with temperature "
-                        << temperature_to_string[opts.temperature]
-                        << " rather than "
-                        << temperature_to_string[expected_wal_temperature]
-                        << std::endl;
-              assert(false);
-            }
-          } else if (opts.temperature != expected_other_metadata_temperature) {
-            std::cerr << "Attempt to open " << fname << " with temperature "
-                      << temperature_to_string[opts.temperature]
-                      << " rather than "
-                      << temperature_to_string[expected_wal_temperature]
-                      << std::endl;
-            assert(false);
-          }
-          UpdateCount(type, 1);
-        }
-      }
-      return ios;
-    }
-
-    IOStatus RenameFile(const std::string& src, const std::string& dst,
-                        const IOOptions& options,
-                        IODebugContext* dbg) override {
-      IOStatus ios = FileTemperatureTestFS::RenameFile(src, dst, options, dbg);
-      if (ios.ok()) {
-        uint64_t number;
-        FileType src_type;
-        FileType dst_type;
-        assert(ParseFileName(GetFileName(src), &number, "LOG", &src_type));
-        assert(ParseFileName(GetFileName(dst), &number, "LOG", &dst_type));
-
-        UpdateCount(src_type, -1);
-        UpdateCount(dst_type, 1);
-      }
-      return ios;
-    }
-
-    void UpdateCount(FileType type, int delta) {
-      size_t i = static_cast<size_t>(type);
-      assert(i < kNumberFileTypes);
-      counts[i].FetchAddRelaxed(delta);
-    }
-
-    std::map<FileType, size_t> PopCounts() {
-      std::map<FileType, size_t> ret;
-      for (size_t i = 0; i < kNumberFileTypes; ++i) {
-        int c = counts[i].ExchangeRelaxed(0);
-        if (c > 0) {
-          ret[static_cast<FileType>(i)] = c;
-        }
-      }
-      return ret;
-    }
-
-    FileOptions OptimizeForLogWrite(
-        const FileOptions& file_options,
-        const DBOptions& /*db_options*/) const override {
-      FileOptions opts = file_options;
-      if (optimize_wal_temperature != Temperature::kUnknown) {
-        opts.temperature = optimize_wal_temperature;
-      }
-      return opts;
-    }
-
-    FileOptions OptimizeForManifestWrite(
-        const FileOptions& file_options) const override {
-      FileOptions opts = file_options;
-      if (optimize_manifest_temperature != Temperature::kUnknown) {
-        opts.temperature = optimize_manifest_temperature;
-      }
-      return opts;
-    }
-
-    void Reset() {
-      optimize_manifest_temperature = Temperature::kUnknown;
-      optimize_wal_temperature = Temperature::kUnknown;
-      expected_manifest_temperature = Temperature::kUnknown;
-      expected_other_metadata_temperature = Temperature::kUnknown;
-      expected_wal_temperature = Temperature::kUnknown;
-      for (auto& c : counts) {
-        c.StoreRelaxed(0);
-      }
-    }
-
-    Temperature optimize_manifest_temperature;
-    Temperature optimize_wal_temperature;
-    Temperature expected_manifest_temperature;
-    Temperature expected_other_metadata_temperature;
-    Temperature expected_wal_temperature;
-    std::array<RelaxedAtomic<int>, kNumberFileTypes> counts;
-  };
-
-  // We don't have enough non-unknown temps to confidently distinguish that
-  // a specific setting caused a specific outcome, in a single run. This is a
-  // reasonable work-around without blowing up test time. Only returns
-  // non-unknown temperatures.
-  auto RandomTemp = [] {
-    static std::vector<Temperature> temps = {
-        Temperature::kHot, Temperature::kWarm, Temperature::kCold};
-    return temps[Random::GetTLSInstance()->Uniform(
-        static_cast<int>(temps.size()))];
-  };
-
-  auto test_fs = std::make_shared<MyTestFS>(env_->GetFileSystem());
-  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, test_fs));
-  for (bool use_optimize : {false, true}) {
-    std::cerr << "use_optimize: " << std::to_string(use_optimize) << std::endl;
-    for (bool use_temp_options : {false, true}) {
-      std::cerr << "use_temp_options: " << std::to_string(use_temp_options)
-                << std::endl;
-
-      Options options = CurrentOptions();
-      // Currently require for last level temperature
-      options.compaction_style = kCompactionStyleUniversal;
-      options.env = env.get();
-      test_fs->Reset();
-      if (use_optimize) {
-        test_fs->optimize_manifest_temperature = RandomTemp();
-        test_fs->expected_manifest_temperature =
-            test_fs->optimize_manifest_temperature;
-        test_fs->optimize_wal_temperature = RandomTemp();
-        test_fs->expected_wal_temperature = test_fs->optimize_wal_temperature;
-      }
-      if (use_temp_options) {
-        options.metadata_write_temperature = RandomTemp();
-        test_fs->expected_manifest_temperature =
-            options.metadata_write_temperature;
-        test_fs->expected_other_metadata_temperature =
-            options.metadata_write_temperature;
-        options.wal_write_temperature = RandomTemp();
-        test_fs->expected_wal_temperature = options.wal_write_temperature;
-        options.last_level_temperature = RandomTemp();
-        options.default_write_temperature = RandomTemp();
-      }
-
-      DestroyAndReopen(options);
-      Defer closer([&] { Close(); });
-
-      using FTC = std::map<FileType, size_t>;
-      // Files on DB startup
-      ASSERT_EQ(test_fs->PopCounts(), FTC({{kWalFile, 1},
-                                           {kDescriptorFile, 2},
-                                           {kCurrentFile, 2},
-                                           {kIdentityFile, 1},
-                                           {kOptionsFile, 1}}));
-
-      // Temperature count map
-      using TCM = std::map<Temperature, size_t>;
-      ASSERT_EQ(test_fs->CountCurrentSstFilesByTemp(), TCM({}));
-
-      ASSERT_OK(Put("foo", "1"));
-      ASSERT_OK(Put("bar", "1"));
-      ASSERT_OK(Flush());
-      ASSERT_OK(Put("foo", "2"));
-      ASSERT_OK(Put("bar", "2"));
-      ASSERT_OK(Flush());
-
-      ASSERT_EQ(test_fs->CountCurrentSstFilesByTemp(),
-                TCM({{options.default_write_temperature, 2}}));
-
-      ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-      ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
-
-      ASSERT_EQ(test_fs->CountCurrentSstFilesByTemp(),
-                TCM({{options.last_level_temperature, 1}}));
-
-      ASSERT_OK(Put("foo", "3"));
-      ASSERT_OK(Put("bar", "3"));
-      ASSERT_OK(Flush());
-
-      // Just in memtable/WAL
-      ASSERT_OK(Put("dog", "3"));
-
-      {
-        TCM expected;
-        expected[options.default_write_temperature] += 1;
-        expected[options.last_level_temperature] += 1;
-        ASSERT_EQ(test_fs->CountCurrentSstFilesByTemp(), expected);
-      }
-
-      // New files during operation
-      ASSERT_EQ(test_fs->PopCounts(), FTC({{kWalFile, 3}, {kTableFile, 4}}));
-
-      Reopen(options);
-
-      // New files during re-open/recovery
-      ASSERT_EQ(test_fs->PopCounts(), FTC({{kWalFile, 1},
-                                           {kTableFile, 1},
-                                           {kDescriptorFile, 1},
-                                           {kCurrentFile, 1},
-                                           {kOptionsFile, 1}}));
-
-      Destroy(options);
-    }
-  }
-}
-
 TEST_F(DBTest2, LastLevelTemperature) {
   class TestListener : public EventListener {
    public:

db/db_test_util.cc

@@ -366,11 +366,6 @@ Options DBTestBase::GetOptions(
     table_options.block_cache = NewLRUCache(/* too small */ 1);
   }
 
-  // Test anticipated new default as much as reasonably possible (and remove
-  // this code when obsolete)
-  assert(!table_options.decouple_partitioned_filters);
-  table_options.decouple_partitioned_filters = true;
-
   bool can_allow_mmap = IsMemoryMappedAccessSupported();
   switch (option_config) {
     case kHashSkipList:
@@ -570,11 +565,6 @@ Options DBTestBase::GetOptions(
       options.unordered_write = false;
       break;
     }
-    case kBlockBasedTableWithBinarySearchWithFirstKeyIndex: {
-      table_options.index_type =
-          BlockBasedTableOptions::kBinarySearchWithFirstKey;
-      break;
-    }
 
     default:
       break;

db/db_test_util.h

@@ -276,16 +276,16 @@ class SpecialEnv : public EnvWrapper {
       SpecialEnv* env_;
       std::unique_ptr<WritableFile> base_;
     };
-    class SpecialWalFile : public WritableFile {
+    class WalFile : public WritableFile {
      public:
-      SpecialWalFile(SpecialEnv* env, std::unique_ptr<WritableFile>&& b)
+      WalFile(SpecialEnv* env, std::unique_ptr<WritableFile>&& b)
           : env_(env), base_(std::move(b)) {
         env_->num_open_wal_file_.fetch_add(1);
       }
-      virtual ~SpecialWalFile() { env_->num_open_wal_file_.fetch_add(-1); }
+      virtual ~WalFile() { env_->num_open_wal_file_.fetch_add(-1); }
       Status Append(const Slice& data) override {
 #if !(defined NDEBUG) || !defined(OS_WIN)
-        TEST_SYNC_POINT("SpecialEnv::SpecialWalFile::Append:1");
+        TEST_SYNC_POINT("SpecialEnv::WalFile::Append:1");
 #endif
         Status s;
         if (env_->log_write_error_.load(std::memory_order_acquire)) {
@@ -299,7 +299,7 @@ class SpecialEnv : public EnvWrapper {
           s = base_->Append(data);
         }
 #if !(defined NDEBUG) || !defined(OS_WIN)
-        TEST_SYNC_POINT("SpecialEnv::SpecialWalFile::Append:2");
+        TEST_SYNC_POINT("SpecialEnv::WalFile::Append:2");
 #endif
         return s;
       }
@@ -419,7 +419,7 @@ class SpecialEnv : public EnvWrapper {
       } else if (strstr(f.c_str(), "MANIFEST") != nullptr) {
         r->reset(new ManifestFile(this, std::move(*r)));
       } else if (strstr(f.c_str(), "log") != nullptr) {
-        r->reset(new SpecialWalFile(this, std::move(*r)));
+        r->reset(new WalFile(this, std::move(*r)));
       } else {
         r->reset(new OtherFile(this, std::move(*r)));
       }
@@ -831,15 +831,6 @@ class FileTemperatureTestFS : public FileSystemWrapper {
     return count;
   }
 
-  std::map<Temperature, size_t> CountCurrentSstFilesByTemp() {
-    MutexLock lock(&mu_);
-    std::map<Temperature, size_t> ret;
-    for (const auto& e : current_sst_file_temperatures_) {
-      ret[e.second]++;
-    }
-    return ret;
-  }
-
   void OverrideSstFileTemperature(uint64_t number, Temperature temp) {
     MutexLock lock(&mu_);
     current_sst_file_temperatures_[number] = temp;
@@ -851,7 +842,7 @@ class FileTemperatureTestFS : public FileSystemWrapper {
       requested_sst_file_temperatures_;
   std::map<uint64_t, Temperature> current_sst_file_temperatures_;
 
-  static std::string GetFileName(const std::string& fname) {
+  std::string GetFileName(const std::string& fname) {
     auto filename = fname.substr(fname.find_last_of(kFilePathSeparator) + 1);
     // workaround only for Windows that the file path could contain both Windows
     // FilePathSeparator and '/'
@@ -1050,7 +1041,6 @@ class DBTestBase : public testing::Test {
     kPartitionedFilterWithNewTableReaderForCompactions,
     kUniversalSubcompactions,
     kUnorderedWrite,
-    kBlockBasedTableWithBinarySearchWithFirstKeyIndex,
     // This must be the last line
     kEnd,
   };

db/db_universal_compaction_test.cc

@@ -213,6 +213,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrigger) {
   options.num_levels = num_levels_;
   options.write_buffer_size = 105 << 10;  // 105KB
   options.arena_block_size = 4 << 10;
+  options.target_file_size_base = 32 << 10;  // 32KB
   // trigger compaction if there are >= 4 files
   options.level0_file_num_compaction_trigger = 4;
   KeepFilterFactory* filter = new KeepFilterFactory(true);

db/db_wal_test.cc

@@ -14,7 +14,6 @@
 #include "port/stack_trace.h"
 #include "rocksdb/file_system.h"
 #include "test_util/sync_point.h"
-#include "util/defer.h"
 #include "util/udt_util.h"
 #include "utilities/fault_injection_env.h"
 #include "utilities/fault_injection_fs.h"
@@ -271,10 +270,8 @@ TEST_F(DBWALTest, SyncWALNotWaitWrite) {
   ASSERT_OK(Put("foo3", "bar3"));
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency({
-      {"SpecialEnv::SpecialWalFile::Append:1",
-       "DBWALTest::SyncWALNotWaitWrite:1"},
-      {"DBWALTest::SyncWALNotWaitWrite:2",
-       "SpecialEnv::SpecialWalFile::Append:2"},
+      {"SpecialEnv::WalFile::Append:1", "DBWALTest::SyncWALNotWaitWrite:1"},
+      {"DBWALTest::SyncWALNotWaitWrite:2", "SpecialEnv::WalFile::Append:2"},
   });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
@@ -1472,213 +1469,6 @@ TEST_F(DBWALTest, SyncMultipleLogs) {
   ASSERT_OK(dbfull()->SyncWAL());
 }
 
-TEST_F(DBWALTest, DISABLED_RecycleMultipleWalsCrash) {
-  Options options = CurrentOptions();
-  options.max_write_buffer_number = 5;
-  options.track_and_verify_wals_in_manifest = true;
-  options.max_bgerror_resume_count = 0;  // manual resume
-  options.recycle_log_file_num = 3;
-  options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
-
-  // Disable truncating recycled WALs to new size in posix env
-  // (approximating a crash)
-  SyncPoint::GetInstance()->SetCallBack(
-      "PosixWritableFile::Close",
-      [](void* arg) { *(static_cast<size_t*>(arg)) = 0; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Re-open with desired options
-  DestroyAndReopen(options);
-  Defer closer([this]() { Close(); });
-
-  // Ensure WAL recycling wasn't sanitized away
-  ASSERT_EQ(db_->GetOptions().recycle_log_file_num,
-            options.recycle_log_file_num);
-
-  // Prepare external files for later ingestion
-  std::string sst_files_dir = dbname_ + "/sst_files/";
-  ASSERT_OK(DestroyDir(env_, sst_files_dir));
-  ASSERT_OK(env_->CreateDir(sst_files_dir));
-  std::string external_file1 = sst_files_dir + "file1.sst";
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    ASSERT_OK(sst_file_writer.Open(external_file1));
-    ASSERT_OK(sst_file_writer.Put("external1", "ex1"));
-    ExternalSstFileInfo file_info;
-    ASSERT_OK(sst_file_writer.Finish(&file_info));
-  }
-  std::string external_file2 = sst_files_dir + "file2.sst";
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    ASSERT_OK(sst_file_writer.Open(external_file2));
-    ASSERT_OK(sst_file_writer.Put("external2", "ex2"));
-    ExternalSstFileInfo file_info;
-    ASSERT_OK(sst_file_writer.Finish(&file_info));
-  }
-
-  // Populate some WALs to be recycled such that there will be extra data
-  // from an old incarnation of the WAL on recovery
-  ASSERT_OK(db_->PauseBackgroundWork());
-  ASSERT_OK(Put("ignore1", Random::GetTLSInstance()->RandomString(500)));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  ASSERT_OK(Put("ignore2", Random::GetTLSInstance()->RandomString(500)));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  ASSERT_OK(db_->ContinueBackgroundWork());
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("ignore3", Random::GetTLSInstance()->RandomString(500)));
-  ASSERT_OK(Flush());
-
-  // Verify expected log files (still there for recycling)
-  std::vector<FileAttributes> files;
-  int log_count = 0;
-  ASSERT_OK(options.env->GetChildrenFileAttributes(dbname_, &files));
-  for (const auto& f : files) {
-    if (EndsWith(f.name, ".log")) {
-      EXPECT_GT(f.size_bytes, 500);
-      ++log_count;
-    }
-  }
-  EXPECT_EQ(log_count, 3);
-
-  // (Re-used recipe) Generate two inactive WALs and one active WAL, with a
-  // gap in sequence numbers to interfere with recovery
-  ASSERT_OK(db_->PauseBackgroundWork());
-  ASSERT_OK(Put("key1", "val1"));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  ASSERT_OK(Put("key2", "val2"));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  // Need a gap in sequence numbers, so e.g. ingest external file
-  // with an open snapshot
-  {
-    ManagedSnapshot snapshot(db_);
-    ASSERT_OK(
-        db_->IngestExternalFile({external_file1}, IngestExternalFileOptions()));
-  }
-  ASSERT_OK(Put("key3", "val3"));
-  ASSERT_OK(db_->SyncWAL());
-  // Need an SST file that is logically after that WAL, so that dropping WAL
-  // data is not a valid point in time.
-  {
-    ManagedSnapshot snapshot(db_);
-    ASSERT_OK(
-        db_->IngestExternalFile({external_file2}, IngestExternalFileOptions()));
-  }
-
-  // Approximate a crash, with respect to recycled WAL data extending past
-  // the end of the current WAL data (see SyncPoint callback above)
-  Close();
-
-  // Verify recycled log files haven't been truncated
-  files.clear();
-  log_count = 0;
-  ASSERT_OK(options.env->GetChildrenFileAttributes(dbname_, &files));
-  for (const auto& f : files) {
-    if (EndsWith(f.name, ".log")) {
-      EXPECT_GT(f.size_bytes, 500);
-      ++log_count;
-    }
-  }
-  EXPECT_EQ(log_count, 3);
-
-  // Verify no data loss after reopen.
-  Reopen(options);
-  EXPECT_EQ("val1", Get("key1"));
-  EXPECT_EQ("val2", Get("key2"));  // Passes because of adjacent seqnos
-  EXPECT_EQ("ex1", Get("external1"));
-  EXPECT_EQ("val3", Get("key3"));  // <- ONLY FAILURE! (Not a point in time)
-  EXPECT_EQ("ex2", Get("external2"));
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(DBWALTest, SyncWalPartialFailure) {
-  class MyTestFileSystem : public FileSystemWrapper {
-   public:
-    explicit MyTestFileSystem(std::shared_ptr<FileSystem> base)
-        : FileSystemWrapper(std::move(base)) {}
-
-    static const char* kClassName() { return "MyTestFileSystem"; }
-    const char* Name() const override { return kClassName(); }
-    IOStatus NewWritableFile(const std::string& fname,
-                             const FileOptions& file_opts,
-                             std::unique_ptr<FSWritableFile>* result,
-                             IODebugContext* dbg) override {
-      IOStatus s = target()->NewWritableFile(fname, file_opts, result, dbg);
-      if (s.ok()) {
-        *result =
-            std::make_unique<MyTestWritableFile>(std::move(*result), *this);
-      }
-      return s;
-    }
-
-    AcqRelAtomic<uint32_t> syncs_before_failure_{UINT32_MAX};
-
-   protected:
-    class MyTestWritableFile : public FSWritableFileOwnerWrapper {
-     public:
-      MyTestWritableFile(std::unique_ptr<FSWritableFile>&& file,
-                         MyTestFileSystem& fs)
-          : FSWritableFileOwnerWrapper(std::move(file)), fs_(fs) {}
-
-      IOStatus Sync(const IOOptions& options, IODebugContext* dbg) override {
-        int prev_val = fs_.syncs_before_failure_.FetchSub(1);
-        if (prev_val == 0) {
-          return IOStatus::IOError("fault");
-        } else {
-          return target()->Sync(options, dbg);
-        }
-      }
-
-     protected:
-      MyTestFileSystem& fs_;
-    };
-  };
-
-  Options options = CurrentOptions();
-  options.max_write_buffer_number = 4;
-  options.track_and_verify_wals_in_manifest = true;
-  options.max_bgerror_resume_count = 0;  // manual resume
-
-  auto custom_fs =
-      std::make_shared<MyTestFileSystem>(options.env->GetFileSystem());
-  std::unique_ptr<Env> fault_fs_env(NewCompositeEnv(custom_fs));
-  options.env = fault_fs_env.get();
-  Reopen(options);
-  Defer closer([this]() { Close(); });
-
-  // This is the simplest way to get
-  // * one inactive WAL, synced
-  // * one inactive WAL, not synced, and
-  // * one active WAL, not synced
-  // with a single thread, to exercise as much logic as we reasonably can.
-  ASSERT_OK(db_->PauseBackgroundWork());
-  ASSERT_OK(Put("key1", "val1"));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  ASSERT_OK(db_->SyncWAL());
-  ASSERT_OK(Put("key2", "val2"));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable());
-  ASSERT_OK(Put("key3", "val3"));
-
-  // Allow 1 of the WALs to sync, but another won't
-  custom_fs->syncs_before_failure_.Store(1);
-  ASSERT_NOK(db_->SyncWAL());
-
-  // Stuck in this state. (This could previously cause a segfault.)
-  ASSERT_NOK(db_->SyncWAL());
-
-  // Can't Resume because WAL write failure is considered non-recoverable,
-  // regardless of the IOStatus itself. (Can/should be fixed?)
-  ASSERT_NOK(db_->Resume());
-
-  // Verify no data loss after reopen.
-  // Also Close() could previously crash in this state.
-  Reopen(options);
-  ASSERT_EQ("val1", Get("key1"));
-  ASSERT_EQ("val2", Get("key2"));
-  ASSERT_EQ("val3", Get("key3"));
-}
-
 // Github issue 1339. Prior the fix we read sequence id from the first log to
 // a local variable, then keep increase the variable as we replay logs,
 // ignoring actual sequence id of the records. This is incorrect if some writes
@@ -2877,83 +2667,6 @@ TEST_F(DBWALTest, EmptyWalReopenTest) {
   }
 }
 
-TEST_F(DBWALTest, RecoveryFlushSwitchWALOnEmptyMemtable) {
-  Options options = CurrentOptions();
-  auto fault_fs = std::make_shared<FaultInjectionTestFS>(FileSystem::Default());
-  std::unique_ptr<Env> fault_fs_env(NewCompositeEnv(fault_fs));
-  options.env = fault_fs_env.get();
-  options.avoid_flush_during_shutdown = true;
-  DestroyAndReopen(options);
-
-  // Make sure the memtable switch in recovery flush happened after test checks
-  // the memtable is empty.
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBWALTest.RecoveryFlushSwitchWALOnEmptyMemtable:"
-        "AfterCheckMemtableEmpty",
-        "RecoverFromRetryableBGIOError:BeforeStart"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-  fault_fs->SetThreadLocalErrorContext(
-      FaultInjectionIOType::kMetadataWrite, 7 /* seed*/, 1 /* one_in */,
-      true /* retryable */, false /* has_data_loss*/);
-  fault_fs->EnableThreadLocalErrorInjection(
-      FaultInjectionIOType::kMetadataWrite);
-
-  WriteOptions wo;
-  wo.sync = true;
-  Status s = Put("k", "old_v", wo);
-  ASSERT_TRUE(s.IsIOError());
-  // To verify the key is not in memtable nor SST
-  ASSERT_TRUE(static_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
-                  ->cfd()
-                  ->mem()
-                  ->IsEmpty());
-  ASSERT_EQ("NOT_FOUND", Get("k"));
-  TEST_SYNC_POINT(
-      "DBWALTest.RecoveryFlushSwitchWALOnEmptyMemtable:"
-      "AfterCheckMemtableEmpty");
-  SyncPoint::GetInstance()->DisableProcessing();
-
-  fault_fs->DisableThreadLocalErrorInjection(
-      FaultInjectionIOType::kMetadataWrite);
-
-  // Keep trying write until recovery of the previous IO error finishes
-  while (!s.ok()) {
-    options.env->SleepForMicroseconds(1000);
-    s = Put("k", "new_v");
-  }
-
-  // If recovery flush didn't switch WAL, we will end up having two duplicate
-  // WAL entries with same seqno and same key that violate assertion during WAL
-  // recovery and fail DB reopen
-  options.avoid_flush_during_recovery = false;
-  Reopen(options);
-
-  ASSERT_EQ("new_v", Get("k"));
-  Destroy(options);
-}
-
-TEST_F(DBWALTest, WALWriteErrorNoRecovery) {
-  Options options = CurrentOptions();
-  auto fault_fs = std::make_shared<FaultInjectionTestFS>(FileSystem::Default());
-  std::unique_ptr<Env> fault_fs_env(NewCompositeEnv(fault_fs));
-  options.env = fault_fs_env.get();
-  options.manual_wal_flush = true;
-  DestroyAndReopen(options);
-  fault_fs->SetThreadLocalErrorContext(
-      FaultInjectionIOType::kWrite, 7 /* seed*/, 1 /* one_in */,
-      true /* retryable */, false /* has_data_loss*/);
-  fault_fs->EnableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
-
-  ASSERT_OK(Put("k", "v"));
-  Status s;
-  s = db_->FlushWAL(false);
-  ASSERT_TRUE(s.IsIOError());
-  s = dbfull()->TEST_GetBGError();
-  ASSERT_EQ(s.severity(), Status::Severity::kFatalError);
-  ASSERT_FALSE(dbfull()->TEST_IsRecoveryInProgress());
-  fault_fs->DisableThreadLocalErrorInjection(FaultInjectionIOType::kWrite);
-  Destroy(options);
-}
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/db_with_timestamp_basic_test.cc

@@ -172,70 +172,6 @@ TEST_F(DBBasicTestWithTimestamp, MixedCfs) {
   Close();
 }
 
-TEST_F(DBBasicTestWithTimestamp, MultiGetMultipleCfs) {
-  const size_t kTimestampSize = Timestamp(0, 0).size();
-  TestComparator test_cmp(kTimestampSize);
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.avoid_flush_during_shutdown = true;
-  options.comparator = &test_cmp;
-  DestroyAndReopen(options);
-
-  Options options1 = CurrentOptions();
-  options1.env = env_;
-  options1.comparator = &test_cmp;
-  ColumnFamilyHandle* handle = nullptr;
-  Status s = db_->CreateColumnFamily(options1, "data", &handle);
-  ASSERT_OK(s);
-
-  std::string ts = Timestamp(1, 0);
-  WriteBatch wb(0, 0, 0, kTimestampSize);
-  ASSERT_OK(wb.Put("a", "value"));
-  ASSERT_OK(wb.Put(handle, "a", "value"));
-  const auto ts_sz_func = [kTimestampSize](uint32_t /*cf_id*/) {
-    return kTimestampSize;
-  };
-  ASSERT_OK(wb.UpdateTimestamps(ts, ts_sz_func));
-  ASSERT_OK(db_->Write(WriteOptions(), &wb));
-
-  int num_keys = 2;
-  std::vector<Slice> keys;
-  std::vector<std::string> expected_values;
-  for (int i = 0; i < num_keys; i++) {
-    keys.push_back("a");
-    expected_values.push_back("value");
-  }
-  std::vector<ColumnFamilyHandle*> handles;
-  handles.push_back(db_->DefaultColumnFamily());
-  handles.push_back(handle);
-
-  {
-    Slice read_ts_slice(ts);
-    ReadOptions read_opts;
-    read_opts.timestamp = &read_ts_slice;
-
-    std::vector<PinnableSlice> values;
-    values.resize(num_keys);
-    std::vector<Status> statuses;
-    statuses.resize(num_keys);
-    std::vector<std::string> timestamps;
-    timestamps.resize(num_keys);
-
-    db_->MultiGet(read_opts, num_keys, handles.data(), keys.data(),
-                  values.data(), timestamps.data(), statuses.data());
-
-    for (int i = 0; i < num_keys; i++) {
-      ASSERT_OK(statuses[i]);
-      ASSERT_EQ(expected_values[i], values[i].ToString());
-      ASSERT_EQ(ts, timestamps[i]);
-    }
-  }
-
-  delete handle;
-  Close();
-}
-
 TEST_F(DBBasicTestWithTimestamp, CompactRangeWithSpecifiedRange) {
   Options options = CurrentOptions();
   options.env = env_;
@@ -832,7 +768,6 @@ TEST_P(DBBasicTestWithTimestampTableOptions, GetAndMultiGet) {
 
 TEST_P(DBBasicTestWithTimestampTableOptions, SeekWithPrefixLessThanKey) {
   Options options = CurrentOptions();
-  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
   options.env = env_;
   options.create_if_missing = true;
   options.prefix_extractor.reset(NewFixedPrefixTransform(3));
@@ -1010,7 +945,6 @@ TEST_F(DBBasicTestWithTimestamp, ChangeIterationDirection) {
   TestComparator test_cmp(kTimestampSize);
   options.comparator = &test_cmp;
   options.prefix_extractor.reset(NewFixedPrefixTransform(1));
-  options.prefix_seek_opt_in_only = false;  // Use legacy prefix seek
   options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
   DestroyAndReopen(options);
   const std::vector<std::string> timestamps = {Timestamp(1, 1), Timestamp(0, 2),

db/db_write_test.cc

@@ -666,25 +666,11 @@ TEST_P(DBWriteTest, LockWALInEffect) {
   // try the 1st WAL created during open
   ASSERT_OK(Put("key0", "value"));
   ASSERT_NE(options.manual_wal_flush, dbfull()->WALBufferIsEmpty());
-
   ASSERT_OK(db_->LockWAL());
-
   ASSERT_TRUE(dbfull()->WALBufferIsEmpty());
-  uint64_t wal_num = dbfull()->TEST_GetCurrentLogNumber();
-  // Manual flush with wait=false should abruptly fail with TryAgain
-  FlushOptions flush_opts;
-  flush_opts.wait = false;
-  for (bool allow_write_stall : {true, false}) {
-    flush_opts.allow_write_stall = allow_write_stall;
-    ASSERT_TRUE(db_->Flush(flush_opts).IsTryAgain());
-  }
-  ASSERT_EQ(wal_num, dbfull()->TEST_GetCurrentLogNumber());
-
   ASSERT_OK(db_->UnlockWAL());
-
-  // try the 2nd wal created during SwitchWAL (not locked this time)
+  // try the 2nd wal created during SwitchWAL
   ASSERT_OK(dbfull()->TEST_SwitchWAL());
-  ASSERT_NE(wal_num, dbfull()->TEST_GetCurrentLogNumber());
   ASSERT_OK(Put("key1", "value"));
   ASSERT_NE(options.manual_wal_flush, dbfull()->WALBufferIsEmpty());
   ASSERT_OK(db_->LockWAL());
@@ -723,57 +709,21 @@ TEST_P(DBWriteTest, LockWALInEffect) {
 }
 
 TEST_P(DBWriteTest, LockWALConcurrentRecursive) {
-  // This is a micro-stress test of LockWAL and concurrency handling.
-  // It is considered the most convenient way to balance functional
-  // coverage and reproducibility (vs. the two extremes of (a) unit tests
-  // tailored to specific interleavings and (b) db_stress)
   Options options = GetOptions();
   Reopen(options);
-  ASSERT_OK(Put("k1", "k1_orig"));
+  ASSERT_OK(Put("k1", "val"));
   ASSERT_OK(db_->LockWAL());  // 0 -> 1
   auto frozen_seqno = db_->GetLatestSequenceNumber();
-
-  std::string ingest_file = dbname_ + "/external.sst";
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    ASSERT_OK(sst_file_writer.Open(ingest_file));
-    ASSERT_OK(sst_file_writer.Put("k2", "k2_val"));
-    ExternalSstFileInfo external_info;
-    ASSERT_OK(sst_file_writer.Finish(&external_info));
-  }
-  AcqRelAtomic<bool> parallel_ingest_completed{false};
-  port::Thread parallel_ingest{[&]() {
-    IngestExternalFileOptions ingest_opts;
-    ingest_opts.move_files = true;  // faster than copy
-    // Shouldn't finish until WAL unlocked
-    ASSERT_OK(db_->IngestExternalFile({ingest_file}, ingest_opts));
-    parallel_ingest_completed.Store(true);
-  }};
-
-  AcqRelAtomic<bool> flush_completed{false};
-  port::Thread parallel_flush{[&]() {
-    FlushOptions flush_opts;
-    // NB: Flush with wait=false case is tested above in LockWALInEffect
-    flush_opts.wait = true;
-    // allow_write_stall = true blocks in fewer cases
-    flush_opts.allow_write_stall = true;
-    // Shouldn't finish until WAL unlocked
-    ASSERT_OK(db_->Flush(flush_opts));
-    flush_completed.Store(true);
-  }};
-
-  AcqRelAtomic<bool> parallel_put_completed{false};
-  port::Thread parallel_put{[&]() {
-    // This can make certain failure scenarios more likely:
-    //   sleep(1);
-    // Shouldn't finish until WAL unlocked
-    ASSERT_OK(Put("k1", "k1_mod"));
-    parallel_put_completed.Store(true);
+  std::atomic<bool> t1_completed{false};
+  port::Thread t1{[&]() {
+    // Won't finish until WAL unlocked
+    ASSERT_OK(Put("k1", "val2"));
+    t1_completed = true;
   }};
 
   ASSERT_OK(db_->LockWAL());  // 1 -> 2
   // Read-only ops are OK
-  ASSERT_EQ(Get("k1"), "k1_orig");
+  ASSERT_EQ(Get("k1"), "val");
   {
     std::vector<LiveFileStorageInfo> files;
     LiveFilesStorageInfoOptions lf_opts;
@@ -782,35 +732,29 @@ TEST_P(DBWriteTest, LockWALConcurrentRecursive) {
     ASSERT_OK(db_->GetLiveFilesStorageInfo({lf_opts}, &files));
   }
 
-  port::Thread parallel_lock_wal{[&]() {
+  port::Thread t2{[&]() {
     ASSERT_OK(db_->LockWAL());  // 2 -> 3 or 1 -> 2
   }};
 
   ASSERT_OK(db_->UnlockWAL());  // 2 -> 1 or 3 -> 2
-  // Give parallel_put an extra chance to jump in case of bug
+  // Give t1 an extra chance to jump in case of bug
   std::this_thread::yield();
-  parallel_lock_wal.join();
-  ASSERT_FALSE(parallel_put_completed.Load());
-  ASSERT_FALSE(parallel_ingest_completed.Load());
-  ASSERT_FALSE(flush_completed.Load());
+  t2.join();
+  ASSERT_FALSE(t1_completed.load());
 
   // Should now have 2 outstanding LockWAL
-  ASSERT_EQ(Get("k1"), "k1_orig");
+  ASSERT_EQ(Get("k1"), "val");
 
   ASSERT_OK(db_->UnlockWAL());  // 2 -> 1
 
-  ASSERT_FALSE(parallel_put_completed.Load());
-  ASSERT_FALSE(parallel_ingest_completed.Load());
-  ASSERT_FALSE(flush_completed.Load());
-
-  ASSERT_EQ(Get("k1"), "k1_orig");
-  ASSERT_EQ(Get("k2"), "NOT_FOUND");
+  ASSERT_FALSE(t1_completed.load());
+  ASSERT_EQ(Get("k1"), "val");
   ASSERT_EQ(frozen_seqno, db_->GetLatestSequenceNumber());
 
   // Ensure final Unlock is concurrency safe and extra Unlock is safe but
   // non-OK
   std::atomic<int> unlock_ok{0};
-  port::Thread parallel_stuff{[&]() {
+  port::Thread t3{[&]() {
     if (db_->UnlockWAL().ok()) {
       unlock_ok++;
     }
@@ -823,23 +767,18 @@ TEST_P(DBWriteTest, LockWALConcurrentRecursive) {
   if (db_->UnlockWAL().ok()) {
     unlock_ok++;
   }
-  parallel_stuff.join();
+  t3.join();
 
   // There was one extra unlock, so just one non-ok
   ASSERT_EQ(unlock_ok.load(), 2);
 
   // Write can proceed
-  parallel_put.join();
-  ASSERT_TRUE(parallel_put_completed.Load());
-  ASSERT_EQ(Get("k1"), "k1_mod");
-  parallel_ingest.join();
-  ASSERT_TRUE(parallel_ingest_completed.Load());
-  ASSERT_EQ(Get("k2"), "k2_val");
-  parallel_flush.join();
-  ASSERT_TRUE(flush_completed.Load());
+  t1.join();
+  ASSERT_TRUE(t1_completed.load());
+  ASSERT_EQ(Get("k1"), "val2");
   // And new writes
-  ASSERT_OK(Put("k3", "val"));
-  ASSERT_EQ(Get("k3"), "val");
+  ASSERT_OK(Put("k2", "val"));
+  ASSERT_EQ(Get("k2"), "val");
 }
 
 TEST_P(DBWriteTest, ConcurrentlyDisabledWAL) {

db/dbformat.cc

@@ -47,8 +47,6 @@ EntryType GetEntryType(ValueType value_type) {
       return kEntryBlobIndex;
     case kTypeWideColumnEntity:
       return kEntryWideColumnEntity;
-    case kTypeValuePreferredSeqno:
-      return kEntryTimedPut;
     default:
       return kEntryOther;
   }
@@ -157,23 +155,10 @@ void ReplaceInternalKeyWithMinTimestamp(std::string* result, const Slice& key,
   result->append(key.data() + key_sz - kNumInternalBytes, kNumInternalBytes);
 }
 
-std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex,
-                                           const Comparator* ucmp) const {
+std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex) const {
   std::string result = "'";
-  size_t ts_sz_for_debug = ucmp == nullptr ? 0 : ucmp->timestamp_size();
   if (log_err_key) {
-    if (ts_sz_for_debug == 0) {
-      result += user_key.ToString(hex);
-    } else {
-      assert(user_key.size() >= ts_sz_for_debug);
-      Slice user_key_without_ts = user_key;
-      user_key_without_ts.remove_suffix(ts_sz_for_debug);
-      result += user_key_without_ts.ToString(hex);
-      Slice ts = Slice(user_key.data() + user_key.size() - ts_sz_for_debug,
-                       ts_sz_for_debug);
-      result += "|timestamp:";
-      result += ucmp->TimestampToString(ts);
-    }
+    result += user_key.ToString(hex);
   } else {
     result += "<redacted>";
   }
@@ -186,11 +171,11 @@ std::string ParsedInternalKey::DebugString(bool log_err_key, bool hex,
   return result;
 }
 
-std::string InternalKey::DebugString(bool hex, const Comparator* ucmp) const {
+std::string InternalKey::DebugString(bool hex) const {
   std::string result;
   ParsedInternalKey parsed;
   if (ParseInternalKey(rep_, &parsed, false /* log_err_key */).ok()) {
-    result = parsed.DebugString(true /* log_err_key */, hex, ucmp);  // TODO
+    result = parsed.DebugString(true /* log_err_key */, hex);  // TODO
   } else {
     result = "(bad)";
     result.append(EscapeString(rep_));

db/dbformat.h

@@ -148,8 +148,7 @@ struct ParsedInternalKey {
   // u contains timestamp if user timestamp feature is enabled.
   ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
       : user_key(u), sequence(seq), type(t) {}
-  std::string DebugString(bool log_err_key, bool hex,
-                          const Comparator* ucmp = nullptr) const;
+  std::string DebugString(bool log_err_key, bool hex) const;
 
   void clear() {
     user_key.clear();
@@ -330,16 +329,17 @@ inline Slice ExtractUserKey(const Slice& internal_key) {
 // output              : <user_provided_key>
 inline Slice ExtractUserKeyAndStripTimestamp(const Slice& internal_key,
                                              size_t ts_sz) {
-  assert(internal_key.size() >= kNumInternalBytes + ts_sz);
-  return Slice(internal_key.data(),
-               internal_key.size() - (kNumInternalBytes + ts_sz));
+  Slice ret = internal_key;
+  ret.remove_suffix(kNumInternalBytes + ts_sz);
+  return ret;
 }
 
 // input [user key]: <user_provided_key | ts>
 // output:           <user_provided_key>
 inline Slice StripTimestampFromUserKey(const Slice& user_key, size_t ts_sz) {
-  assert(user_key.size() >= ts_sz);
-  return Slice(user_key.data(), user_key.size() - ts_sz);
+  Slice ret = user_key;
+  ret.remove_suffix(ts_sz);
+  return ret;
 }
 
 // input [user key]: <user_provided_key | ts>
@@ -503,7 +503,7 @@ class InternalKey {
     AppendInternalKeyFooter(&rep_, s, t);
   }
 
-  std::string DebugString(bool hex, const Comparator* ucmp = nullptr) const;
+  std::string DebugString(bool hex) const;
 };
 
 inline int InternalKeyComparator::Compare(const InternalKey& a,

db/dbformat_test.cc

@@ -23,17 +23,17 @@ static std::string IKey(const std::string& user_key, uint64_t seq,
 }
 
 static std::string Shorten(const std::string& s, const std::string& l) {
-  std::string scratch;
-  return ShortenedIndexBuilder::FindShortestInternalKeySeparator(
-             *BytewiseComparator(), s, l, &scratch)
-      .ToString();
+  std::string result = s;
+  ShortenedIndexBuilder::FindShortestInternalKeySeparator(*BytewiseComparator(),
+                                                          &result, l);
+  return result;
 }
 
 static std::string ShortSuccessor(const std::string& s) {
-  std::string scratch;
-  return ShortenedIndexBuilder::FindShortInternalKeySuccessor(
-             *BytewiseComparator(), s, &scratch)
-      .ToString();
+  std::string result = s;
+  ShortenedIndexBuilder::FindShortInternalKeySuccessor(*BytewiseComparator(),
+                                                       &result);
+  return result;
 }
 
 static void TestKey(const std::string& key, uint64_t seq, ValueType vt) {

db/error_handler.cc

@@ -250,6 +250,8 @@ void ErrorHandler::CancelErrorRecovery() {
   EndAutoRecovery();
 }
 
+STATIC_AVOID_DESTRUCTION(const Status, kOkStatus){Status::OK()};
+
 // This is the main function for looking at an error during a background
 // operation and deciding the severity, and error recovery strategy. The high
 // level algorithm is as follows -
@@ -268,11 +270,11 @@ void ErrorHandler::CancelErrorRecovery() {
 // This can also get called as part of a recovery operation. In that case, we
 // also track the error separately in recovery_error_ so we can tell in the
 // end whether recovery succeeded or not
-void ErrorHandler::HandleKnownErrors(const Status& bg_err,
-                                     BackgroundErrorReason reason) {
+const Status& ErrorHandler::HandleKnownErrors(const Status& bg_err,
+                                              BackgroundErrorReason reason) {
   db_mutex_->AssertHeld();
   if (bg_err.ok()) {
-    return;
+    return kOkStatus;
   }
 
   ROCKS_LOG_INFO(db_options_.info_log,
@@ -337,7 +339,7 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
     } else {
       // This error is less severe than previously encountered error. Don't
       // take any further action
-      return;
+      return bg_error_;
     }
   }
 
@@ -354,6 +356,7 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
   if (bg_error_.severity() >= Status::Severity::kHardError) {
     is_db_stopped_.store(true, std::memory_order_release);
   }
+  return bg_error_;
 }
 
 // This is the main function for looking at IO related error during the
@@ -380,17 +383,17 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
 // 3) for other cases, HandleKnownErrors(const Status& bg_err,
 //    BackgroundErrorReason reason) will be called to handle other error cases
 //    such as delegating to SstFileManager to handle no space error.
-void ErrorHandler::SetBGError(const Status& bg_status,
-                              BackgroundErrorReason reason, bool wal_related) {
+const Status& ErrorHandler::SetBGError(const Status& bg_status,
+                                       BackgroundErrorReason reason) {
   db_mutex_->AssertHeld();
   Status tmp_status = bg_status;
   IOStatus bg_io_err = status_to_io_status(std::move(tmp_status));
 
   if (bg_io_err.ok()) {
-    return;
+    return kOkStatus;
   }
-  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s, reason %d",
-                 bg_io_err.ToString().c_str(), static_cast<int>(reason));
+  ROCKS_LOG_WARN(db_options_.info_log, "Background IO error %s",
+                 bg_io_err.ToString().c_str());
 
   RecordStats({ERROR_HANDLER_BG_ERROR_COUNT, ERROR_HANDLER_BG_IO_ERROR_COUNT},
               {} /* int_histograms */);
@@ -410,36 +413,11 @@ void ErrorHandler::SetBGError(const Status& bg_status,
     EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
                                           &bg_err, db_mutex_, &auto_recovery);
     recover_context_ = context;
-    return;
-  }
-  if (wal_related) {
-    assert(reason == BackgroundErrorReason::kWriteCallback ||
-           reason == BackgroundErrorReason::kMemTable ||
-           reason == BackgroundErrorReason::kFlush);
-  }
-  if (db_options_.manual_wal_flush && wal_related && bg_io_err.IsIOError()) {
-    // With manual_wal_flush, a WAL write failure can drop buffered WAL writes.
-    // Memtables and WAL then become inconsistent. A successful memtable flush
-    // on one CF can cause CFs to be inconsistent upon restart. Before we fix
-    // the bug in auto recovery from WAL write failures that can flush one CF
-    // at a time, we set the error severity to fatal to disallow auto recovery.
-    // TODO: remove parameter `wal_related` once we can automatically recover
-    //  from WAL write failures.
-    bool auto_recovery = false;
-    Status bg_err(new_bg_io_err, Status::Severity::kFatalError);
-    CheckAndSetRecoveryAndBGError(bg_err);
-    ROCKS_LOG_WARN(db_options_.info_log,
-                   "ErrorHandler: A potentially WAL error happened, set "
-                   "background IO error as fatal error\n");
-    EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
-                                          &bg_err, db_mutex_, &auto_recovery);
-    recover_context_ = context;
-    return;
-  }
-
-  if (bg_io_err.subcode() != IOStatus::SubCode::kNoSpace &&
-      (bg_io_err.GetScope() == IOStatus::IOErrorScope::kIOErrorScopeFile ||
-       bg_io_err.GetRetryable())) {
+    return bg_error_;
+  } else if (bg_io_err.subcode() != IOStatus::SubCode::kNoSpace &&
+             (bg_io_err.GetScope() ==
+                  IOStatus::IOErrorScope::kIOErrorScopeFile ||
+              bg_io_err.GetRetryable())) {
     // Second, check if the error is a retryable IO error (file scope IO error
     // is also treated as retryable IO error in RocksDB write path). if it is
     // retryable error and its severity is higher than bg_error_, overwrite the
@@ -448,6 +426,10 @@ void ErrorHandler::SetBGError(const Status& bg_status,
     // IO error as hard error. Note that, all the NoSpace error should be
     // handled by the SstFileManager::StartErrorRecovery(). Therefore, no matter
     // it is retryable or file scope, this logic will be bypassed.
+    bool auto_recovery = false;
+    EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
+                                          &new_bg_io_err, db_mutex_,
+                                          &auto_recovery);
 
     RecordStats({ERROR_HANDLER_BG_RETRYABLE_IO_ERROR_COUNT},
                 {} /* int_histograms */);
@@ -463,13 +445,9 @@ void ErrorHandler::SetBGError(const Status& bg_status,
       ROCKS_LOG_INFO(
           db_options_.info_log,
           "ErrorHandler: Compaction will schedule by itself to resume\n");
-      bool auto_recovery = false;
-      EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
-                                            &new_bg_io_err, db_mutex_,
-                                            &auto_recovery);
       // Not used in this code path.
       new_bg_io_err.PermitUncheckedError();
-      return;
+      return bg_error_;
     }
 
     Status::Severity severity;
@@ -491,14 +469,10 @@ void ErrorHandler::SetBGError(const Status& bg_status,
     Status bg_err(new_bg_io_err, severity);
     CheckAndSetRecoveryAndBGError(bg_err);
     recover_context_ = context;
-    bool auto_recovery = db_options_.max_bgerror_resume_count > 0;
-    EventHelpers::NotifyOnBackgroundError(db_options_.listeners, reason,
-                                          &new_bg_io_err, db_mutex_,
-                                          &auto_recovery);
-    StartRecoverFromRetryableBGIOError(bg_io_err);
-    return;
+    return StartRecoverFromRetryableBGIOError(bg_io_err);
+  } else {
+    return HandleKnownErrors(new_bg_io_err, reason);
   }
-  HandleKnownErrors(new_bg_io_err, reason);
 }
 
 void ErrorHandler::AddFilesToQuarantine(
@@ -646,23 +620,23 @@ Status ErrorHandler::RecoverFromBGError(bool is_manual) {
   return s;
 }
 
-void ErrorHandler::StartRecoverFromRetryableBGIOError(
+const Status& ErrorHandler::StartRecoverFromRetryableBGIOError(
     const IOStatus& io_error) {
   db_mutex_->AssertHeld();
-  if (bg_error_.ok() || io_error.ok()) {
-    return;
-  }
-  if (db_options_.max_bgerror_resume_count <= 0 || recovery_in_prog_) {
-    // Auto resume BG error is not enabled
-    return;
-  }
-  if (end_recovery_) {
+  if (bg_error_.ok()) {
+    return bg_error_;
+  } else if (io_error.ok()) {
+    return kOkStatus;
+  } else if (db_options_.max_bgerror_resume_count <= 0 || recovery_in_prog_) {
+    // Auto resume BG error is not enabled, directly return bg_error_.
+    return bg_error_;
+  } else if (end_recovery_) {
     // Can temporarily release db mutex
     EventHelpers::NotifyOnErrorRecoveryEnd(db_options_.listeners, bg_error_,
                                            Status::ShutdownInProgress(),
                                            db_mutex_);
     db_mutex_->AssertHeld();
-    return;
+    return bg_error_;
   }
   RecordStats({ERROR_HANDLER_AUTORESUME_COUNT}, {} /* int_histograms */);
   ROCKS_LOG_INFO(
@@ -690,6 +664,12 @@ void ErrorHandler::StartRecoverFromRetryableBGIOError(
 
   recovery_thread_.reset(
       new port::Thread(&ErrorHandler::RecoverFromRetryableBGIOError, this));
+
+  if (recovery_error_.ok()) {
+    return recovery_error_;
+  } else {
+    return bg_error_;
+  }
 }
 
 // Automatic recover from Retryable BG IO error. Must be called after db

db/error_handler.h

@@ -56,8 +56,7 @@ class ErrorHandler {
   Status::Severity GetErrorSeverity(BackgroundErrorReason reason,
                                     Status::Code code, Status::SubCode subcode);
 
-  void SetBGError(const Status& bg_err, BackgroundErrorReason reason,
-                  bool wal_related = false);
+  const Status& SetBGError(const Status& bg_err, BackgroundErrorReason reason);
 
   Status GetBGError() const { return bg_error_; }
 
@@ -136,10 +135,11 @@ class ErrorHandler {
   // unsorted.
   autovector<uint64_t> files_to_quarantine_;
 
-  void HandleKnownErrors(const Status& bg_err, BackgroundErrorReason reason);
+  const Status& HandleKnownErrors(const Status& bg_err,
+                                  BackgroundErrorReason reason);
   Status OverrideNoSpaceError(const Status& bg_error, bool* auto_recovery);
   void RecoverFromNoSpace();
-  void StartRecoverFromRetryableBGIOError(const IOStatus& io_error);
+  const Status& StartRecoverFromRetryableBGIOError(const IOStatus& io_error);
   void RecoverFromRetryableBGIOError();
   // First, if it is in recovery and the recovery_error is ok. Set the
   // recovery_error_ to bg_err. Second, if the severity is higher than the