set ignore_unknown_options when parsing options (#13443 )

Summary: In case the primary host has a new option added which isn't available in the remote worker yet, the remote compaction currently fails. In most cases, these new options are not relevant to the remote compaction and the worker should be able to move on by ignoring it. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13443 Test Plan: Verified internally in Meta Infra. Reviewed By: anand1976 Differential Revision: D70744359 Pulled By: jaykorean fbshipit-source-id: eb6a388c2358a7f8089f2e35a378b7017b9e03f3
Fix version numbering from 10.1.0 to 10.0.1
2026-11-07 03:22:34 -05:00 · 2025-03-06 17:32:20 -08:00 · 2025-03-06 09:53:11 -08:00 · 2025-03-06 09:51:05 -08:00 · 2025-03-06 09:48:17 -08:00 · 2025-03-06 09:48:05 -08:00
366 changed files with 7953 additions and 23000 deletions
@@ -4,8 +4,8 @@ runs:
  steps:
  - name: Install Maven
    run: |
-      wget --no-check-certificate https://archive.apache.org/dist/maven/maven-3/3.9.11/binaries/apache-maven-3.9.11-bin.tar.gz
-      tar zxf apache-maven-3.9.11-bin.tar.gz
-      echo "export M2_HOME=$(pwd)/apache-maven-3.9.11" >> $GITHUB_ENV
-      echo "$(pwd)/apache-maven-3.9.11/bin" >> $GITHUB_PATH
+      wget --no-check-certificate https://dlcdn.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz
+      tar zxf apache-maven-3.9.6-bin.tar.gz
+      echo "export M2_HOME=$(pwd)/apache-maven-3.9.6" >> $GITHUB_ENV
+      echo "$(pwd)/apache-maven-3.9.6/bin" >> $GITHUB_PATH
    shell: bash
@@ -11,9 +11,9 @@ runs:
      CMAKE_BIN: C:/Program Files/CMake/bin/cmake.exe
      CTEST_BIN: C:/Program Files/CMake/bin/ctest.exe
      JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8
-      SNAPPY_HOME: ${{ github.workspace }}/thirdparty/snappy-1.2.2
-      SNAPPY_INCLUDE: ${{ github.workspace }}/thirdparty/snappy-1.2.2;${{ github.workspace }}/thirdparty/snappy-1.2.2/build
-      SNAPPY_LIB_DEBUG: ${{ github.workspace }}/thirdparty/snappy-1.2.2/build/Debug/snappy.lib
+      SNAPPY_HOME: ${{ github.workspace }}/thirdparty/snappy-1.1.8
+      SNAPPY_INCLUDE: ${{ github.workspace }}/thirdparty/snappy-1.1.8;${{ github.workspace }}/thirdparty/snappy-1.1.8/build
+      SNAPPY_LIB_DEBUG: ${{ github.workspace }}/thirdparty/snappy-1.1.8/build/Debug/snappy.lib
    run: |-
      # NOTE: if ... Exit $LASTEXITCODE lines needed to exit and report failure
      echo ===================== Install Dependencies =====================
@@ -22,14 +22,14 @@ runs:
      mkdir $Env:THIRDPARTY_HOME
      cd $Env:THIRDPARTY_HOME
      echo "Building Snappy dependency..."
-      curl -Lo snappy-1.2.2.zip https://github.com/google/snappy/archive/refs/tags/1.2.2.zip
+      curl -Lo snappy-1.1.8.zip https://github.com/google/snappy/archive/refs/tags/1.1.8.zip
      if(!$?) { Exit $LASTEXITCODE }
-      unzip -q snappy-1.2.2.zip
+      unzip -q snappy-1.1.8.zip
      if(!$?) { Exit $LASTEXITCODE }
-      cd snappy-1.2.2
+      cd snappy-1.1.8
      mkdir build
      cd build
-      & cmake -G "$Env:CMAKE_GENERATOR" .. -DSNAPPY_BUILD_TESTS=OFF -DSNAPPY_BUILD_BENCHMARKS=OFF
+      & cmake -G "$Env:CMAKE_GENERATOR" ..
      if(!$?) { Exit $LASTEXITCODE }
      msbuild Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
      if(!$?) { Exit $LASTEXITCODE }
@@ -38,7 +38,7 @@ runs:
      $env:Path = $env:JAVA_HOME + ";" + $env:Path
      mkdir build
      cd build
-      & cmake -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DXPRESS=1 -DJNI=1 ..
+      & cmake -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 ..
      if(!$?) { Exit $LASTEXITCODE }
      cd ..
      echo "Building with VS version: $Env:CMAKE_GENERATOR"
@@ -27,6 +27,18 @@ jobs:
        git config --global --add safe.directory /__w/rocksdb/rocksdb
        tools/check_format_compatible.sh
    - uses: "./.github/actions/post-steps"
+  build-linux-run-microbench:
+    if: ${{ github.repository_owner == 'facebook' }}
+    runs-on:
+      labels: 16-core-ubuntu
+    container:
+      image: zjay437/rocksdb:0.6
+      options: --shm-size=16gb
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/pre-steps"
+    - run: DEBUG_LEVEL=0 make -j32 run_microbench
+    - uses: "./.github/actions/post-steps"
  build-linux-non-shm:
    if: ${{ github.repository_owner == 'facebook' }}
    runs-on:
@@ -79,6 +91,15 @@ jobs:
    steps:
    - uses: actions/checkout@v4.1.0
    - uses: "./.github/actions/windows-build-steps"
+  build-windows-vs2022:
+    if: ${{ github.repository_owner == 'facebook' }}
+    runs-on: windows-2022
+    env:
+      CMAKE_GENERATOR: Visual Studio 17 2022
+      CMAKE_PORTABLE: 1
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/windows-build-steps"
  build-linux-arm-test-full:
    if: ${{ github.repository_owner == 'facebook' }}
    runs-on:
@@ -89,59 +110,3 @@ jobs:
      - run: sudo apt-get update && sudo apt-get install -y build-essential libgflags-dev
      - run: make V=1 J=4 -j4 check
      - uses: "./.github/actions/post-steps"
-  build-examples:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - name: Build examples
-      run: make V=1 -j4 static_lib && cd examples && make V=1 -j4
-    - uses: "./.github/actions/post-steps"
-  build-fuzzers:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - name: Build rocksdb lib
-      run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j4 static_lib
-    - name: Build fuzzers
-      run: cd fuzz && make sst_file_writer_fuzzer db_fuzzer db_map_fuzzer
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-11-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: LIB_MODE=static CC=gcc-11 CXX=g++-11 V=1 make -j32 all microbench
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-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: "(mkdir build && cd build && cmake -DUSE_FOLLY_LITE=1 -DWITH_GFLAGS=1 .. && make V=1 -j20)"
-    - uses: "./.github/actions/post-steps"
@@ -52,14 +52,6 @@ jobs:
      run: make check-buck-targets
    - name: Simple source code checks
      run: make check-sources
-    - name: Sanity check check_format_compatible.sh
-      run: |-
-        export TEST_TMPDIR=/dev/shm/rocksdb
-        rm -rf /dev/shm/rocksdb
-        mkdir /dev/shm/rocksdb
-        git reset --hard
-        git config --global --add safe.directory /__w/rocksdb/rocksdb
-        SANITY_CHECK=1 LONG_TEST=1 tools/check_format_compatible.sh
  # ========================= Linux With Tests ======================== #
  build-linux:
    if: ${{ github.repository_owner == 'facebook' }}
@@ -109,6 +101,22 @@ jobs:
    - uses: "./.github/actions/build-folly"
    - run: "(mkdir build && cd build && cmake -DUSE_FOLLY=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 .. && make V=1 -j20 && ctest -j20)"
    - uses: "./.github/actions/post-steps"
+  build-linux-cmake-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: "(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:
    if: ${{ github.repository_owner == 'facebook' }}
    runs-on:
@@ -182,7 +190,7 @@ jobs:
    - uses: actions/checkout@v4.1.0
    - uses: "./.github/actions/pre-steps"
    - run: ENCRYPTED_ENV=1 ROCKSDB_DISABLE_SNAPPY=1 ROCKSDB_DISABLE_ZLIB=1 ROCKSDB_DISABLE_BZIP=1 ROCKSDB_DISABLE_LZ4=1 ROCKSDB_DISABLE_ZSTD=1 make V=1 J=32 -j32 check
-    - run: "./sst_dump --help | grep -E -q 'Supported built-in compression types: kNoCompression$' # Verify no compiled in compression\n"
+    - run: "./sst_dump --help | grep -E -q 'Supported compression types: kNoCompression$' # Verify no compiled in compression\n"
    - uses: "./.github/actions/post-steps"
  # ======================== Linux No Test Runs ======================= #
  build-linux-release:
@@ -226,6 +234,34 @@ jobs:
    - run: apt-get remove -y libgflags-dev
    - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
    - run: if ./db_stress --version; then false; else true; fi
+  build-examples:
+    if: ${{ github.repository_owner == 'facebook' }}
+    runs-on:
+      labels: 4-core-ubuntu
+    container:
+      image: zjay437/rocksdb:0.6
+      options: --shm-size=16gb
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/pre-steps"
+    - name: Build examples
+      run: make V=1 -j4 static_lib && cd examples && make V=1 -j4
+    - uses: "./.github/actions/post-steps"
+  build-fuzzers:
+    if: ${{ github.repository_owner == 'facebook' }}
+    runs-on:
+      labels: 4-core-ubuntu
+    container:
+      image: zjay437/rocksdb:0.6
+      options: --shm-size=16gb
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/pre-steps"
+    - name: Build rocksdb lib
+      run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j4 static_lib
+    - name: Build fuzzers
+      run: cd fuzz && make sst_file_writer_fuzzer db_fuzzer db_map_fuzzer
+    - uses: "./.github/actions/post-steps"
  build-linux-clang-no_test_run:
    if: ${{ github.repository_owner == 'facebook' }}
    runs-on:
@@ -273,7 +309,18 @@ jobs:
    - uses: "./.github/actions/pre-steps"
    - run: CC=gcc-10 CXX=g++-10 V=1 ROCKSDB_CXX_STANDARD=c++20 make -j32 all
    - uses: "./.github/actions/post-steps"
-
+  build-linux-gcc-11-no_test_run:
+    if: ${{ github.repository_owner == 'facebook' }}
+    runs-on:
+      labels: 16-core-ubuntu
+    container:
+      image: zjay437/rocksdb:0.6
+      options: --shm-size=16gb
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/pre-steps"
+    - run: LIB_MODE=static CC=gcc-11 CXX=g++-11 V=1 make -j32 all microbench
+    - uses: "./.github/actions/post-steps"
  # ======================== Linux Other Checks ======================= #
  build-linux-clang10-clang-analyze:
    if: ${{ github.repository_owner == 'facebook' }}
@@ -414,11 +461,11 @@ jobs:
    - uses: "./.github/actions/post-steps"
  # ======================== Windows with Tests ======================= #
  # NOTE: some windows jobs are in "nightly" to save resources
-  build-windows-vs2022:
+  build-windows-vs2019:
    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: windows-2022
+    runs-on: windows-2019
    env:
-      CMAKE_GENERATOR: Visual Studio 17 2022
+      CMAKE_GENERATOR: Visual Studio 16 2019
      CMAKE_PORTABLE: 1
    steps:
    - uses: actions/checkout@v4.1.0
@@ -429,7 +476,7 @@ jobs:
    runs-on:
      labels: 4-core-ubuntu
    container:
-      image: evolvedbinary/rocksjava:centos7_x64-be
+      image: evolvedbinary/rocksjava:centos6_x64-be
      options: --shm-size=16gb
    steps:
    # The docker image is intentionally based on an OS that has an older GLIBC version.
@@ -457,7 +504,7 @@ jobs:
    runs-on:
      labels: 4-core-ubuntu
    container:
-      image: evolvedbinary/rocksjava:centos7_x64-be
+      image: evolvedbinary/rocksjava:centos6_x64-be
      options: --shm-size=16gb
    steps:
    # The docker image is intentionally based on an OS that has an older GLIBC version.
@@ -552,7 +599,7 @@ jobs:
    runs-on:
      labels: 4-core-ubuntu
    container:
-      image: evolvedbinary/rocksjava:alpine3_x64-be
+      image: evolvedbinary/rocksjava:rockylinux8_x64-be
      options: --shm-size=16gb
    steps:
    - uses: actions/checkout@v4.1.0
@@ -88,7 +88,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "db/memtable_list.cc",
        "db/merge_helper.cc",
        "db/merge_operator.cc",
-        "db/multi_scan.cc",
        "db/output_validator.cc",
        "db/periodic_task_scheduler.cc",
        "db/range_del_aggregator.cc",
@@ -250,7 +249,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "trace_replay/trace_record_result.cc",
        "trace_replay/trace_replay.cc",
        "util/async_file_reader.cc",
-        "util/auto_tune_compressor.cc",
        "util/build_version.cc",
        "util/cleanable.cc",
        "util/coding.cc",
@@ -269,7 +267,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "util/random.cc",
        "util/rate_limiter.cc",
        "util/ribbon_config.cc",
-        "util/simple_mixed_compressor.cc",
        "util/slice.cc",
        "util/status.cc",
        "util/stderr_logger.cc",
@@ -4712,12 +4709,6 @@ cpp_unittest_wrapper(name="compressed_secondary_cache_test",
            extra_compiler_flags=[])


-cpp_unittest_wrapper(name="compression_test",
-            srcs=["util/compression_test.cc"],
-            deps=[":rocksdb_test_lib"],
-            extra_compiler_flags=[])
-
-
 cpp_unittest_wrapper(name="configurable_test",
            srcs=["options/configurable_test.cc"],
            deps=[":rocksdb_test_lib"],
@@ -721,7 +721,6 @@ set(SOURCES
        db/memtable_list.cc
        db/merge_helper.cc
        db/merge_operator.cc
-        db/multi_scan.cc
        db/output_validator.cc
        db/periodic_task_scheduler.cc
        db/range_del_aggregator.cc
@@ -875,13 +874,11 @@ set(SOURCES
        trace_replay/trace_record.cc
        trace_replay/trace_replay.cc
        util/async_file_reader.cc
-        util/auto_tune_compressor.cc
        util/cleanable.cc
        util/coding.cc
        util/compaction_job_stats_impl.cc
        util/comparator.cc
        util/compression.cc
-        util/simple_mixed_compressor.cc
        util/compression_context_cache.cc
        util/concurrent_task_limiter_impl.cc
        util/crc32c.cc
@@ -1459,7 +1456,6 @@ if(WITH_TESTS)
        util/autovector_test.cc
        util/bloom_test.cc
        util/coding_test.cc
-        util/compression_test.cc
        util/crc32c_test.cc
        util/defer_test.cc
        util/dynamic_bloom_test.cc
@@ -1,116 +1,11 @@
 # Rocksdb Change Log
 > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`

-## 10.5.4 (08/21/2025)
-### Bug Fixes
-* Fix a crash in iterator Prepare() when fill_cache=false
-
-## 10.5.3 (08/14/2025)
-### Bug Fixes
-* Allow a user defined index to be configured from a string.
-
-## 10.5.2 (08/12/2025)
-### Bug Fixes
-* Make the User Defined Index interface consistently use the user key format, fixing the previous mixed usage of internal and user key.
-
-## 10.5.1 (08/04/2025)
-### Bug Fixes
-* Fixed a bug in remote compaction that may mistakenly delete live SST file(s) during the cleanup phase when no keys survive the compaction (all expired)
-
-## 10.5.0 (07/21/2025)
+## 10.0.1 (03/05/2025)
 ### Public API Changes
-* DB option skip_checking_sst_file_sizes_on_db_open is deprecated, in favor of validating file size in parallel in a thread pool, when db is opened. When DB is opened, with paranoid check enabled, a file with the wrong size would fail the DB open. With paranoid check disabled, the DB open would succeed, the column family with the corrupted file would not be read or write, while the other healthy column families could be read and write normally. When max_open_files option is not set to -1, only a subset of the files will be opened and checked. The rest of the files will be opened and checked when they are accessed.
-* GetTtl() API is now available in TTL DB
-
-### Behavior Changes
-* PessimisticTransaction::GetWaitingTxns now returns waiting transaction information even if the current transaction has timed out. This allows the information to be surfaced to users for debugging purposes once it is known that the timeout has occured.
-* A new API GetFileSize is added to FSRandomAccessFile interface class. It uses fstat vs stat on the posix implementation which is more efficient. Caller could use it to get file size faster. This function might be required in the future for FileSystem implementation outside of the RocksDB code base.
-* RocksDB now triggers eligible compactions every 12 hours when periodic compaction is configured. This solves a limitation of the compaction trigger mechanism, which would only trigger compaction after specific events like flush, compaction, or SetOptions.
-
-### Bug Fixes
-* Fix a bug in BackupEngine that can crash backup due to a null FSWritableFile passed to WritableFileWriter.
-* Fix DB::NewMultiScan iterator to respect the scan upper bound specified in ScanOptions
-
-### Performance Improvements
-* Optimized MultiScan using BlockBasedTable to coalesce I/Os and prefetch all data blocks.
-
-## 10.4.0 (06/20/2025)
-### New Features
-* Add a new CF option `memtable_avg_op_scan_flush_trigger` that supports triggering memtable flush when an iterator scans through an expensive range of keys, with the average number of skipped keys from the active memtable exceeding the threshold.
-* Vector based memtable now supports concurrent writers (DBOptions::allow_concurrent_memtable_write) #13675.
-* Add new experimental `TransactionOptions::large_txn_commit_optimize_byte_threshold` to enable optimizations for large transaction commit by transaction batch data size.
-* Add a new option `CompactionOptionsUniversal::reduce_file_locking` and if it's true, auto universal compaction picking will adjust to minimize locking of input files when bottom priority compactions are waiting to run. This can increase the likelihood of existing L0s being selected for compaction, thereby improving write stall and reducing read regression.
-* Add new `format_version=7` to aid experimental support of custom compression algorithms with CompressionManager and block-based table. This format version includes changing the format of `TableProperties::compression_name`.
-
-### Public API Changes
-* Change NewExternalTableFactory to return a unique_ptr instead of shared_ptr.
-* Add an optional min file size requirement for deletion triggered compaction. It can be specified when creating `CompactOnDeletionCollectorFactory`.
-
-### Behavior Changes
-* `TransactionOptions::large_txn_commit_optimize_threshold` now has default value 0 for disabled. `TransactionDBOptions::txn_commit_bypass_memtable_threshold` now has no effect on transactions.
-
-### Bug Fixes
-* Fix a bug where CreateColumnFamilyWithImport() could miss the SST file for the memtable flush it triggered. The exported CF then may not contain the updates in the memtable when CreateColumnFamilyWithImport() is called.
-* Fix iterator operations returning NotImplemented status if disallow_memtable_writes and paranoid_memory_checks CF options are both set.
-* Fixed handling of file checksums in IngestExternalFile() to allow providing checksums using recognized but not necessarily the DB's preferred checksum function, to ease migration between checksum functions.
-
-## 10.3.0 (05/17/2025)
-### New Features
-* Add new experimental `CompactionOptionsFIFO::allow_trivial_copy_when_change_temperature` along with `CompactionOptionsFIFO::trivial_copy_buffer_size` to allow optimizing FIFO compactions with tiering when kChangeTemperature to move files from source tier FileSystem to another tier FileSystem via trivial and direct copying raw sst file instead of reading thru the content of the SST file then rebuilding the table files.
-* Add a new field to Compaction Stats in LOG files for the pre-compression size written to each level.
-* Add new experimental `TransactionOptions::large_txn_commit_optimize_threshold` to enable optimizations for large transaction commit with per transaction threshold. `TransactionDBOptions::txn_commit_bypass_memtable_threshold` is deprecated in favor of this transaction option.
-* [internal team use only] Allow an application-defined `request_id` to be passed to RocksDB and propagated to the filesystem via IODebugContext
-
-### Bug Fixes
-* Fix a bug where transaction lock upgrade can incorrectly fail with a Deadlock status. This happens when a transaction has a non-zero timeout and tries to upgrade a shared lock that is also held by another transaction.
-* Pass wrapped WritableFileWriter pointer to ExternalTableBuilder so that the file checksum can be correctly calculated and returned by SstFileWriter for external table files.
-* Fix an infinite-loop bug in transaction locking. This can happen if a transaction reaches lock limit and its time out expires before it attempts to wait for it.
-* Fixed a potential data race with `CompressionOptions::parallel_threads > 1` and a `TablePropertiesCollector` overriding `BlockAdd()`.
-
-## 10.2.0 (04/21/2025)
-### New Features
-* Provide histogram stats `COMPACTION_PREFETCH_BYTES` to measure number of bytes for RocksDB's prefetching (as opposed to file
-system's prefetch) on SST file during compaction read
-* A new API DB::GetNewestUserDefinedTimestamp is added to return the newest user defined timestamp seen in a column family
-* Introduce API `IngestWriteBatchWithIndex()` for ingesting updates into DB while bypassing memtable writes. This improves performance when writing a large write batch to the DB.
-* Add a new CF option `memtable_op_scan_flush_trigger` that triggers a flush of the memtable if an iterator's Seek()/Next() scans over a certain number of invisible entries from the memtable.
-
-### Public API Changes
-* AdvancedColumnFamilyOptions.max_write_buffer_number_to_maintain is deleted. It's deprecated since introduction of a better option max_write_buffer_size_to_maintain since RocksDB 6.5.0.
-* Deprecated API `DB::MaxMemCompactionLevel()`.
-* Deprecated `ReadOptions::ignore_range_deletions`.
-* Deprecated API `experimental::PromoteL0()`.
-* Added arbitrary string map for additional options to be overriden for remote compactions
-* The fail_if_options_file_error option in DBOptions has been removed. The behavior now is to always return failure in any API that fails to persist the OPTIONS file.
-
-### Behavior Changes
-* Make stats `PREFETCH_BYTES_USEFUL`, `PREFETCH_HITS`, `PREFETCH_BYTES` only account for prefetching during user initiated scan
-
-### Bug Fixes
-* Fix a bug in Posix file system that the FSWritableFile created via `FileSystem::ReopenWritableFile` internally does not track the correct file size.
-* Fix a bug where tail size of remote compaction output is not persisted in primary db's manifest
-
-## 10.1.0 (03/24/2025)
-### New Features
-* Added a new `DBOptions.calculate_sst_write_lifetime_hint_set` setting that allows to customize which compaction styles SST write lifetime hint calculation is allowed on. Today RocksDB supports only two modes `kCompactionStyleLevel` and `kCompactionStyleUniversal`.
-* Add a new field `num_l0_files` in `CompactionJobInfo` about the number of L0 files in the CF right before and after the compaction
-* Added per-key-placement feature in Remote Compaction
-* Implemented API DB::GetPropertiesOfTablesByLevel that retrieves table properties for files in each LSM tree level
-
-### Public API Changes
-* `GetAllKeyVersions()` now interprets empty slices literally, as valid keys, and uses new `OptSlice` type default value for extreme upper and lower range limits.
-* `DeleteFilesInRanges()` now takes `RangeOpt` which is based on `OptSlice`. The overload taking `RangePtr` is deprecated.
 * Add an unordered map of name/value pairs, ReadOptions::property_bag, to pass opaque options through to an external table when creating an Iterator.
 * Introduced CompactionServiceJobStatus::kAborted to allow handling aborted scenario in Schedule(), Wait() or OnInstallation() APIs in Remote Compactions.
-* format\_version < 2 in BlockBasedTableOptions is no longer supported for writing new files. Support for reading such files is deprecated and might be removed in the future. `CompressedSecondaryCacheOptions::compress_format_version == 1` is also deprecated.
-
-### Behavior Changes
-* `ldb` now returns an error if the specified `--compression_type` is not supported in the build.
-* MultiGet with snapshot and ReadOptions::read_tier = kPersistedTier will now read a consistent view across CFs (instead of potentially reading some CF before and some CF after a flush).
-* CreateColumnFamily() is no longer allowed on a read-only DB (OpenForReadOnly())
-
-### Bug Fixes
-* Fixed stats for Tiered Storage with preclude_last_level feature
+* Added a column family option disallow_memtable_writes to safely fail any attempts to write to a non-default column family. This can be used for column families that are ingest only.

 ## 10.0.0 (02/21/2025)
 ### New Features
@@ -1491,9 +1491,6 @@ db_test: $(OBJ_DIR)/db/db_test.o $(TEST_LIBRARY) $(LIBRARY)
 db_test2: $(OBJ_DIR)/db/db_test2.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

-compression_test: $(OBJ_DIR)/util/compression_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 db_logical_block_size_cache_test: $(OBJ_DIR)/db/db_logical_block_size_cache_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

@@ -2147,14 +2144,14 @@ 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.2
-SNAPPY_SHA256 ?= 90f74bc1fbf78a6c56b3c4a082a05103b3a56bb17bca1a27e052ea11723292dc
+SNAPPY_VER ?= 1.2.1
+SNAPPY_SHA256 ?= 736aeb64d86566d2236ddffa2865ee5d7a82d26c9016b36218fcc27ea4f09f86
 SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
-LZ4_VER ?= 1.10.0
-LZ4_SHA256 ?= 537512904744b35e232912055ccf8ec66d768639ff3abe5788d90d792ec5f48b
+LZ4_VER ?= 1.9.4
+LZ4_SHA256 ?= 0b0e3aa07c8c063ddf40b082bdf7e37a1562bda40a0ff5272957f3e987e0e54b
 LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
-ZSTD_VER ?= 1.5.7
-ZSTD_SHA256 ?= 37d7284556b20954e56e1ca85b80226768902e2edabd3b649e9e72c0c9012ee3
+ZSTD_VER ?= 1.5.5
+ZSTD_SHA256 ?= 98e9c3d949d1b924e28e01eccb7deed865eefebf25c2f21c702e5cd5b63b85e1
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
 CURL_SSL_OPTS ?= --tlsv1

@@ -2375,27 +2372,27 @@ rocksdbjavastaticreleasedocker: rocksdbjavastaticosx rocksdbjavastaticdockerx86

 rocksdbjavastaticdockerx86:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_x86-be --platform linux/386 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_x86-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_x86-be --platform linux/386 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos6_x86-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerx86_64:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_x64-be --platform linux/amd64 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_x64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_x64-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos6_x64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerppc64le:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_ppc64le-be --platform linux/ppc64le --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_ppc64le-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_ppc64le-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_ppc64le-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerarm64v8:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_arm64v8-be --platform linux/aarch64 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_arm64v8-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_arm64v8-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:centos7_arm64v8-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockers390x:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_s390x-be --platform linux/s390x --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:ubuntu18_s390x-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_s390x-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:ubuntu18_s390x-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerriscv64:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_riscv64-be --platform linux/riscv64 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:ubuntu20_riscv64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_riscv64-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:ubuntu20_riscv64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerx86musl:
 	mkdir -p java/target
@@ -2403,19 +2400,19 @@ rocksdbjavastaticdockerx86musl:

 rocksdbjavastaticdockerx86_64musl:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_x64-musl-be --platform linux/amd64 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_x64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_x64-musl-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_x64-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerppc64lemusl:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_ppc64le-musl-be --platform linux/ppc64le --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_ppc64le-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_ppc64le-musl-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_ppc64le-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockerarm64v8musl:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_arm64v8-musl-be --platform linux/aarch64 --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_arm64v8-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_arm64v8-musl-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_arm64v8-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticdockers390xmusl:
 	mkdir -p java/target
-	docker run --rm --name rocksdb_linux_s390x-musl-be --platform linux/s390x --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_s390x-be /rocksdb-host/java/crossbuild/docker-build-linux.sh
+	docker run --rm --name rocksdb_linux_s390x-musl-be --attach stdin --attach stdout --attach stderr --volume $(HOME)/.m2:/root/.m2:ro --volume `pwd`:/rocksdb-host:ro --volume /rocksdb-local-build --volume `pwd`/java/target:/rocksdb-java-target --env DEBUG_LEVEL=$(DEBUG_LEVEL) --env J=$(J) evolvedbinary/rocksjava:alpine3_s390x-be /rocksdb-host/java/crossbuild/docker-build-linux.sh

 rocksdbjavastaticpublish: rocksdbjavastaticrelease rocksdbjavastaticpublishcentral

@@ -2470,8 +2467,8 @@ jtest_run:
 jtest: rocksdbjava
 	cd java;$(MAKE) sample test

-jpmd: rocksdbjavageneratepom
-	cd java;$(MAKE) java java_test pmd
+jpmd: rocksdbjava rocksdbjavageneratepom
+	cd java;$(MAKE) pmd

 jdb_bench:
 	cd java;$(MAKE) db_bench;
@@ -2492,13 +2489,11 @@ 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 5c626dd6a028a02e461edb5396694d48305e9284
-	@# Apparently missing include
-	perl -pi -e 's/(#include <atomic>)/$$1\n#include <cstring>/' third-party/folly/folly/lang/Exception.h
-	@# Warning-as-error on memcpy
-	perl -pi -e 's/memcpy.&ptr/memcpy((void*)&ptr/' third-party/folly/folly/lang/Exception.cpp
-	@# const mismatch
-	perl -pi -e 's/: environ/: (const char**)(environ)/' third-party/folly/folly/Subprocess.cpp
+	cd third-party/folly && git reset --hard f1c1542fb071e9d88181279ec24043400222aef1
+	@# 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

@@ -118,9 +118,6 @@ fi
 # fi
 set -e

-# Exclude third-party from formatting
-EXCLUDE=':!third-party/'
-
 uncommitted_code=`git diff HEAD`

 # If there's no uncommitted changes, we assume user are doing post-commit
@@ -140,11 +137,11 @@ then
  # should be relevant for formatting fixes.
  FORMAT_UPSTREAM_MERGE_BASE="$(git merge-base "$FORMAT_UPSTREAM" HEAD)"
  # Get the differences
-  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" -- $EXCLUDE | $CLANG_FORMAT_DIFF -p 1) || true
+  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -p 1) || true
  echo "Checking format of changes not yet in $FORMAT_UPSTREAM..."
 else
  # Check the format of uncommitted lines,
-  diffs=$(git diff -U0 HEAD -- $EXCLUDE | $CLANG_FORMAT_DIFF -p 1) || true
+  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1) || true
  echo "Checking format of uncommitted changes..."
 fi

@@ -190,9 +187,9 @@ fi
 # Do in-place format adjustment.
 if [ -z "$uncommitted_code" ]
 then
-  git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" -- $EXCLUDE | $CLANG_FORMAT_DIFF -i -p 1
+  git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -i -p 1
 else
-  git diff -U0 HEAD -- $EXCLUDE | $CLANG_FORMAT_DIFF -i -p 1
+  git diff -U0 HEAD | $CLANG_FORMAT_DIFF -i -p 1
 fi
 echo "Files reformatted!"

@@ -24,14 +24,7 @@ CompressedSecondaryCache::CompressedSecondaryCache(
      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
          std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
              cache_))),
-      disable_cache_(opts.capacity == 0) {
-  auto mgr =
-      GetBuiltinCompressionManager(cache_options_.compress_format_version);
-  compressor_ = mgr->GetCompressor(cache_options_.compression_opts,
-                                   cache_options_.compression_type);
-  decompressor_ =
-      mgr->GetDecompressorOptimizeFor(cache_options_.compression_type);
-}
+      disable_cache_(opts.capacity == 0) {}

 CompressedSecondaryCache::~CompressedSecondaryCache() = default;

@@ -80,16 +73,15 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
    ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
    handle_value_charge = cache_->GetCharge(lru_handle);
    data_ptr = ptr->get();
-    const char* limit = ptr->get() + handle_value_charge;
-    data_ptr =
-        GetVarint32Ptr(data_ptr, limit, static_cast<uint32_t*>(&type_32));
+    data_ptr = GetVarint32Ptr(data_ptr, data_ptr + 1,
+                              static_cast<uint32_t*>(&type_32));
    type = static_cast<CompressionType>(type_32);
-    data_ptr =
-        GetVarint32Ptr(data_ptr, limit, static_cast<uint32_t*>(&source_32));
+    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, limit, static_cast<uint64_t*>(&data_size));
+    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;
  }
@@ -105,24 +97,25 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
                            kNoCompression, CacheTier::kVolatileTier,
                            create_context, allocator, &value, &charge);
    } else {
-      // TODO: can we work some magic with create_cb, which might be based on
-      // custom compression, to decompress without an extra copy in create_cb?
-      Decompressor::Args args;
-      args.compressed_data = Slice(data_ptr, handle_value_charge);
-      args.compression_type = cache_options_.compression_type;
-      s = decompressor_->ExtractUncompressedSize(args);
-      assert(s.ok());
-      if (s.ok()) {
-        auto uncompressed = std::make_unique<char[]>(args.uncompressed_size);
-        s = decompressor_->DecompressBlock(args, uncompressed.get());
-        assert(s.ok());
-        if (s.ok()) {
-          s = helper->create_cb(
-              Slice(uncompressed.get(), args.uncompressed_size), kNoCompression,
-              CacheTier::kVolatileTier, create_context, allocator, &value,
-              &charge);
-        }
+      UncompressionContext uncompression_context(
+          cache_options_.compression_type);
+      UncompressionInfo uncompression_info(uncompression_context,
+                                           UncompressionDict::GetEmptyDict(),
+                                           cache_options_.compression_type);
+
+      size_t uncompressed_size{0};
+      CacheAllocationPtr uncompressed =
+          UncompressData(uncompression_info, (char*)data_ptr,
+                         handle_value_charge, &uncompressed_size,
+                         cache_options_.compress_format_version, allocator);
+
+      if (!uncompressed) {
+        cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
+        return nullptr;
      }
+      s = helper->create_cb(Slice(uncompressed.get(), uncompressed_size),
+                            kNoCompression, CacheTier::kVolatileTier,
+                            create_context, allocator, &value, &charge);
    }
  } else {
    // The item was not compressed by us. Let the helper create_cb
@@ -205,17 +198,20 @@ Status CompressedSecondaryCache::InsertInternal(
      type == kNoCompression &&
      !cache_options_.do_not_compress_roles.Contains(helper->role)) {
    PERF_COUNTER_ADD(compressed_sec_cache_uncompressed_bytes, data_size);
+    CompressionContext compression_context(cache_options_.compression_type,
+                                           cache_options_.compression_opts);
+    uint64_t sample_for_compression{0};
+    CompressionInfo compression_info(
+        cache_options_.compression_opts, compression_context,
+        CompressionDict::GetEmptyDict(), cache_options_.compression_type,
+        sample_for_compression);

-    CompressionType to_type = kNoCompression;
-    s = compressor_->CompressBlock(val, &compressed_val, &to_type,
-                                   nullptr /*working_area*/);
-    if (!s.ok()) {
-      return s;
-    }
-    // TODO: allow values not compressed when there's no size savings?
-    assert(to_type == cache_options_.compression_type);
-    if (to_type != cache_options_.compression_type) {
-      return Status::Corruption("Failed to compress value.");
+    bool success =
+        CompressData(val, compression_info,
+                     cache_options_.compress_format_version, &compressed_val);
+
+    if (!success) {
+      return Status::Corruption("Error compressing value.");
    }

    val = Slice(compressed_val);
@@ -145,8 +145,6 @@ class CompressedSecondaryCache : public SecondaryCache {
  const Cache::CacheItemHelper* GetHelper(bool enable_custom_split_merge) const;
  std::shared_ptr<Cache> cache_;
  CompressedSecondaryCacheOptions cache_options_;
-  std::unique_ptr<Compressor> compressor_;
-  std::shared_ptr<Decompressor> decompressor_;
  mutable port::Mutex capacity_mutex_;
  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
  bool disable_cache_;
@@ -121,17 +121,7 @@ CacheWithSecondaryAdapter::~CacheWithSecondaryAdapter() {
    assert(s.ok());
    assert(placeholder_usage_ == 0);
    assert(reserved_usage_ == 0);
-    bool pri_cache_res_mismatch =
-        pri_cache_res_->GetTotalMemoryUsed() != sec_capacity;
-    if (pri_cache_res_mismatch) {
-      fprintf(stderr,
-              "~CacheWithSecondaryAdapter: Primary cache reservation: "
-              "%zu, Secondary cache capacity: %zu, "
-              "Secondary cache reserved: %zu\n",
-              pri_cache_res_->GetTotalMemoryUsed(), sec_capacity,
-              sec_reserved_);
-      assert(!pri_cache_res_mismatch);
-    }
+    assert(pri_cache_res_->GetTotalMemoryUsed() == sec_capacity);
  }
 #endif  // NDEBUG
 }
@@ -489,10 +479,12 @@ const char* CacheWithSecondaryAdapter::Name() const {
 // as well. At the moment, we don't have a good way of handling the case
 // where the new capacity < total cache reservations.
 void CacheWithSecondaryAdapter::SetCapacity(size_t capacity) {
+  size_t sec_capacity = static_cast<size_t>(
+      capacity * (distribute_cache_res_ ? sec_cache_res_ratio_ : 0.0));
+  size_t old_sec_capacity = 0;
+
  if (distribute_cache_res_) {
    MutexLock m(&cache_res_mutex_);
-    size_t sec_capacity = static_cast<size_t>(capacity * sec_cache_res_ratio_);
-    size_t old_sec_capacity = 0;

    Status s = secondary_cache_->GetCapacity(old_sec_capacity);
    if (!s.ok()) {
@@ -611,7 +603,6 @@ Status CacheWithSecondaryAdapter::UpdateCacheReservationRatio(
    //    cache utilization (increase in capacity - increase in share of cache
    //    reservation)
    // 3. Increase secondary cache capacity
-    assert(new_sec_reserved >= sec_reserved_);
    s = secondary_cache_->Deflate(new_sec_reserved - sec_reserved_);
    assert(s.ok());
    s = pri_cache_res_->UpdateCacheReservation(
@@ -11,29 +11,18 @@ CRASHTEST_MAKE=$(MAKE) -f crash_test.mk
 CRASHTEST_PY=$(PYTHON) -u tools/db_crashtest.py --stress_cmd=$(DB_STRESS_CMD) --cleanup_cmd='$(DB_CLEANUP_CMD)'

 .PHONY: crash_test crash_test_with_atomic_flush crash_test_with_txn \
-	crash_test_with_wc_txn crash_test_with_wp_txn crash_test_with_wup_txn \
 	crash_test_with_best_efforts_recovery crash_test_with_ts \
-	crash_test_with_multiops_wc_txn \
-	crash_test_with_multiops_wp_txn \
-	crash_test_with_multiops_wup_txn \
-	crash_test_with_optimistic_txn \
-	crash_test_with_tiered_storage \
 	blackbox_crash_test blackbox_crash_test_with_atomic_flush \
-	blackbox_crash_test_with_wc_txn blackbox_crash_test_with_wp_txn \
-	blackbox_crash_test_with_wup_txn \
 	blackbox_crash_test_with_txn blackbox_crash_test_with_ts \
 	blackbox_crash_test_with_best_efforts_recovery \
+	whitebox_crash_test whitebox_crash_test_with_atomic_flush \
+	whitebox_crash_test_with_txn whitebox_crash_test_with_ts \
 	blackbox_crash_test_with_multiops_wc_txn \
 	blackbox_crash_test_with_multiops_wp_txn \
-	blackbox_crash_test_with_multiops_wup_txn \
-	blackbox_crash_test_with_optimistic_txn \
-	blackbox_crash_test_with_tiered_storage \
-	whitebox_crash_test whitebox_crash_test_with_atomic_flush \
-	whitebox_crash_test_with_wc_txn whitebox_crash_test_with_wp_txn \
-	whitebox_crash_test_with_wup_txn \
-	whitebox_crash_test_with_txn whitebox_crash_test_with_ts \
-	whitebox_crash_test_with_optimistic_txn \
+	crash_test_with_tiered_storage blackbox_crash_test_with_tiered_storage \
 	whitebox_crash_test_with_tiered_storage \
+	whitebox_crash_test_with_optimistic_txn \
+	blackbox_crash_test_with_optimistic_txn \

 crash_test: $(DB_STRESS_CMD)
 # Do not parallelize
@@ -45,20 +34,10 @@ crash_test_with_atomic_flush: $(DB_STRESS_CMD)
 	$(CRASHTEST_MAKE) whitebox_crash_test_with_atomic_flush
 	$(CRASHTEST_MAKE) blackbox_crash_test_with_atomic_flush

-crash_test_with_wc_txn: $(DB_STRESS_CMD)
+crash_test_with_txn: $(DB_STRESS_CMD)
 # Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_wc_txn
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_wc_txn
-
-crash_test_with_wp_txn: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_wp_txn
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_wp_txn
-
-crash_test_with_wup_txn: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_wup_txn
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_wup_txn
+	$(CRASHTEST_MAKE) whitebox_crash_test_with_txn
+	$(CRASHTEST_MAKE) blackbox_crash_test_with_txn

 crash_test_with_optimistic_txn: $(DB_STRESS_CMD)
 # Do not parallelize
@@ -83,9 +62,6 @@ crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
 crash_test_with_multiops_wp_txn: $(DB_STRESS_CMD)
 	$(CRASHTEST_MAKE) blackbox_crash_test_with_multiops_wp_txn

-crash_test_with_multiops_wup_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_multiops_wup_txn
-
 blackbox_crash_test: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --simple blackbox $(CRASH_TEST_EXT_ARGS)
 	$(CRASHTEST_PY) blackbox $(CRASH_TEST_EXT_ARGS)
@@ -93,14 +69,8 @@ blackbox_crash_test: $(DB_STRESS_CMD)
 blackbox_crash_test_with_atomic_flush: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --cf_consistency blackbox $(CRASH_TEST_EXT_ARGS)

-blackbox_crash_test_with_wc_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn blackbox --txn_write_policy 0 $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_wp_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn blackbox --txn_write_policy 1 $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_wup_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn blackbox --txn_write_policy 2 $(CRASH_TEST_EXT_ARGS)
+blackbox_crash_test_with_txn: $(DB_STRESS_CMD)
+	$(CRASHTEST_PY) --txn blackbox $(CRASH_TEST_EXT_ARGS)

 blackbox_crash_test_with_best_efforts_recovery: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --test_best_efforts_recovery blackbox $(CRASH_TEST_EXT_ARGS)
@@ -109,13 +79,10 @@ blackbox_crash_test_with_ts: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --enable_ts blackbox $(CRASH_TEST_EXT_ARGS)

 blackbox_crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_multiops_txn --txn_write_policy 0 blackbox $(CRASH_TEST_EXT_ARGS)
+	$(CRASHTEST_PY) --test_multiops_txn --write_policy write_committed blackbox $(CRASH_TEST_EXT_ARGS)

 blackbox_crash_test_with_multiops_wp_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_multiops_txn --txn_write_policy 1 blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_multiops_wup_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_multiops_txn --txn_write_policy 2 blackbox $(CRASH_TEST_EXT_ARGS)
+	$(CRASHTEST_PY) --test_multiops_txn --write_policy write_prepared blackbox $(CRASH_TEST_EXT_ARGS)

 blackbox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --test_tiered_storage blackbox $(CRASH_TEST_EXT_ARGS)
@@ -137,17 +104,9 @@ whitebox_crash_test_with_atomic_flush: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --cf_consistency whitebox  --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

-whitebox_crash_test_with_wc_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn whitebox --txn_write_policy 0 \
-	  --random_kill_odd $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_wp_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn whitebox --txn_write_policy 1 \
-      --random_kill_odd $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_wup_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn whitebox --txn_write_policy 2 \
-      --random_kill_odd $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
+whitebox_crash_test_with_txn: $(DB_STRESS_CMD)
+	$(CRASHTEST_PY) --txn whitebox --random_kill_odd \
+      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

 whitebox_crash_test_with_ts: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --enable_ts whitebox --random_kill_odd \
@@ -160,8 +119,3 @@ whitebox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
 whitebox_crash_test_with_optimistic_txn: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --optimistic_txn whitebox --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-# Old names DEPRECATED
-crash_test_with_txn: crash_test_with_wc_txn
-whitebox_crash_test_with_txn: whitebox_crash_test_with_wc_txn
-blackbox_crash_test_with_txn: blackbox_crash_test_with_wc_txn
@@ -42,9 +42,9 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
 void ArenaWrappedDBIter::Init(
    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
    const MutableCFOptions& mutable_cf_options, const Version* version,
-    const SequenceNumber& sequence, uint64_t version_number,
-    ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
-    bool expose_blob_index, bool allow_refresh, ReadOnlyMemTable* active_mem) {
+    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) {
  read_options_ = read_options;
  if (!CheckFSFeatureSupport(env->GetFileSystem().get(),
                             FSSupportedOps::kAsyncIO)) {
@@ -52,14 +52,15 @@ void ArenaWrappedDBIter::Init(
  }
  read_options_.total_order_seek |= ioptions.prefix_seek_opt_in_only;

-  db_iter_ = DBIter::NewIter(
-      env, read_options_, ioptions, mutable_cf_options,
-      ioptions.user_comparator, /*internal_iter=*/nullptr, version, sequence,
-      read_callback, active_mem, cfh, expose_blob_index, &arena_);
+  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;
-  allow_mark_memtable_for_flush_ = active_mem;
  memtable_range_tombstone_iter_ = nullptr;
 }

@@ -165,8 +166,9 @@ void ArenaWrappedDBIter::DoRefresh(const Snapshot* snapshot,
    read_callback_->Refresh(read_seq);
  }
  Init(env, read_options_, cfd->ioptions(), sv->mutable_cf_options, sv->current,
-       read_seq, sv->version_number, read_callback_, cfh_, expose_blob_index_,
-       allow_refresh_, allow_mark_memtable_for_flush_ ? sv->mem : nullptr);
+       read_seq, sv->mutable_cf_options.max_sequential_skip_in_iterations,
+       sv->version_number, read_callback_, cfh_, expose_blob_index_,
+       allow_refresh_);

  InternalIterator* internal_iter = db_impl->NewInternalIterator(
      read_options_, cfd, sv, &arena_, read_seq,
@@ -251,26 +253,20 @@ Status ArenaWrappedDBIter::Refresh(const Snapshot* snapshot) {
 }

 ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options, ColumnFamilyHandleImpl* cfh,
-    SuperVersion* sv, const SequenceNumber& sequence,
-    ReadCallback* read_callback, DBImpl* db_impl, bool expose_blob_index,
-    bool allow_refresh, bool allow_mark_memtable_for_flush) {
-  ArenaWrappedDBIter* db_iter = new ArenaWrappedDBIter();
-  db_iter->Init(env, read_options, cfh->cfd()->ioptions(),
-                sv->mutable_cf_options, sv->current, sequence,
-                sv->version_number, read_callback, cfh, expose_blob_index,
-                allow_refresh,
-                allow_mark_memtable_for_flush ? sv->mem : nullptr);
+    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    const MutableCFOptions& mutable_cf_options, const Version* version,
+    const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations,
+    uint64_t version_number, ReadCallback* read_callback,
+    ColumnFamilyHandleImpl* cfh, bool expose_blob_index, bool allow_refresh) {
+  ArenaWrappedDBIter* iter = new ArenaWrappedDBIter();
+  iter->Init(env, read_options, ioptions, mutable_cf_options, version, sequence,
+             max_sequential_skip_in_iterations, version_number, read_callback,
+             cfh, expose_blob_index, allow_refresh);
  if (cfh != nullptr && allow_refresh) {
-    db_iter->StoreRefreshInfo(cfh, read_callback, expose_blob_index);
+    iter->StoreRefreshInfo(cfh, read_callback, expose_blob_index);
  }

-  InternalIterator* internal_iter = db_impl->NewInternalIterator(
-      db_iter->GetReadOptions(), cfh->cfd(), sv, db_iter->GetArena(), sequence,
-      /*allow_unprepared_value=*/true, db_iter);
-  db_iter->SetIterUnderDBIter(internal_iter);
-
-  return db_iter;
+  return iter;
 }

 }  // namespace ROCKSDB_NAMESPACE
@@ -19,6 +19,7 @@
 #include "options/cf_options.h"
 #include "rocksdb/db.h"
 #include "rocksdb/iterator.h"
+#include "util/autovector.h"

 namespace ROCKSDB_NAMESPACE {

@@ -98,19 +99,13 @@ class ArenaWrappedDBIter : public Iterator {

  bool PrepareValue() override { return db_iter_->PrepareValue(); }

-  void Prepare(const std::vector<ScanOptions>& scan_opts) override {
-    db_iter_->Prepare(scan_opts);
-  }
-
-  // FIXME: we could just pass SV in for mutable cf option, version and version
-  // number, but this is used by SstFileReader which does not have a SV.
  void Init(Env* env, const ReadOptions& read_options,
            const ImmutableOptions& ioptions,
            const MutableCFOptions& mutable_cf_options, const Version* version,
-            const SequenceNumber& sequence, uint64_t version_number,
+            const SequenceNumber& sequence,
+            uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
            ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
-            bool expose_blob_index, bool allow_refresh,
-            ReadOnlyMemTable* active_mem);
+            bool expose_blob_index, bool allow_refresh);

  // Store some parameters so we can refresh the iterator at a later point
  // with these same params
@@ -133,16 +128,20 @@ class ArenaWrappedDBIter : public Iterator {
  ReadCallback* read_callback_;
  bool expose_blob_index_ = false;
  bool allow_refresh_ = true;
-  bool allow_mark_memtable_for_flush_ = 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;
 };

+// Generate the arena wrapped iterator class.
+// `cfh` is used for reneweal. If left null, renewal will not
+// be supported.
 ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options, ColumnFamilyHandleImpl* cfh,
-    SuperVersion* sv, const SequenceNumber& sequence,
-    ReadCallback* read_callback, DBImpl* db_impl, bool expose_blob_index,
-    bool allow_refresh, bool allow_mark_memtable_for_flush);
+    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    const MutableCFOptions& mutable_cf_options, const Version* version,
+    const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iterations,
+    uint64_t version_number, ReadCallback* read_callback,
+    ColumnFamilyHandleImpl* cfh = nullptr, bool expose_blob_index = false,
+    bool allow_refresh = true);
 }  // namespace ROCKSDB_NAMESPACE
@@ -188,12 +188,10 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
  }

  std::unique_ptr<FSWritableFile> file;
-  FileOptions fo_copy;
+
  {
    assert(file_options_);
-    fo_copy = *file_options_;
-    fo_copy.write_hint = write_hint_;
-    Status s = NewWritableFile(fs_, blob_file_path, &file, fo_copy);
+    Status s = NewWritableFile(fs_, blob_file_path, &file, *file_options_);

    TEST_SYNC_POINT_CALLBACK(
        "BlobFileBuilder::OpenBlobFileIfNeeded:NewWritableFile", &s);
@@ -211,9 +209,7 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {

  assert(file);
  file->SetIOPriority(write_options_->rate_limiter_priority);
-  // Subsequent attempts to override the hint via SetWriteLifeTimeHint
-  // with the very same value will be ignored by the fs.
-  file->SetWriteLifeTimeHint(fo_copy.write_hint);
+  file->SetWriteLifeTimeHint(write_hint_);
  FileTypeSet tmp_set = immutable_options_->checksum_handoff_file_types;
  Statistics* const statistics = immutable_options_->stats;
  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
@@ -267,9 +263,10 @@ Status BlobFileBuilder::CompressBlobIfNeeded(
  // TODO: allow user CompressionOptions, including max_compressed_bytes_per_kb
  CompressionOptions opts;
  CompressionContext context(blob_compression_type_, opts);
+  constexpr uint64_t sample_for_compression = 0;

  CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                       blob_compression_type_);
+                       blob_compression_type_, sample_for_compression);

  constexpr uint32_t compression_format_version = 2;

@@ -278,8 +275,8 @@ Status BlobFileBuilder::CompressBlobIfNeeded(
  {
    StopWatch stop_watch(immutable_options_->clock, immutable_options_->stats,
                         BLOB_DB_COMPRESSION_MICROS);
-    success = OLD_CompressData(*blob, info, compression_format_version,
-                               compressed_blob);
+    success =
+        CompressData(*blob, info, compression_format_version, compressed_blob);
  }

  if (!success) {
@@ -405,9 +405,10 @@ TEST_F(BlobFileBuilderTest, Compression) {

  CompressionOptions opts;
  CompressionContext context(kSnappyCompression, opts);
+  constexpr uint64_t sample_for_compression = 0;

  CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                       kSnappyCompression);
+                       kSnappyCompression, sample_for_compression);

  std::string compressed_value;
  ASSERT_TRUE(Snappy_Compress(info, uncompressed_value.data(),
@@ -6,7 +6,6 @@
 #pragma once

 #include <cassert>
-#include <cstdint>
 #include <iosfwd>
 #include <memory>
 #include <string>
@@ -250,8 +250,7 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
  Status s;

  IOOptions io_options;
-  IODebugContext dbg;
-  s = file_reader->PrepareIOOptions(read_options, io_options, &dbg);
+  s = file_reader->PrepareIOOptions(read_options, io_options);
  if (!s.ok()) {
    return s;
  }
@@ -260,13 +259,13 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
    constexpr char* scratch = nullptr;

    s = file_reader->Read(io_options, read_offset, read_size, slice, scratch,
-                          aligned_buf, &dbg);
+                          aligned_buf);
  } else {
    buf->reset(new char[read_size]);
    constexpr AlignedBuf* aligned_scratch = nullptr;

    s = file_reader->Read(io_options, read_offset, read_size, slice, buf->get(),
-                          aligned_scratch, &dbg);
+                          aligned_scratch);
  }

  if (!s.ok()) {
@@ -335,8 +334,7 @@ Status BlobFileReader::GetBlob(
    constexpr bool for_compaction = true;

    IOOptions io_options;
-    IODebugContext dbg;
-    s = file_reader_->PrepareIOOptions(read_options, io_options, &dbg);
+    s = file_reader_->PrepareIOOptions(read_options, io_options);
    if (!s.ok()) {
      return s;
    }
@@ -465,11 +463,10 @@ void BlobFileReader::MultiGetBlob(
  PERF_COUNTER_ADD(blob_read_count, num_blobs);
  PERF_COUNTER_ADD(blob_read_byte, total_len);
  IOOptions opts;
-  IODebugContext dbg;
-  s = file_reader_->PrepareIOOptions(read_options, opts, &dbg);
+  s = file_reader_->PrepareIOOptions(read_options, opts);
  if (s.ok()) {
    s = file_reader_->MultiRead(opts, read_reqs.data(), read_reqs.size(),
-                                direct_io ? &aligned_buf : nullptr, &dbg);
+                                direct_io ? &aligned_buf : nullptr);
  }
  if (!s.ok()) {
    for (auto& req : read_reqs) {
@@ -605,9 +602,9 @@ Status BlobFileReader::UncompressBlobIfNeeded(
  {
    PERF_TIMER_GUARD(blob_decompress_time);
    StopWatch stop_watch(clock, statistics, BLOB_DB_DECOMPRESSION_MICROS);
-    output = OLD_UncompressData(info, value_slice.data(), value_slice.size(),
-                                &uncompressed_size, compression_format_version,
-                                allocator);
+    output = UncompressData(info, value_slice.data(), value_slice.size(),
+                            &uncompressed_size, compression_format_version,
+                            allocator);
  }

  TEST_SYNC_POINT_CALLBACK(
@@ -75,14 +75,15 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,
  } else {
    CompressionOptions opts;
    CompressionContext context(compression, opts);
+    constexpr uint64_t sample_for_compression = 0;
    CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                         compression);
+                         compression, sample_for_compression);

    constexpr uint32_t compression_format_version = 2;

    for (size_t i = 0; i < num; ++i) {
-      ASSERT_TRUE(OLD_CompressData(blobs[i], info, compression_format_version,
-                                   &compressed_blobs[i]));
+      ASSERT_TRUE(CompressData(blobs[i], info, compression_format_version,
+                               &compressed_blobs[i]));
      blobs_to_write[i] = compressed_blobs[i];
      blob_sizes[i] = compressed_blobs[i].size();
    }
@@ -77,14 +77,15 @@ void WriteBlobFile(const ImmutableOptions& immutable_options,
  } else {
    CompressionOptions opts;
    CompressionContext context(compression, opts);
+    constexpr uint64_t sample_for_compression = 0;
    CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                         compression);
+                         compression, sample_for_compression);

    constexpr uint32_t compression_format_version = 2;

    for (size_t i = 0; i < num; ++i) {
-      ASSERT_TRUE(OLD_CompressData(blobs[i], info, compression_format_version,
-                                   &compressed_blobs[i]));
+      ASSERT_TRUE(CompressData(blobs[i], info, compression_format_version,
+                               &compressed_blobs[i]));
      blobs_to_write[i] = compressed_blobs[i];
      blob_sizes[i] = compressed_blobs[i].size();
    }
@@ -74,8 +74,8 @@ Status BuildTable(
    EventLogger* event_logger, int job_id, TableProperties* table_properties,
    Env::WriteLifeTimeHint write_hint, const std::string* full_history_ts_low,
    BlobFileCompletionCallback* blob_callback, Version* version,
-    uint64_t* memtable_payload_bytes, uint64_t* memtable_garbage_bytes,
-    InternalStats::CompactionStats* flush_stats) {
+    uint64_t* num_input_entries, uint64_t* memtable_payload_bytes,
+    uint64_t* memtable_garbage_bytes) {
  assert((tboptions.column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         tboptions.column_family_name.empty());
@@ -145,9 +145,7 @@ Status BuildTable(
      bool use_direct_writes = file_options.use_direct_writes;
      TEST_SYNC_POINT_CALLBACK("BuildTable:create_file", &use_direct_writes);
 #endif  // !NDEBUG
-      FileOptions fo_copy = file_options;
-      fo_copy.write_hint = write_hint;
-      IOStatus io_s = NewWritableFile(fs, fname, &file, fo_copy);
+      IOStatus io_s = NewWritableFile(fs, fname, &file, file_options);
      assert(s.ok());
      s = io_s;
      if (io_status->ok()) {
@@ -165,9 +163,7 @@ Status BuildTable(
      table_file_created = true;
      FileTypeSet tmp_set = ioptions.checksum_handoff_file_types;
      file->SetIOPriority(tboptions.write_options.rate_limiter_priority);
-      // Subsequent attempts to override the hint via SetWriteLifeTimeHint
-      // with the very same value will be ignored by the fs.
-      file->SetWriteLifeTimeHint(fo_copy.write_hint);
+      file->SetWriteLifeTimeHint(write_hint);
      file_writer.reset(new WritableFileWriter(
          std::move(file), fname, file_options, ioptions.clock, io_tracer,
          ioptions.stats, Histograms::SST_WRITE_MICROS, ioptions.listeners,
@@ -218,7 +214,8 @@ Status BuildTable(
      const Slice& key = c_iter.key();
      const Slice& value = c_iter.value();
      ParsedInternalKey ikey = c_iter.ikey();
-      Slice key_after_flush = key;
+      key_after_flush_buf.assign(key.data(), key.size());
+      Slice key_after_flush = key_after_flush_buf;
      Slice value_after_flush = value;

      if (ikey.type == kTypeValuePreferredSeqno) {
@@ -236,7 +233,6 @@ Status BuildTable(
              std::min(smallest_preferred_seqno, preferred_seqno);
        } else {
          // Cannot get a useful preferred seqno, convert it to a kTypeValue.
-          key_after_flush_buf.assign(key.data(), key.size());
          UpdateInternalKey(&key_after_flush_buf, ikey.sequence, kTypeValue);
          ikey = ParsedInternalKey(ikey.user_key, ikey.sequence, kTypeValue);
          key_after_flush = key_after_flush_buf;
@@ -253,10 +249,6 @@ Status BuildTable(
      }
      builder->Add(key_after_flush, value_after_flush);

-      if (flush_stats) {
-        flush_stats->num_output_records++;
-      }
-
      s = meta->UpdateBoundaries(key_after_flush, value_after_flush,
                                 ikey.sequence, ikey.type);
      if (!s.ok()) {
@@ -288,9 +280,6 @@ Status BuildTable(
        auto tombstone = range_del_it->Tombstone();
        std::pair<InternalKey, Slice> kv = tombstone.Serialize();
        builder->Add(kv.first.Encode(), kv.second);
-        if (flush_stats) {
-          flush_stats->num_output_records++;
-        }
        InternalKey tombstone_end = tombstone.SerializeEndKey();
        meta->UpdateBoundariesForRange(kv.first, tombstone_end, tombstone.seq_,
                                       tboptions.internal_comparator);
@@ -312,9 +301,9 @@ Status BuildTable(

    TEST_SYNC_POINT("BuildTable:BeforeFinishBuildTable");
    const bool empty = builder->IsEmpty();
-    if (flush_stats) {
+    if (num_input_entries != nullptr) {
      assert(c_iter.HasNumInputEntryScanned());
-      flush_stats->num_input_records =
+      *num_input_entries =
          c_iter.NumInputEntryScanned() + num_unfragmented_tombstones;
    }
    if (!s.ok() || empty) {
@@ -341,9 +330,6 @@ Status BuildTable(
    }

    if (s.ok() && !empty) {
-      if (flush_stats) {
-        flush_stats->bytes_written_pre_comp = builder->PreCompressionSize();
-      }
      uint64_t file_size = builder->FileSize();
      meta->fd.file_size = file_size;
      meta->tail_size = builder->GetTailSize();
@@ -10,7 +10,6 @@
 #include <utility>
 #include <vector>

-#include "db/internal_stats.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/seqno_to_time_mapping.h"
 #include "db/table_properties_collector.h"
@@ -35,6 +34,7 @@ class SnapshotChecker;
 class TableCache;
 class TableBuilder;
 class WritableFileWriter;
+class InternalStats;
 class BlobFileCompletionCallback;

 // Convenience function for NewTableBuilder on the embedded table_factory.
@@ -49,7 +49,6 @@ TableBuilder* NewTableBuilder(const TableBuilderOptions& tboptions,
 //
 // @param column_family_name Name of the column family that is also identified
 //    by column_family_id, or empty string if unknown.
-// @param flush_stats treat flush as level 0 compaction in internal stats
 Status BuildTable(
    const std::string& dbname, VersionSet* versions,
    const ImmutableDBOptions& db_options, const TableBuilderOptions& tboptions,
@@ -70,8 +69,8 @@ Status BuildTable(
    Env::WriteLifeTimeHint write_hint = Env::WLTH_NOT_SET,
    const std::string* full_history_ts_low = nullptr,
    BlobFileCompletionCallback* blob_callback = nullptr,
-    Version* version = nullptr, uint64_t* memtable_payload_bytes = nullptr,
-    uint64_t* memtable_garbage_bytes = nullptr,
-    InternalStats::CompactionStats* flush_stats = nullptr);
+    Version* version = nullptr, uint64_t* num_input_entries = nullptr,
+    uint64_t* memtable_payload_bytes = nullptr,
+    uint64_t* memtable_garbage_bytes = nullptr);

 }  // namespace ROCKSDB_NAMESPACE
@@ -24,14 +24,12 @@
 #include "rocksdb/experimental.h"
 #include "rocksdb/filter_policy.h"
 #include "rocksdb/iterator.h"
-#include "rocksdb/listener.h"
 #include "rocksdb/memtablerep.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/options.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/rate_limiter.h"
 #include "rocksdb/slice_transform.h"
-#include "rocksdb/sst_file_manager.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
 #include "rocksdb/table.h"
@@ -51,7 +49,6 @@
 #include "util/stderr_logger.h"
 #include "utilities/merge_operators.h"

-using ROCKSDB_NAMESPACE::BackgroundErrorReason;
 using ROCKSDB_NAMESPACE::BackupEngine;
 using ROCKSDB_NAMESPACE::BackupEngineOptions;
 using ROCKSDB_NAMESPACE::BackupID;
@@ -68,9 +65,7 @@ using ROCKSDB_NAMESPACE::ColumnFamilyMetaData;
 using ROCKSDB_NAMESPACE::ColumnFamilyOptions;
 using ROCKSDB_NAMESPACE::CompactionFilter;
 using ROCKSDB_NAMESPACE::CompactionFilterFactory;
-using ROCKSDB_NAMESPACE::CompactionJobInfo;
 using ROCKSDB_NAMESPACE::CompactionOptionsFIFO;
-using ROCKSDB_NAMESPACE::CompactionReason;
 using ROCKSDB_NAMESPACE::CompactRangeOptions;
 using ROCKSDB_NAMESPACE::Comparator;
 using ROCKSDB_NAMESPACE::CompressionType;
@@ -81,11 +76,8 @@ using ROCKSDB_NAMESPACE::DBOptions;
 using ROCKSDB_NAMESPACE::DbPath;
 using ROCKSDB_NAMESPACE::Env;
 using ROCKSDB_NAMESPACE::EnvOptions;
-using ROCKSDB_NAMESPACE::EventListener;
-using ROCKSDB_NAMESPACE::ExternalFileIngestionInfo;
 using ROCKSDB_NAMESPACE::FileLock;
 using ROCKSDB_NAMESPACE::FilterPolicy;
-using ROCKSDB_NAMESPACE::FlushJobInfo;
 using ROCKSDB_NAMESPACE::FlushOptions;
 using ROCKSDB_NAMESPACE::HistogramData;
 using ROCKSDB_NAMESPACE::HyperClockCacheOptions;
@@ -98,7 +90,6 @@ using ROCKSDB_NAMESPACE::Logger;
 using ROCKSDB_NAMESPACE::LRUCacheOptions;
 using ROCKSDB_NAMESPACE::MemoryAllocator;
 using ROCKSDB_NAMESPACE::MemoryUtil;
-using ROCKSDB_NAMESPACE::MemTableInfo;
 using ROCKSDB_NAMESPACE::MergeOperator;
 using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
 using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory;
@@ -122,12 +113,10 @@ using ROCKSDB_NAMESPACE::Slice;
 using ROCKSDB_NAMESPACE::SliceParts;
 using ROCKSDB_NAMESPACE::SliceTransform;
 using ROCKSDB_NAMESPACE::Snapshot;
-using ROCKSDB_NAMESPACE::SstFileManager;
 using ROCKSDB_NAMESPACE::SstFileMetaData;
 using ROCKSDB_NAMESPACE::SstFileWriter;
 using ROCKSDB_NAMESPACE::Status;
 using ROCKSDB_NAMESPACE::StderrLogger;
-using ROCKSDB_NAMESPACE::SubcompactionJobInfo;
 using ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory;
 using ROCKSDB_NAMESPACE::Transaction;
 using ROCKSDB_NAMESPACE::TransactionDB;
@@ -141,8 +130,6 @@ using ROCKSDB_NAMESPACE::WriteBatch;
 using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
 using ROCKSDB_NAMESPACE::WriteBufferManager;
 using ROCKSDB_NAMESPACE::WriteOptions;
-using ROCKSDB_NAMESPACE::WriteStallCondition;
-using ROCKSDB_NAMESPACE::WriteStallInfo;

 using std::unordered_set;
 using std::vector;
@@ -152,9 +139,6 @@ extern "C" {
 struct rocksdb_t {
  DB* rep;
 };
-struct rocksdb_status_ptr_t {
-  Status* rep;
-};
 struct rocksdb_backup_engine_t {
  BackupEngine* rep;
 };
@@ -242,9 +226,6 @@ struct rocksdb_cache_t {
 struct rocksdb_write_buffer_manager_t {
  std::shared_ptr<WriteBufferManager> rep;
 };
-struct rocksdb_sst_file_manager_t {
-  std::shared_ptr<SstFileManager> rep;
-};
 struct rocksdb_livefiles_t {
  std::vector<LiveFileMetaData> rep;
 };
@@ -311,28 +292,6 @@ struct rocksdb_compactionfiltercontext_t {
  CompactionFilter::Context rep;
 };

-struct rocksdb_flushjobinfo_t {
-  FlushJobInfo rep;
-};
-struct rocksdb_writestallcondition_t {
-  WriteStallCondition rep;
-};
-struct rocksdb_writestallinfo_t {
-  WriteStallInfo rep;
-};
-struct rocksdb_memtableinfo_t {
-  MemTableInfo rep;
-};
-struct rocksdb_compactionjobinfo_t {
-  CompactionJobInfo rep;
-};
-struct rocksdb_subcompactionjobinfo_t {
-  SubcompactionJobInfo rep;
-};
-struct rocksdb_externalfileingestioninfo_t {
-  ExternalFileIngestionInfo rep;
-};
-
 struct rocksdb_statistics_histogram_data_t {
  rocksdb_statistics_histogram_data_t() : rep() {}
  HistogramData rep;
@@ -925,10 +884,6 @@ void rocksdb_backup_engine_options_destroy(
  delete options;
 }

-void rocksdb_status_ptr_get_error(rocksdb_status_ptr_t* status, char** errptr) {
-  SaveError(errptr, *(status->rep));
-}
-
 rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db,
                                                       char** errptr) {
  Checkpoint* checkpoint;
@@ -2672,16 +2627,6 @@ rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base(
  return result;
 }

-rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_readopts(
-    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
-    const rocksdb_readoptions_t* options) {
-  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep =
-      wbwi->rep->NewIteratorWithBase(base_iterator->rep, &options->rep);
-  delete base_iterator;
-  return result;
-}
-
 rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
    rocksdb_column_family_handle_t* column_family) {
@@ -2692,17 +2637,6 @@ rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
  return result;
 }

-rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf_readopts(
-    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
-    rocksdb_column_family_handle_t* column_family,
-    const rocksdb_readoptions_t* options) {
-  rocksdb_iterator_t* result = new rocksdb_iterator_t;
-  result->rep = wbwi->rep->NewIteratorWithBase(
-      column_family->rep, base_iterator->rep, &options->rep);
-  delete base_iterator;
-  return result;
-}
-
 char* rocksdb_writebatch_wi_get_from_batch(rocksdb_writebatch_wi_t* wbwi,
                                           const rocksdb_options_t* options,
                                           const char* key, size_t keylen,
@@ -2762,23 +2696,6 @@ char* rocksdb_writebatch_wi_get_from_batch_and_db(
  return result;
 }

-rocksdb_pinnableslice_t* rocksdb_writebatch_wi_get_pinned_from_batch_and_db(
-    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
-    const rocksdb_readoptions_t* options, const char* key, size_t keylen,
-    char** errptr) {
-  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
-  Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep,
-                                          Slice(key, keylen), &v->rep);
-  if (!s.ok()) {
-    delete (v);
-    if (!s.IsNotFound()) {
-      SaveError(errptr, s);
-    }
-    return nullptr;
-  }
-  return v;
-}
-
 char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
    const rocksdb_readoptions_t* options,
@@ -2800,24 +2717,6 @@ char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
  return result;
 }

-rocksdb_pinnableslice_t* rocksdb_writebatch_wi_get_pinned_from_batch_and_db_cf(
-    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* column_family, const char* key,
-    size_t keylen, char** errptr) {
-  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
-  Status s = wbwi->rep->GetFromBatchAndDB(
-      db->rep, options->rep, column_family->rep, Slice(key, keylen), &v->rep);
-  if (!s.ok()) {
-    delete (v);
-    if (!s.IsNotFound()) {
-      SaveError(errptr, s);
-    }
-    return nullptr;
-  }
-  return v;
-}
-
 void rocksdb_write_writebatch_wi(rocksdb_t* db,
                                 const rocksdb_writeoptions_t* options,
                                 rocksdb_writebatch_wi_t* wbwi, char** errptr) {
@@ -3031,361 +2930,6 @@ void rocksdb_block_based_options_set_unpartitioned_pinning_tier(
      static_cast<ROCKSDB_NAMESPACE::PinningTier>(v);
 }

-/* FlushJobInfo */
-
-const char* rocksdb_flushjobinfo_cf_name(const rocksdb_flushjobinfo_t* info,
-                                         size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const char* rocksdb_flushjobinfo_file_path(const rocksdb_flushjobinfo_t* info,
-                                           size_t* size) {
-  *size = info->rep.file_path.size();
-  return info->rep.file_path.data();
-}
-
-unsigned char rocksdb_flushjobinfo_triggered_writes_slowdown(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.triggered_writes_slowdown;
-}
-
-unsigned char rocksdb_flushjobinfo_triggered_writes_stop(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.triggered_writes_stop;
-}
-
-uint64_t rocksdb_flushjobinfo_largest_seqno(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.largest_seqno;
-}
-
-uint64_t rocksdb_flushjobinfo_smallest_seqno(
-    const rocksdb_flushjobinfo_t* info) {
-  return info->rep.smallest_seqno;
-}
-
-uint32_t rocksdb_flushjobinfo_flush_reason(const rocksdb_flushjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.flush_reason);
-}
-
-void rocksdb_reset_status(rocksdb_status_ptr_t* status_ptr) {
-  auto ptr = status_ptr->rep;
-  *ptr = Status::OK();
-}
-
-/* CompactionJobInfo */
-
-void rocksdb_compactionjobinfo_status(const rocksdb_compactionjobinfo_t* info,
-                                      char** errptr) {
-  SaveError(errptr, info->rep.status);
-}
-
-const char* rocksdb_compactionjobinfo_cf_name(
-    const rocksdb_compactionjobinfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-size_t rocksdb_compactionjobinfo_input_files_count(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.input_files.size();
-}
-
-const char* rocksdb_compactionjobinfo_input_file_at(
-    const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) {
-  assert(info != nullptr);
-  assert(pos < info->rep.input_files.size());
-
-  const std::string& path = info->rep.input_files[pos];
-  *size = path.size();
-  return path.data();
-}
-
-size_t rocksdb_compactionjobinfo_output_files_count(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.output_files.size();
-}
-
-const char* rocksdb_compactionjobinfo_output_file_at(
-    const rocksdb_compactionjobinfo_t* info, size_t pos, size_t* size) {
-  assert(info != nullptr);
-  assert(pos < info->rep.output_files.size());
-
-  const std::string& path = info->rep.output_files[pos];
-  *size = path.size();
-  return path.data();
-}
-
-uint64_t rocksdb_compactionjobinfo_elapsed_micros(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.elapsed_micros;
-}
-
-uint64_t rocksdb_compactionjobinfo_num_corrupt_keys(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_corrupt_keys;
-}
-
-int rocksdb_compactionjobinfo_base_input_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.base_input_level;
-}
-
-int rocksdb_compactionjobinfo_output_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.output_level;
-}
-
-size_t rocksdb_compactionjobinfo_num_input_files(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_files;
-}
-
-size_t rocksdb_compactionjobinfo_num_input_files_at_output_level(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_files_at_output_level;
-}
-
-uint64_t rocksdb_compactionjobinfo_input_records(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_input_records;
-}
-
-uint64_t rocksdb_compactionjobinfo_output_records(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.num_output_records;
-}
-
-uint64_t rocksdb_compactionjobinfo_total_input_bytes(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.total_input_bytes;
-}
-
-uint64_t rocksdb_compactionjobinfo_total_output_bytes(
-    const rocksdb_compactionjobinfo_t* info) {
-  return info->rep.stats.total_output_bytes;
-}
-
-uint32_t rocksdb_compactionjobinfo_compaction_reason(
-    const rocksdb_compactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compaction_reason);
-}
-
-/* SubcompactionJobInfo */
-
-void rocksdb_subcompactionjobinfo_status(
-    const rocksdb_subcompactionjobinfo_t* info, char** errptr) {
-  SaveError(errptr, info->rep.status);
-}
-
-const char* rocksdb_subcompactionjobinfo_cf_name(
-    const rocksdb_subcompactionjobinfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-uint64_t rocksdb_subcompactionjobinfo_thread_id(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.thread_id;
-}
-
-int rocksdb_subcompactionjobinfo_base_input_level(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.base_input_level;
-}
-
-int rocksdb_subcompactionjobinfo_output_level(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return info->rep.output_level;
-}
-
-uint32_t rocksdb_subcompactionjobinfo_compaction_reason(
-    const rocksdb_subcompactionjobinfo_t* info) {
-  return static_cast<uint32_t>(info->rep.compaction_reason);
-}
-
-/* ExternalFileIngestionInfo */
-
-const char* rocksdb_externalfileingestioninfo_cf_name(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const char* rocksdb_externalfileingestioninfo_internal_file_path(
-    const rocksdb_externalfileingestioninfo_t* info, size_t* size) {
-  *size = info->rep.internal_file_path.size();
-  return info->rep.internal_file_path.data();
-}
-
-/* External write stall info */
-extern ROCKSDB_LIBRARY_API const char* rocksdb_writestallinfo_cf_name(
-    const rocksdb_writestallinfo_t* info, size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-const rocksdb_writestallcondition_t* rocksdb_writestallinfo_cur(
-    const rocksdb_writestallinfo_t* info) {
-  return reinterpret_cast<const rocksdb_writestallcondition_t*>(
-      &info->rep.condition.cur);
-}
-
-const rocksdb_writestallcondition_t* rocksdb_writestallinfo_prev(
-    const rocksdb_writestallinfo_t* info) {
-  return reinterpret_cast<const rocksdb_writestallcondition_t*>(
-      &info->rep.condition.prev);
-}
-
-const char* rocksdb_memtableinfo_cf_name(const rocksdb_memtableinfo_t* info,
-                                         size_t* size) {
-  *size = info->rep.cf_name.size();
-  return info->rep.cf_name.data();
-}
-
-uint64_t rocksdb_memtableinfo_first_seqno(const rocksdb_memtableinfo_t* info) {
-  return info->rep.first_seqno;
-}
-uint64_t rocksdb_memtableinfo_earliest_seqno(
-    const rocksdb_memtableinfo_t* info) {
-  return info->rep.earliest_seqno;
-}
-uint64_t rocksdb_memtableinfo_num_entries(const rocksdb_memtableinfo_t* info) {
-  return info->rep.num_entries;
-}
-uint64_t rocksdb_memtableinfo_num_deletes(const rocksdb_memtableinfo_t* info) {
-  return info->rep.num_deletes;
-}
-
-/* event listener */
-
-struct rocksdb_eventlistener_t : public EventListener {
-  void* state_{};
-  void (*destructor_)(void*){};
-  void (*on_flush_begin)(void*, rocksdb_t*, const rocksdb_flushjobinfo_t*){};
-  void (*on_flush_completed)(void*, rocksdb_t*,
-                             const rocksdb_flushjobinfo_t*){};
-  void (*on_compaction_begin)(void*, rocksdb_t*,
-                              const rocksdb_compactionjobinfo_t*){};
-  void (*on_compaction_completed)(void*, rocksdb_t*,
-                                  const rocksdb_compactionjobinfo_t*){};
-  void (*on_subcompaction_begin)(void*,
-                                 const rocksdb_subcompactionjobinfo_t*){};
-  void (*on_subcompaction_completed)(void*,
-                                     const rocksdb_subcompactionjobinfo_t*){};
-  void (*on_external_file_ingested)(
-      void*, rocksdb_t*, const rocksdb_externalfileingestioninfo_t*){};
-  void (*on_background_error)(void*, uint32_t, rocksdb_status_ptr_t*){};
-  void (*on_stall_conditions_changed)(void*, const rocksdb_writestallinfo_t*){};
-  void (*on_memtable_sealed)(void*, const rocksdb_memtableinfo_t*){};
-
-  rocksdb_eventlistener_t() = default;
-
-  rocksdb_eventlistener_t(const rocksdb_eventlistener_t&) = delete;
-  rocksdb_eventlistener_t& operator=(const rocksdb_eventlistener_t&) = delete;
-  rocksdb_eventlistener_t(rocksdb_eventlistener_t&&) = delete;
-  rocksdb_eventlistener_t& operator=(rocksdb_eventlistener_t&&) = delete;
-
-  void OnFlushBegin(DB* db, const FlushJobInfo& info) override {
-    rocksdb_t c_db = {db};
-    on_flush_begin(state_, &c_db,
-                   reinterpret_cast<const rocksdb_flushjobinfo_t*>(&info));
-  }
-
-  void OnFlushCompleted(DB* db, const FlushJobInfo& info) override {
-    rocksdb_t c_db = {db};
-    on_flush_completed(state_, &c_db,
-                       reinterpret_cast<const rocksdb_flushjobinfo_t*>(&info));
-  }
-
-  void OnCompactionBegin(DB* db, const CompactionJobInfo& info) override {
-    rocksdb_t c_db = {db};
-    on_compaction_begin(
-        state_, &c_db,
-        reinterpret_cast<const rocksdb_compactionjobinfo_t*>(&info));
-  }
-
-  void OnCompactionCompleted(DB* db, const CompactionJobInfo& info) override {
-    rocksdb_t c_db = {db};
-    on_compaction_completed(
-        state_, &c_db,
-        reinterpret_cast<const rocksdb_compactionjobinfo_t*>(&info));
-  }
-
-  void OnSubcompactionBegin(const SubcompactionJobInfo& info) override {
-    on_subcompaction_begin(
-        state_, reinterpret_cast<const rocksdb_subcompactionjobinfo_t*>(&info));
-  }
-
-  void OnSubcompactionCompleted(const SubcompactionJobInfo& info) override {
-    on_subcompaction_completed(
-        state_, reinterpret_cast<const rocksdb_subcompactionjobinfo_t*>(&info));
-  }
-
-  void OnExternalFileIngested(DB* db,
-                              const ExternalFileIngestionInfo& info) override {
-    rocksdb_t c_db = {db};
-    on_external_file_ingested(
-        state_, &c_db,
-        reinterpret_cast<const rocksdb_externalfileingestioninfo_t*>(&info));
-  }
-
-  void OnBackgroundError(BackgroundErrorReason reason,
-                         Status* status) override {
-    rocksdb_status_ptr_t* s = new rocksdb_status_ptr_t;
-    s->rep = status;
-    on_background_error(state_, static_cast<uint32_t>(reason), s);
-    delete s;
-  }
-
-  void OnStallConditionsChanged(const WriteStallInfo& info) override {
-    on_stall_conditions_changed(
-        state_, reinterpret_cast<const rocksdb_writestallinfo_t*>(&info));
-  }
-
-  void OnMemTableSealed(const MemTableInfo& info) override {
-    on_memtable_sealed(state_,
-                       reinterpret_cast<const rocksdb_memtableinfo_t*>(&info));
-  }
-
-  ~rocksdb_eventlistener_t() override { destructor_(state_); }
-};
-
-rocksdb_eventlistener_t* rocksdb_eventlistener_create(
-    void* state_, void (*destructor_)(void*), on_flush_begin_cb on_flush_begin,
-    on_flush_completed_cb on_flush_completed,
-    on_compaction_begin_cb on_compaction_begin,
-    on_compaction_completed_cb on_compaction_completed,
-    on_subcompaction_begin_cb on_subcompaction_begin,
-    on_subcompaction_completed_cb on_subcompaction_completed,
-    on_external_file_ingested_cb on_external_file_ingested,
-    on_background_error_cb on_background_error,
-    on_stall_conditions_changed_cb on_stall_conditions_changed,
-    on_memtable_sealed_cb on_memtable_sealed) {
-  rocksdb_eventlistener_t* et = new rocksdb_eventlistener_t;
-  et->state_ = state_;
-  et->destructor_ = destructor_;
-  et->on_flush_begin = on_flush_begin;
-  et->on_flush_completed = on_flush_completed;
-  et->on_compaction_begin = on_compaction_begin;
-  et->on_compaction_completed = on_compaction_completed;
-  et->on_subcompaction_begin = on_subcompaction_begin;
-  et->on_subcompaction_completed = on_subcompaction_completed;
-  et->on_external_file_ingested = on_external_file_ingested;
-  et->on_background_error = on_background_error;
-  et->on_stall_conditions_changed = on_stall_conditions_changed;
-  et->on_memtable_sealed = on_memtable_sealed;
-  return et;
-}
-
-void rocksdb_eventlistener_destroy(rocksdb_eventlistener_t* t) { delete t; }
-
-void rocksdb_options_add_eventlistener(rocksdb_options_t* opt,
-                                       rocksdb_eventlistener_t* t) {
-  opt->rep.listeners.emplace_back(std::shared_ptr<EventListener>(t));
-}
-
 rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create() {
  return new rocksdb_cuckoo_table_options_t;
 }
@@ -3751,26 +3295,6 @@ uint64_t rocksdb_options_get_periodic_compaction_seconds(
  return opt->rep.periodic_compaction_seconds;
 }

-void rocksdb_options_set_memtable_op_scan_flush_trigger(rocksdb_options_t* opt,
-                                                        uint32_t n) {
-  opt->rep.memtable_op_scan_flush_trigger = n;
-}
-
-uint32_t rocksdb_options_get_memtable_op_scan_flush_trigger(
-    rocksdb_options_t* opt) {
-  return opt->rep.memtable_op_scan_flush_trigger;
-}
-
-void rocksdb_options_set_memtable_avg_op_scan_flush_trigger(
-    rocksdb_options_t* opt, uint32_t n) {
-  opt->rep.memtable_avg_op_scan_flush_trigger = n;
-}
-
-uint32_t rocksdb_options_get_memtable_avg_op_scan_flush_trigger(
-    rocksdb_options_t* opt) {
-  return opt->rep.memtable_avg_op_scan_flush_trigger;
-}
-
 void rocksdb_options_enable_statistics(rocksdb_options_t* opt) {
  opt->rep.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
 }
@@ -4280,6 +3804,16 @@ int rocksdb_options_get_min_write_buffer_number_to_merge(
  return opt->rep.min_write_buffer_number_to_merge;
 }

+void rocksdb_options_set_max_write_buffer_number_to_maintain(
+    rocksdb_options_t* opt, int n) {
+  opt->rep.max_write_buffer_number_to_maintain = n;
+}
+
+int rocksdb_options_get_max_write_buffer_number_to_maintain(
+    rocksdb_options_t* opt) {
+  return opt->rep.max_write_buffer_number_to_maintain;
+}
+
 void rocksdb_options_set_max_write_buffer_size_to_maintain(
    rocksdb_options_t* opt, int64_t n) {
  opt->rep.max_write_buffer_size_to_maintain = n;
@@ -4798,8 +4332,6 @@ uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
      return rep->internal_recent_skipped_count;
    case rocksdb_internal_merge_count:
      return rep->internal_merge_count;
-    case rocksdb_internal_merge_point_lookup_count:
-      return rep->internal_merge_point_lookup_count;
    case rocksdb_get_snapshot_time:
      return rep->get_snapshot_time;
    case rocksdb_get_from_memtable_time:
@@ -5707,67 +5239,6 @@ ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_allow_stall(
  wbm->rep->SetAllowStall(new_allow_stall);
 }

-rocksdb_sst_file_manager_t* rocksdb_sst_file_manager_create(
-    rocksdb_env_t* env) {
-  rocksdb_sst_file_manager_t* sfm = new rocksdb_sst_file_manager_t;
-  sfm->rep.reset(ROCKSDB_NAMESPACE::NewSstFileManager(env->rep));
-  return sfm;
-}
-
-void rocksdb_sst_file_manager_destroy(rocksdb_sst_file_manager_t* sfm) {
-  delete sfm;
-}
-
-void rocksdb_sst_file_manager_set_max_allowed_space_usage(
-    rocksdb_sst_file_manager_t* sfm, uint64_t max_allowed_space) {
-  sfm->rep->SetMaxAllowedSpaceUsage(max_allowed_space);
-}
-
-void rocksdb_sst_file_manager_set_compaction_buffer_size(
-    rocksdb_sst_file_manager_t* sfm, uint64_t compaction_buffer_size) {
-  sfm->rep->SetCompactionBufferSize(compaction_buffer_size);
-}
-
-bool rocksdb_sst_file_manager_is_max_allowed_space_reached(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->IsMaxAllowedSpaceReached();
-}
-
-bool rocksdb_sst_file_manager_is_max_allowed_space_reached_including_compactions(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->IsMaxAllowedSpaceReachedIncludingCompactions();
-}
-
-uint64_t rocksdb_sst_file_manager_get_total_size(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->GetTotalSize();
-}
-
-int64_t rocksdb_sst_file_manager_get_delete_rate_bytes_per_second(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->GetDeleteRateBytesPerSecond();
-}
-
-void rocksdb_sst_file_manager_set_delete_rate_bytes_per_second(
-    rocksdb_sst_file_manager_t* sfm, int64_t delete_rate) {
-  return sfm->rep->SetDeleteRateBytesPerSecond(delete_rate);
-}
-
-double rocksdb_sst_file_manager_get_max_trash_db_ratio(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->GetMaxTrashDBRatio();
-}
-
-void rocksdb_sst_file_manager_set_max_trash_db_ratio(
-    rocksdb_sst_file_manager_t* sfm, double ratio) {
-  return sfm->rep->SetMaxTrashDBRatio(ratio);
-}
-
-uint64_t rocksdb_sst_file_manager_get_total_trash_size(
-    rocksdb_sst_file_manager_t* sfm) {
-  return sfm->rep->GetTotalTrashSize();
-}
-
 rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path,
                                        uint64_t target_size) {
  rocksdb_dbpath_t* result = new rocksdb_dbpath_t;
@@ -103,12 +103,6 @@ static void CheckValue(char* err, const char* expected, char** actual,
  Free(actual);
 }

-static void CheckPinnedValue(char* err, const char* expected,
-                             const char** actual, size_t actual_length) {
-  CheckNoError(err);
-  CheckEqual(expected, *actual, actual_length);
-}
-
 static void CheckGet(rocksdb_t* db, const rocksdb_readoptions_t* options,
                     const char* key, const char* expected) {
  char* err = NULL;
@@ -1251,8 +1245,6 @@ int main(int argc, char** argv) {
    CheckCondition(count == 3);
    size_t size;
    char* value;
-    const char* pinned_value;
-    rocksdb_pinnableslice_t* p;
    value = rocksdb_writebatch_wi_get_from_batch(wbi, options, "box", 3, &size,
                                                 &err);
    CheckValue(err, "c", &value, size);
@@ -1262,19 +1254,9 @@ int main(int argc, char** argv) {
    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions,
                                                        "foo", 3, &size, &err);
    CheckValue(err, "hello", &value, size);
-    p = rocksdb_writebatch_wi_get_pinned_from_batch_and_db(wbi, db, roptions,
-                                                           "foo", 3, &err);
-    pinned_value = rocksdb_pinnableslice_value(p, &size);
-    CheckPinnedValue(err, "hello", &pinned_value, size);
-    rocksdb_pinnableslice_destroy(p);
    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions,
                                                        "box", 3, &size, &err);
    CheckValue(err, "c", &value, size);
-    p = rocksdb_writebatch_wi_get_pinned_from_batch_and_db(wbi, db, roptions,
-                                                           "box", 3, &err);
-    pinned_value = rocksdb_pinnableslice_value(p, &size);
-    CheckPinnedValue(err, "c", &pinned_value, size);
-    rocksdb_pinnableslice_destroy(p);
    rocksdb_write_writebatch_wi(db, woptions, wbi, &err);
    CheckNoError(err);
    CheckGet(db, roptions, "foo", "hello");
@@ -1380,46 +1362,6 @@ int main(int argc, char** argv) {
    rocksdb_writebatch_wi_destroy(wbi);
  }

-  StartPhase("wbwi_iter_readoptions");
-  {
-    rocksdb_readoptions_t* iter_roptions = rocksdb_readoptions_create();
-    rocksdb_readoptions_set_iterate_lower_bound(iter_roptions, "boy", 3);
-    rocksdb_readoptions_set_iterate_upper_bound(iter_roptions, "fool", 4);
-    rocksdb_iterator_t* base_iter = rocksdb_create_iterator(db, iter_roptions);
-    rocksdb_writebatch_wi_t* wbi = rocksdb_writebatch_wi_create(0, 1);
-    rocksdb_writebatch_wi_put(wbi, "bar", 3, "b",
-                              1);  // should get filtered out
-    rocksdb_writebatch_wi_put(wbi, "cat", 3, "miau", 4);
-    rocksdb_writebatch_wi_put(wbi, "gnu", 3, "muh",
-                              3);  // should get filtered out
-    rocksdb_iterator_t* iter =
-        rocksdb_writebatch_wi_create_iterator_with_base_readopts(wbi, base_iter,
-                                                                 iter_roptions);
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_seek_to_first(iter);
-    CheckCondition(rocksdb_iter_valid(iter));
-    CheckIter(iter, "cat", "miau");
-    rocksdb_iter_next(iter);
-    CheckIter(iter, "foo", "hello");
-    rocksdb_iter_prev(iter);
-    CheckIter(iter, "cat", "miau");
-    rocksdb_iter_prev(iter);
-    CheckCondition(!rocksdb_iter_valid(iter));
-    rocksdb_iter_seek_to_last(iter);
-    CheckIter(iter, "foo", "hello");
-    rocksdb_iter_seek(iter, "b", 1);
-    CheckIter(iter, "cat", "miau");
-    rocksdb_iter_seek_for_prev(iter, "d", 1);
-    CheckIter(iter, "cat", "miau");
-    rocksdb_iter_seek_for_prev(iter, "fool", 3);
-    CheckIter(iter, "foo", "hello");
-    rocksdb_iter_get_error(iter, &err);
-    CheckNoError(err);
-    rocksdb_iter_destroy(iter);
-    rocksdb_writebatch_wi_destroy(wbi);
-    rocksdb_readoptions_destroy(iter_roptions);
-  }
-
  StartPhase("multiget");
  {
    const char* keys[3] = {"box", "foo", "notfound"};
@@ -1850,35 +1792,6 @@ int main(int argc, char** argv) {
    rocksdb_flush_wal(db, 1, &err);
    CheckNoError(err);

-    // Test WriteBatchWithIndex iteration with Column Family
-    rocksdb_writebatch_wi_t* wbwi = rocksdb_writebatch_wi_create(0, true);
-    rocksdb_writebatch_wi_put_cf(wbwi, handles[1], "boat", 4, "row",
-                                 3);  // should be filtered out
-    rocksdb_writebatch_wi_put_cf(wbwi, handles[1], "buffy", 5, "charmed", 7);
-    rocksdb_writebatch_wi_put_cf(wbwi, handles[1], "bus", 3, "yellow",
-                                 6);  // should be filtered out
-    rocksdb_readoptions_t* iter_roptions = rocksdb_readoptions_create();
-    rocksdb_readoptions_set_iterate_lower_bound(iter_roptions, "bu", 2);
-    rocksdb_readoptions_set_iterate_upper_bound(iter_roptions, "buffz", 5);
-    rocksdb_iterator_t* base_iter =
-        rocksdb_create_iterator_cf(db, iter_roptions, handles[1]);
-    rocksdb_iterator_t* wbwi_iter =
-        rocksdb_writebatch_wi_create_iterator_with_base_cf_readopts(
-            wbwi, base_iter, handles[1], iter_roptions);
-
-    CheckCondition(!rocksdb_iter_valid(wbwi_iter));
-    rocksdb_iter_seek_to_first(wbwi_iter);
-    CheckCondition(rocksdb_iter_valid(wbwi_iter));
-    CheckIter(wbwi_iter, "buff", "rocksdb");
-    rocksdb_iter_next(wbwi_iter);
-    CheckIter(wbwi_iter, "buffy", "charmed");
-    rocksdb_iter_next(wbwi_iter);
-    CheckCondition(!rocksdb_iter_valid(wbwi_iter));
-
-    rocksdb_iter_destroy(wbwi_iter);
-    rocksdb_writebatch_wi_destroy(wbwi);
-    rocksdb_readoptions_destroy(iter_roptions);
-
    const char* keys[3] = {"box", "box", "barfooxx"};
    const rocksdb_column_family_handle_t* get_handles[3] = {
        handles[0], handles[1], handles[1]};
@@ -2216,20 +2129,16 @@ int main(int argc, char** argv) {
    CheckCondition(100000 ==
                   rocksdb_options_get_periodic_compaction_seconds(o));

-    rocksdb_options_set_memtable_op_scan_flush_trigger(o, 100);
-    CheckCondition(100 ==
-                   rocksdb_options_get_memtable_op_scan_flush_trigger(o));
-
-    rocksdb_options_set_memtable_avg_op_scan_flush_trigger(o, 150);
-    CheckCondition(150 ==
-                   rocksdb_options_get_memtable_avg_op_scan_flush_trigger(o));
-
    rocksdb_options_set_ttl(o, 5000);
    CheckCondition(5000 == rocksdb_options_get_ttl(o));

    rocksdb_options_set_skip_stats_update_on_db_open(o, 1);
    CheckCondition(1 == rocksdb_options_get_skip_stats_update_on_db_open(o));

+    rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(o, 1);
+    CheckCondition(
+        1 == rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(o));
+
    rocksdb_options_set_max_write_buffer_number(o, 97);
    CheckCondition(97 == rocksdb_options_get_max_write_buffer_number(o));

@@ -2237,6 +2146,10 @@ int main(int argc, char** argv) {
    CheckCondition(23 ==
                   rocksdb_options_get_min_write_buffer_number_to_merge(o));

+    rocksdb_options_set_max_write_buffer_number_to_maintain(o, 64);
+    CheckCondition(64 ==
+                   rocksdb_options_get_max_write_buffer_number_to_maintain(o));
+
    rocksdb_options_set_max_write_buffer_size_to_maintain(o, 50000);
    CheckCondition(50000 ==
                   rocksdb_options_get_max_write_buffer_size_to_maintain(o));
@@ -2489,9 +2402,13 @@ int main(int argc, char** argv) {
    CheckCondition(2.0 ==
                   rocksdb_options_get_max_bytes_for_level_multiplier(copy));
    CheckCondition(1 == rocksdb_options_get_skip_stats_update_on_db_open(copy));
+    CheckCondition(
+        1 == rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(copy));
    CheckCondition(97 == rocksdb_options_get_max_write_buffer_number(copy));
    CheckCondition(23 ==
                   rocksdb_options_get_min_write_buffer_number_to_merge(copy));
+    CheckCondition(
+        64 == rocksdb_options_get_max_write_buffer_number_to_maintain(copy));
    CheckCondition(50000 ==
                   rocksdb_options_get_max_write_buffer_size_to_maintain(copy));
    CheckCondition(1 == rocksdb_options_get_enable_pipelined_write(copy));
@@ -2655,18 +2572,6 @@ int main(int argc, char** argv) {
    CheckCondition(100000 ==
                   rocksdb_options_get_periodic_compaction_seconds(o));

-    rocksdb_options_set_memtable_op_scan_flush_trigger(copy, 800);
-    CheckCondition(800 ==
-                   rocksdb_options_get_memtable_op_scan_flush_trigger(copy));
-    CheckCondition(100 ==
-                   rocksdb_options_get_memtable_op_scan_flush_trigger(o));
-
-    rocksdb_options_set_memtable_avg_op_scan_flush_trigger(copy, 900);
-    CheckCondition(
-        900 == rocksdb_options_get_memtable_avg_op_scan_flush_trigger(copy));
-    CheckCondition(150 ==
-                   rocksdb_options_get_memtable_avg_op_scan_flush_trigger(o));
-
    rocksdb_options_set_ttl(copy, 8000);
    CheckCondition(8000 == rocksdb_options_get_ttl(copy));
    CheckCondition(5000 == rocksdb_options_get_ttl(o));
@@ -2675,6 +2580,12 @@ int main(int argc, char** argv) {
    CheckCondition(0 == rocksdb_options_get_skip_stats_update_on_db_open(copy));
    CheckCondition(1 == rocksdb_options_get_skip_stats_update_on_db_open(o));

+    rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(copy, 0);
+    CheckCondition(
+        0 == rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(copy));
+    CheckCondition(
+        1 == rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(o));
+
    rocksdb_options_set_max_write_buffer_number(copy, 2000);
    CheckCondition(2000 == rocksdb_options_get_max_write_buffer_number(copy));
    CheckCondition(97 == rocksdb_options_get_max_write_buffer_number(o));
@@ -2685,6 +2596,12 @@ int main(int argc, char** argv) {
    CheckCondition(23 ==
                   rocksdb_options_get_min_write_buffer_number_to_merge(o));

+    rocksdb_options_set_max_write_buffer_number_to_maintain(copy, 128);
+    CheckCondition(
+        128 == rocksdb_options_get_max_write_buffer_number_to_maintain(copy));
+    CheckCondition(64 ==
+                   rocksdb_options_get_max_write_buffer_number_to_maintain(o));
+
    rocksdb_options_set_max_write_buffer_size_to_maintain(copy, 9000);
    CheckCondition(9000 ==
                   rocksdb_options_get_max_write_buffer_size_to_maintain(copy));
@@ -4135,23 +4052,6 @@ int main(int argc, char** argv) {
    rocksdb_cache_destroy(lru);
  }

-  StartPhase("sst_file_manager");
-  {
-    rocksdb_sst_file_manager_t* sst_file_manager;
-    sst_file_manager = rocksdb_sst_file_manager_create(env);
-    rocksdb_sst_file_manager_set_delete_rate_bytes_per_second(sst_file_manager,
-                                                              1);
-    rocksdb_sst_file_manager_set_max_trash_db_ratio(sst_file_manager, 0.75);
-
-    CheckCondition(1 ==
-                   rocksdb_sst_file_manager_get_delete_rate_bytes_per_second(
-                       sst_file_manager));
-    CheckCondition(0.75 == rocksdb_sst_file_manager_get_max_trash_db_ratio(
-                               sst_file_manager));
-
-    rocksdb_sst_file_manager_destroy(sst_file_manager);
-  }
-
  StartPhase("cancel_all_background_work");
  rocksdb_cancel_all_background_work(db, 1);

@@ -110,48 +110,23 @@ void GetInternalTblPropCollFactory(
  }
 }

-Status CheckCompressionSupportedWithManager(
-    CompressionType type, UnownedPtr<CompressionManager> mgr) {
-  if (mgr) {
-    if (!mgr->SupportsCompressionType(type)) {
-      return Status::NotSupported("Compression type " +
-                                  CompressionTypeToString(type) +
-                                  " is not recognized/supported by this "
-                                  "version of CompressionManager " +
-                                  mgr->GetId());
-    }
-  } else {
-    if (!CompressionTypeSupported(type)) {
-      if (type <= kLastBuiltinCompression) {
-        return Status::InvalidArgument("Compression type " +
-                                       CompressionTypeToString(type) +
-                                       " is not linked with the binary.");
-      } else {
-        return Status::NotSupported(
-            "Compression type " + CompressionTypeToString(type) +
-            " is not recognized/supported by built-in CompressionManager.");
-      }
-    }
-  }
-  return Status::OK();
-}
-
 Status CheckCompressionSupported(const ColumnFamilyOptions& cf_options) {
  if (!cf_options.compression_per_level.empty()) {
    for (size_t level = 0; level < cf_options.compression_per_level.size();
         ++level) {
-      Status s = CheckCompressionSupportedWithManager(
-          cf_options.compression_per_level[level],
-          cf_options.compression_manager.get());
-      if (!s.ok()) {
-        return s;
+      if (!CompressionTypeSupported(cf_options.compression_per_level[level])) {
+        return Status::InvalidArgument(
+            "Compression type " +
+            CompressionTypeToString(cf_options.compression_per_level[level]) +
+            " is not linked with the binary.");
      }
    }
  } else {
-    Status s = CheckCompressionSupportedWithManager(
-        cf_options.compression, cf_options.compression_manager.get());
-    if (!s.ok()) {
-      return s;
+    if (!CompressionTypeSupported(cf_options.compression)) {
+      return Status::InvalidArgument(
+          "Compression type " +
+          CompressionTypeToString(cf_options.compression) +
+          " is not linked with the binary.");
    }
  }
  if (cf_options.compression_opts.zstd_max_train_bytes > 0) {
@@ -225,9 +200,8 @@ const uint64_t kDefaultTtl = 0xfffffffffffffffe;
 const uint64_t kDefaultPeriodicCompSecs = 0xfffffffffffffffe;
 }  // anonymous namespace

-ColumnFamilyOptions SanitizeCfOptions(const ImmutableDBOptions& db_options,
-                                      bool read_only,
-                                      const ColumnFamilyOptions& src) {
+ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
+                                    const ColumnFamilyOptions& src) {
  ColumnFamilyOptions result = src;
  size_t clamp_max = std::conditional<
      sizeof(size_t) == 4, std::integral_constant<size_t, 0xffffffff>,
@@ -287,10 +261,15 @@ ColumnFamilyOptions SanitizeCfOptions(const ImmutableDBOptions& db_options,
  if (result.max_write_buffer_number < 2) {
    result.max_write_buffer_number = 2;
  }
+  // fall back max_write_buffer_number_to_maintain if
+  // max_write_buffer_size_to_maintain is not set
  if (result.max_write_buffer_size_to_maintain < 0) {
    result.max_write_buffer_size_to_maintain =
        result.max_write_buffer_number *
        static_cast<int64_t>(result.write_buffer_size);
+  } else if (result.max_write_buffer_size_to_maintain == 0 &&
+             result.max_write_buffer_number_to_maintain < 0) {
+    result.max_write_buffer_number_to_maintain = result.max_write_buffer_number;
  }
  // bloom filter size shouldn't exceed 1/4 of memtable size.
  if (result.memtable_prefix_bloom_size_ratio > 0.25) {
@@ -461,33 +440,6 @@ ColumnFamilyOptions SanitizeCfOptions(const ImmutableDBOptions& db_options,
    result.periodic_compaction_seconds = 0;
  }

-  if (read_only && (result.preserve_internal_time_seconds > 0 ||
-                    result.preclude_last_level_data_seconds > 0)) {
-    // With no writes coming in, we don't need periodic SeqnoToTime entries.
-    // Existing SST files may or may not have that info associated with them.
-    ROCKS_LOG_WARN(
-        db_options.info_log.get(),
-        "preserve_internal_time_seconds and preclude_last_level_data_seconds "
-        "are ignored in read-only DB");
-    result.preserve_internal_time_seconds = 0;
-    result.preclude_last_level_data_seconds = 0;
-  }
-
-  if (read_only) {
-    if (result.memtable_op_scan_flush_trigger) {
-      ROCKS_LOG_WARN(db_options.info_log.get(),
-                     "option memtable_op_scan_flush_trigger is sanitized to "
-                     "0(disabled) for read only DB.");
-      result.memtable_op_scan_flush_trigger = 0;
-    }
-    if (result.memtable_avg_op_scan_flush_trigger) {
-      ROCKS_LOG_WARN(
-          db_options.info_log.get(),
-          "option memtable_avg_op_scan_flush_trigger is sanitized to "
-          "0(disabled) for read only DB.");
-      result.memtable_avg_op_scan_flush_trigger = 0;
-    }
-  }
  return result;
 }

@@ -545,17 +497,6 @@ void SuperVersion::Init(
  imm->Ref();
  current->Ref();
  refs.store(1, std::memory_order_relaxed);
-
-  // There should be at least one mapping entry iff time tracking is enabled.
-#ifndef NDEBUG
-  MinAndMaxPreserveSeconds preserve_info{mutable_cf_options};
-  if (preserve_info.IsEnabled()) {
-    assert(seqno_to_time_mapping);
-    assert(!seqno_to_time_mapping->Empty());
-  } else {
-    assert(seqno_to_time_mapping == nullptr);
-  }
-#endif  // NDEBUG
 }

 namespace {
@@ -594,7 +535,7 @@ ColumnFamilyData::ColumnFamilyData(
    const FileOptions* file_options, ColumnFamilySet* column_family_set,
    BlockCacheTracer* const block_cache_tracer,
    const std::shared_ptr<IOTracer>& io_tracer, const std::string& db_id,
-    const std::string& db_session_id, bool read_only)
+    const std::string& db_session_id)
    : id_(id),
      name_(name),
      dummy_versions_(_dummy_versions),
@@ -604,7 +545,7 @@ ColumnFamilyData::ColumnFamilyData(
      dropped_(false),
      flush_skip_reschedule_(false),
      internal_comparator_(cf_options.comparator),
-      initial_cf_options_(SanitizeCfOptions(db_options, read_only, cf_options)),
+      initial_cf_options_(SanitizeOptions(db_options, cf_options)),
      ioptions_(db_options, initial_cf_options_),
      mutable_cf_options_(initial_cf_options_),
      is_delete_range_supported_(
@@ -612,6 +553,7 @@ ColumnFamilyData::ColumnFamilyData(
      write_buffer_manager_(write_buffer_manager),
      mem_(nullptr),
      imm_(ioptions_.min_write_buffer_number_to_merge,
+           ioptions_.max_write_buffer_number_to_maintain,
           ioptions_.max_write_buffer_size_to_maintain),
      super_version_(nullptr),
      super_version_number_(0),
@@ -1242,12 +1184,10 @@ Compaction* ColumnFamilyData::PickCompaction(
    const MutableCFOptions& mutable_options,
    const MutableDBOptions& mutable_db_options,
    const std::vector<SequenceNumber>& existing_snapshots,
-    const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-    bool require_max_output_level) {
+    const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer) {
  auto* result = compaction_picker_->PickCompaction(
      GetName(), mutable_options, mutable_db_options, existing_snapshots,
-      snapshot_checker, current_->storage_info(), log_buffer,
-      require_max_output_level);
+      snapshot_checker, current_->storage_info(), log_buffer);
  if (result != nullptr) {
    result->FinalizeInputInfo(current_);
  }
@@ -1404,17 +1344,20 @@ bool ColumnFamilyData::ReturnThreadLocalSuperVersion(SuperVersion* sv) {
  return false;
 }

-void ColumnFamilyData::InstallSuperVersion(
-    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex,
-    std::optional<std::shared_ptr<SeqnoToTimeMapping>>
-        new_seqno_to_time_mapping) {
+void ColumnFamilyData::InstallSuperVersion(SuperVersionContext* sv_context,
+                                           InstrumentedMutex* db_mutex) {
  db_mutex->AssertHeld();
+  return InstallSuperVersion(sv_context, mutable_cf_options_);
+}

+void ColumnFamilyData::InstallSuperVersion(
+    SuperVersionContext* sv_context,
+    const MutableCFOptions& mutable_cf_options) {
  SuperVersion* new_superversion = sv_context->new_superversion.release();
-  new_superversion->mutable_cf_options = GetLatestMutableCFOptions();
+  new_superversion->mutable_cf_options = mutable_cf_options;
  new_superversion->Init(this, mem_, imm_.current(), current_,
-                         new_seqno_to_time_mapping.has_value()
-                             ? std::move(new_seqno_to_time_mapping.value())
+                         sv_context->new_seqno_to_time_mapping
+                             ? std::move(sv_context->new_seqno_to_time_mapping)
                         : super_version_
                             ? super_version_->ShareSeqnoToTimeMapping()
                             : nullptr);
@@ -1427,7 +1370,7 @@ void ColumnFamilyData::InstallSuperVersion(
    // currently RecalculateWriteStallConditions() treats it as further slowing
    // down is needed.
    super_version_->write_stall_condition =
-        RecalculateWriteStallConditions(new_superversion->mutable_cf_options);
+        RecalculateWriteStallConditions(mutable_cf_options);
  } else {
    super_version_->write_stall_condition =
        old_superversion->write_stall_condition;
@@ -1440,9 +1383,8 @@ void ColumnFamilyData::InstallSuperVersion(
    ResetThreadLocalSuperVersions();

    if (old_superversion->mutable_cf_options.write_buffer_size !=
-        new_superversion->mutable_cf_options.write_buffer_size) {
-      mem_->UpdateWriteBufferSize(
-          new_superversion->mutable_cf_options.write_buffer_size);
+        mutable_cf_options.write_buffer_size) {
+      mem_->UpdateWriteBufferSize(mutable_cf_options.write_buffer_size);
    }
    if (old_superversion->write_stall_condition !=
        new_superversion->write_stall_condition) {
@@ -1633,8 +1575,6 @@ Status ColumnFamilyData::SetOptions(
  Status s = GetColumnFamilyOptionsFromMap(config_opts, cf_opts, options_map,
                                           &cf_opts);
  if (s.ok()) {
-    // FIXME: we should call SanitizeOptions() too or consolidate it with
-    // ValidateOptions().
    s = ValidateOptions(db_opts, cf_opts);
  }
  if (s.ok()) {
@@ -1745,8 +1685,7 @@ ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
      dummy_cfd_(new ColumnFamilyData(
          ColumnFamilyData::kDummyColumnFamilyDataId, "", nullptr, nullptr,
          nullptr, ColumnFamilyOptions(), *db_options, &file_options_, nullptr,
-          block_cache_tracer, io_tracer, db_id, db_session_id,
-          /*read_only*/ true)),
+          block_cache_tracer, io_tracer, db_id, db_session_id)),
      default_cfd_cache_(nullptr),
      db_name_(dbname),
      db_options_(db_options),
@@ -1818,12 +1757,12 @@ size_t ColumnFamilySet::NumberOfColumnFamilies() const {
 // under a DB mutex AND write thread
 ColumnFamilyData* ColumnFamilySet::CreateColumnFamily(
    const std::string& name, uint32_t id, Version* dummy_versions,
-    const ColumnFamilyOptions& options, bool read_only) {
+    const ColumnFamilyOptions& options) {
  assert(column_families_.find(name) == column_families_.end());
  ColumnFamilyData* new_cfd = new ColumnFamilyData(
      id, name, dummy_versions, table_cache_, write_buffer_manager_, options,
      *db_options_, &file_options_, this, block_cache_tracer_, io_tracer_,
-      db_id_, db_session_id_, read_only);
+      db_id_, db_session_id_);
  column_families_.insert({name, id});
  column_family_data_.insert({id, new_cfd});
  auto ucmp = new_cfd->user_comparator();
@@ -281,9 +281,8 @@ Status CheckConcurrentWritesSupported(const ColumnFamilyOptions& cf_options);
 Status CheckCFPathsSupported(const DBOptions& db_options,
                             const ColumnFamilyOptions& cf_options);

-ColumnFamilyOptions SanitizeCfOptions(const ImmutableDBOptions& db_options,
-                                      bool read_only,
-                                      const ColumnFamilyOptions& src);
+ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
+                                    const ColumnFamilyOptions& src);
 // Wrap user defined table properties collector factories `from cf_options`
 // into internal ones in internal_tbl_prop_coll_factories. Add a system internal
 // one too.
@@ -385,10 +384,10 @@ class ColumnFamilyData {
  Version* dummy_versions() { return dummy_versions_; }
  Version* current() { return current_; }  // REQUIRE: DB mutex held
  void SetCurrent(Version* _current);      // REQUIRE: DB mutex held
-  uint64_t GetNumLiveVersions() const;     // REQUIRE: DB mutex held
-  uint64_t GetTotalSstFilesSize() const;   // REQUIRE: DB mutex held
-  uint64_t GetLiveSstFilesSize() const;    // REQUIRE: DB mutex held
-  uint64_t GetTotalBlobFileSize() const;   // REQUIRE: DB mutex held
+  uint64_t GetNumLiveVersions() const;    // REQUIRE: DB mutex held
+  uint64_t GetTotalSstFilesSize() const;  // REQUIRE: DB mutex held
+  uint64_t GetLiveSstFilesSize() const;   // REQUIRE: DB mutex held
+  uint64_t GetTotalBlobFileSize() const;  // REQUIRE: DB mutex held
  // REQUIRE: DB mutex held
  void SetMemtable(MemTable* new_mem) {
    AssignMemtableID(new_mem);
@@ -424,8 +423,7 @@ class ColumnFamilyData {
      const MutableCFOptions& mutable_options,
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& existing_snapshots,
-      const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
-      bool require_max_output_level = false);
+      const SnapshotChecker* snapshot_checker, LogBuffer* log_buffer);

  // Check if the passed range overlap with any running compactions.
  // REQUIRES: DB mutex held
@@ -492,11 +490,15 @@ class ColumnFamilyData {
  uint64_t GetSuperVersionNumberRelaxed() const {
    return super_version_number_.load(std::memory_order_relaxed);
  }
-  // Only intended for use by DBImpl::InstallSuperVersion() and variants
+  // will return a pointer to SuperVersion* if previous SuperVersion
+  // if its reference count is zero and needs deletion or nullptr if not
+  // As argument takes a pointer to allocated SuperVersion to enable
+  // the clients to allocate SuperVersion outside of mutex.
+  // IMPORTANT: Only call this from DBImpl::InstallSuperVersion()
  void InstallSuperVersion(SuperVersionContext* sv_context,
-                           InstrumentedMutex* db_mutex,
-                           std::optional<std::shared_ptr<SeqnoToTimeMapping>>
-                               new_seqno_to_time_mapping = {});
+                           const MutableCFOptions& mutable_cf_options);
+  void InstallSuperVersion(SuperVersionContext* sv_context,
+                           InstrumentedMutex* db_mutex);

  void ResetThreadLocalSuperVersions();

@@ -538,12 +540,6 @@ class ColumnFamilyData {
    assert(!ts_low.empty());
    const Comparator* ucmp = user_comparator();
    assert(ucmp);
-    // Guard against resurrected full_history_ts_low persisted in MANIFEST
-    // from previous DB sessions. This could happen if UDT was enabled and then
-    // disabled.
-    if (ucmp->timestamp_size() == 0) {
-      return;
-    }
    if (full_history_ts_low_.empty() ||
        ucmp->CompareTimestamp(ts_low, full_history_ts_low_) > 0) {
      full_history_ts_low_ = std::move(ts_low);
@@ -551,11 +547,6 @@ class ColumnFamilyData {
  }

  const std::string& GetFullHistoryTsLow() const {
-    const Comparator* ucmp = user_comparator();
-    assert(ucmp);
-    if (ucmp->timestamp_size() == 0) {
-      assert(full_history_ts_low_.empty());
-    }
    return full_history_ts_low_;
  }

@@ -602,14 +593,16 @@ class ColumnFamilyData {

 private:
  friend class ColumnFamilySet;
-  ColumnFamilyData(
-      uint32_t id, const std::string& name, Version* dummy_versions,
-      Cache* table_cache, WriteBufferManager* write_buffer_manager,
-      const ColumnFamilyOptions& options, const ImmutableDBOptions& db_options,
-      const FileOptions* file_options, ColumnFamilySet* column_family_set,
-      BlockCacheTracer* const block_cache_tracer,
-      const std::shared_ptr<IOTracer>& io_tracer, const std::string& db_id,
-      const std::string& db_session_id, bool read_only);
+  ColumnFamilyData(uint32_t id, const std::string& name,
+                   Version* dummy_versions, Cache* table_cache,
+                   WriteBufferManager* write_buffer_manager,
+                   const ColumnFamilyOptions& options,
+                   const ImmutableDBOptions& db_options,
+                   const FileOptions* file_options,
+                   ColumnFamilySet* column_family_set,
+                   BlockCacheTracer* const block_cache_tracer,
+                   const std::shared_ptr<IOTracer>& io_tracer,
+                   const std::string& db_id, const std::string& db_session_id);

  std::vector<std::string> GetDbPaths() const;

@@ -771,8 +764,7 @@ class ColumnFamilySet {

  ColumnFamilyData* CreateColumnFamily(const std::string& name, uint32_t id,
                                       Version* dummy_version,
-                                       const ColumnFamilyOptions& options,
-                                       bool read_only);
+                                       const ColumnFamilyOptions& options);

  const UnorderedMap<uint32_t, size_t>& GetRunningColumnFamiliesTimestampSize()
      const {
@@ -72,6 +72,7 @@ class ColumnFamilyTestBase : public testing::Test {
    env_->skip_fsync_ = true;
    dbname_ = test::PerThreadDBPath("column_family_test");
    db_options_.create_if_missing = true;
+    db_options_.fail_if_options_file_error = true;
    db_options_.env = env_;
  }

@@ -270,8 +271,7 @@ class ColumnFamilyTestBase : public testing::Test {
      // them.
      ASSERT_OK(RocksDBOptionsParser::VerifyCFOptions(
          ConfigOptions(), desc.options,
-          SanitizeCfOptions(dbfull()->immutable_db_options(),
-                            /*read_only*/ false, current_cf_opt)));
+          SanitizeOptions(dbfull()->immutable_db_options(), current_cf_opt)));
      cfi++;
    }
  }
@@ -2175,7 +2175,7 @@ TEST_P(ColumnFamilyTest, FlushStaleColumnFamilies) {
  ASSERT_TRUE(has_cf2_sst);

  ASSERT_OK(Flush(0));
-  ASSERT_EQ(0, dbfull()->TEST_wals_total_size());
+  ASSERT_EQ(0, dbfull()->TEST_total_log_size());
  Close();
 }

@@ -2232,7 +2232,7 @@ TEST_P(ColumnFamilyTest, CreateMissingColumnFamilies) {
  ASSERT_EQ(my_fs->options_files_created.load(), 2);
 }

-TEST_P(ColumnFamilyTest, SanitizeCfOptions) {
+TEST_P(ColumnFamilyTest, SanitizeOptions) {
  DBOptions db_options;
  for (int s = kCompactionStyleLevel; s <= kCompactionStyleUniversal; ++s) {
    for (int l = 0; l <= 2; l++) {
@@ -2248,8 +2248,8 @@ TEST_P(ColumnFamilyTest, SanitizeCfOptions) {
            original.write_buffer_size =
                l * 4 * 1024 * 1024 + i * 1024 * 1024 + j * 1024 + k;

-            ColumnFamilyOptions result = SanitizeCfOptions(
-                ImmutableDBOptions(db_options), /*read_only*/ false, original);
+            ColumnFamilyOptions result =
+                SanitizeOptions(ImmutableDBOptions(db_options), original);
            ASSERT_TRUE(result.level0_stop_writes_trigger >=
                        result.level0_slowdown_writes_trigger);
            ASSERT_TRUE(result.level0_slowdown_writes_trigger >=
@@ -284,9 +284,9 @@ Compaction::Compaction(
    CompressionOptions _compression_opts, Temperature _output_temperature,
    uint32_t _max_subcompactions, std::vector<FileMetaData*> _grandparents,
    std::optional<SequenceNumber> _earliest_snapshot,
-    const SnapshotChecker* _snapshot_checker,
-    CompactionReason _compaction_reason, const std::string& _trim_ts,
-    double _score, bool l0_files_might_overlap,
+    const SnapshotChecker* _snapshot_checker, bool _manual_compaction,
+    const std::string& _trim_ts, double _score, bool _deletion_compaction,
+    bool l0_files_might_overlap, CompactionReason _compaction_reason,
    BlobGarbageCollectionPolicy _blob_garbage_collection_policy,
    double _blob_garbage_collection_age_cutoff)
    : input_vstorage_(vstorage),
@@ -304,9 +304,7 @@ Compaction::Compaction(
      output_compression_(_compression),
      output_compression_opts_(_compression_opts),
      output_temperature_(_output_temperature),
-      deletion_compaction_(_compaction_reason == CompactionReason::kFIFOTtl ||
-                           _compaction_reason ==
-                               CompactionReason::kFIFOMaxSize),
+      deletion_compaction_(_deletion_compaction),
      l0_files_might_overlap_(l0_files_might_overlap),
      inputs_(PopulateWithAtomicBoundaries(vstorage, std::move(_inputs))),
      grandparents_(std::move(_grandparents)),
@@ -323,8 +321,7 @@ Compaction::Compaction(
              ? false
              : IsBottommostLevel(output_level_, vstorage, inputs_)),
      is_full_compaction_(IsFullCompaction(vstorage, inputs_)),
-      is_manual_compaction_(_compaction_reason ==
-                            CompactionReason::kManualCompaction),
+      is_manual_compaction_(_manual_compaction),
      trim_ts_(_trim_ts),
      is_trivial_move_(false),
      compaction_reason_(_compaction_reason),
@@ -341,17 +338,20 @@ Compaction::Compaction(
                  _blob_garbage_collection_age_cutoff > 1
              ? mutable_cf_options().blob_garbage_collection_age_cutoff
              : _blob_garbage_collection_age_cutoff),
-      proximal_level_(
-          // For simplicity, we don't support the concept of "proximal level"
+      penultimate_level_(
+          // For simplicity, we don't support the concept of "penultimate level"
          // with `CompactionReason::kExternalSstIngestion` and
          // `CompactionReason::kRefitLevel`
          _compaction_reason == CompactionReason::kExternalSstIngestion ||
                  _compaction_reason == CompactionReason::kRefitLevel
              ? Compaction::kInvalidLevel
-              : EvaluateProximalLevel(vstorage, mutable_cf_options_,
-                                      immutable_options_, start_level_,
-                                      output_level_)) {
+              : EvaluatePenultimateLevel(vstorage, mutable_cf_options_,
+                                         immutable_options_, start_level_,
+                                         output_level_)) {
  MarkFilesBeingCompacted(true);
+  if (is_manual_compaction_) {
+    compaction_reason_ = CompactionReason::kManualCompaction;
+  }
  if (max_subcompactions_ == 0) {
    max_subcompactions_ = _mutable_db_options.max_subcompactions;
  }
@@ -405,10 +405,10 @@ Compaction::Compaction(
    }
  }

-  PopulateProximalLevelOutputRange();
+  PopulatePenultimateLevelOutputRange();
 }

-void Compaction::PopulateProximalLevelOutputRange() {
+void Compaction::PopulatePenultimateLevelOutputRange() {
  if (!SupportsPerKeyPlacement()) {
    assert(keep_in_last_level_through_seqno_ == kMaxSequenceNumber);
    return;
@@ -417,42 +417,46 @@ void Compaction::PopulateProximalLevelOutputRange() {
  // exclude the last level, the range of all input levels is the safe range
  // of keys that can be moved up.
  int exclude_level = number_levels_ - 1;
-  proximal_output_range_type_ = ProximalOutputRangeType::kNonLastRange;
+  penultimate_output_range_type_ = PenultimateOutputRangeType::kNonLastRange;

-  // For universal compaction, the proximal_output_range could be extended if
-  // all proximal level files are included in the compaction (which includes
-  // the case that the proximal level is empty).
+  // For universal compaction, the penultimate_output_range could be extended if
+  // all penultimate level files are included in the compaction (which includes
+  // the case that the penultimate level is empty).
  if (immutable_options_.compaction_style == kCompactionStyleUniversal) {
    exclude_level = kInvalidLevel;
-    proximal_output_range_type_ = ProximalOutputRangeType::kFullRange;
-    std::set<uint64_t> proximal_inputs;
+    penultimate_output_range_type_ = PenultimateOutputRangeType::kFullRange;
+    std::set<uint64_t> penultimate_inputs;
    for (const auto& input_lvl : inputs_) {
-      if (input_lvl.level == proximal_level_) {
+      if (input_lvl.level == penultimate_level_) {
        for (const auto& file : input_lvl.files) {
-          proximal_inputs.emplace(file->fd.GetNumber());
+          penultimate_inputs.emplace(file->fd.GetNumber());
        }
      }
    }
-    auto proximal_files = input_vstorage_->LevelFiles(proximal_level_);
-    for (const auto& file : proximal_files) {
-      if (proximal_inputs.find(file->fd.GetNumber()) == proximal_inputs.end()) {
+    auto penultimate_files = input_vstorage_->LevelFiles(penultimate_level_);
+    for (const auto& file : penultimate_files) {
+      if (penultimate_inputs.find(file->fd.GetNumber()) ==
+          penultimate_inputs.end()) {
        exclude_level = number_levels_ - 1;
-        proximal_output_range_type_ = ProximalOutputRangeType::kNonLastRange;
+        penultimate_output_range_type_ =
+            PenultimateOutputRangeType::kNonLastRange;
        break;
      }
    }
  }

-  // FIXME: should make use of `proximal_output_range_type_`.
+  // FIXME: should make use of `penultimate_output_range_type_`.
  // FIXME: when last level's input range does not overlap with
-  //  proximal level, and proximal level input is empty,
-  //  this call will not set proximal_level_smallest_ or
-  //  proximal_level_largest_. No keys will be compacted up.
-  GetBoundaryInternalKeys(input_vstorage_, inputs_, &proximal_level_smallest_,
-                          &proximal_level_largest_, exclude_level);
+  //  penultimate level, and penultimate level input is empty,
+  //  this call will not set penultimate_level_smallest_ or
+  //  penultimate_level_largest_. No keys will be compacted up.
+  GetBoundaryInternalKeys(input_vstorage_, inputs_,
+                          &penultimate_level_smallest_,
+                          &penultimate_level_largest_, exclude_level);

-  if (proximal_output_range_type_ != ProximalOutputRangeType::kFullRange) {
-    // If not full range in proximal level, must keep everything already
+  if (penultimate_output_range_type_ !=
+      PenultimateOutputRangeType::kFullRange) {
+    // If not full range in penultimate level, must keep everything already
    // in the last level there, because moving it back up might cause
    // overlap/placement issues that are difficult to resolve properly in the
    // presence of range deletes
@@ -482,23 +486,23 @@ Compaction::~Compaction() {
 }

 bool Compaction::SupportsPerKeyPlacement() const {
-  return proximal_level_ != kInvalidLevel;
+  return penultimate_level_ != kInvalidLevel;
 }

-int Compaction::GetProximalLevel() const { return proximal_level_; }
+int Compaction::GetPenultimateLevel() const { return penultimate_level_; }

 // smallest_key and largest_key include timestamps if user-defined timestamp is
 // enabled.
-bool Compaction::OverlapProximalLevelOutputRange(
+bool Compaction::OverlapPenultimateLevelOutputRange(
    const Slice& smallest_key, const Slice& largest_key) const {
  if (!SupportsPerKeyPlacement()) {
    return false;
  }

-  // See FIXME in Compaction::PopulateProximalLevelOutputRange().
+  // See FIXME in Compaction::PopulatePenultimateLevelOutputRange().
  // We do not compact any key up in this case.
-  if (proximal_level_smallest_.size() == 0 ||
-      proximal_level_largest_.size() == 0) {
+  if (penultimate_level_smallest_.size() == 0 ||
+      penultimate_level_largest_.size() == 0) {
    return false;
  }

@@ -506,13 +510,13 @@ bool Compaction::OverlapProximalLevelOutputRange(
      input_vstorage_->InternalComparator()->user_comparator();

  return ucmp->CompareWithoutTimestamp(
-             smallest_key, proximal_level_largest_.user_key()) <= 0 &&
+             smallest_key, penultimate_level_largest_.user_key()) <= 0 &&
         ucmp->CompareWithoutTimestamp(
-             largest_key, proximal_level_smallest_.user_key()) >= 0;
+             largest_key, penultimate_level_smallest_.user_key()) >= 0;
 }

 // key includes timestamp if user-defined timestamp is enabled.
-void Compaction::TEST_AssertWithinProximalLevelOutputRange(
+void Compaction::TEST_AssertWithinPenultimateLevelOutputRange(
    const Slice& user_key, bool expect_failure) const {
 #ifdef NDEBUG
  (void)user_key;
@@ -520,15 +524,15 @@ void Compaction::TEST_AssertWithinProximalLevelOutputRange(
 #else
  assert(SupportsPerKeyPlacement());

-  assert(proximal_level_smallest_.size() > 0);
-  assert(proximal_level_largest_.size() > 0);
+  assert(penultimate_level_smallest_.size() > 0);
+  assert(penultimate_level_largest_.size() > 0);

  auto* cmp = input_vstorage_->user_comparator();

  // op_type of a key can change during compaction, e.g. Merge -> Put.
-  if (!(cmp->Compare(user_key, proximal_level_smallest_.user_key()) >= 0)) {
+  if (!(cmp->Compare(user_key, penultimate_level_smallest_.user_key()) >= 0)) {
    assert(expect_failure);
-  } else if (!(cmp->Compare(user_key, proximal_level_largest_.user_key()) <=
+  } else if (!(cmp->Compare(user_key, penultimate_level_largest_.user_key()) <=
               0)) {
    assert(expect_failure);
  } else {
@@ -1014,7 +1018,7 @@ uint64_t Compaction::MinInputFileEpochNumber() const {
  return min_epoch_number;
 }

-int Compaction::EvaluateProximalLevel(
+int Compaction::EvaluatePenultimateLevel(
    const VersionStorageInfo* vstorage,
    const MutableCFOptions& mutable_cf_options,
    const ImmutableOptions& immutable_options, const int start_level,
@@ -1029,21 +1033,21 @@ int Compaction::EvaluateProximalLevel(
    return kInvalidLevel;
  }

-  int proximal_level = output_level - 1;
-  assert(proximal_level < immutable_options.num_levels);
-  if (proximal_level <= 0) {
+  int penultimate_level = output_level - 1;
+  assert(penultimate_level < immutable_options.num_levels);
+  if (penultimate_level <= 0) {
    return kInvalidLevel;
  }

-  // If the proximal level is not within input level -> output level range
-  // check if the proximal output level is empty, if it's empty, it could
-  // also be locked for the proximal output.
+  // If the penultimate level is not within input level -> output level range
+  // check if the penultimate output level is empty, if it's empty, it could
+  // also be locked for the penultimate output.
  // TODO: ideally, it only needs to check if there's a file within the
  //  compaction output key range. For simplicity, it just check if there's any
-  //  file on the proximal level.
+  //  file on the penultimate level.
  if (start_level == immutable_options.num_levels - 1 &&
      (immutable_options.compaction_style != kCompactionStyleUniversal ||
-       !vstorage->LevelFiles(proximal_level).empty())) {
+       !vstorage->LevelFiles(penultimate_level).empty())) {
    return kInvalidLevel;
  }

@@ -1057,7 +1061,7 @@ int Compaction::EvaluateProximalLevel(
    return kInvalidLevel;
  }

-  return proximal_level;
+  return penultimate_level;
 }

 void Compaction::FilterInputsForCompactionIterator() {
@@ -94,20 +94,21 @@ class Compaction {
             std::vector<FileMetaData*> grandparents,
             std::optional<SequenceNumber> earliest_snapshot,
             const SnapshotChecker* snapshot_checker,
-             CompactionReason compaction_reason,
-             const std::string& trim_ts = "", double score = -1,
+             bool manual_compaction = false, const std::string& trim_ts = "",
+             double score = -1, bool deletion_compaction = false,
             bool l0_files_might_overlap = true,
+             CompactionReason compaction_reason = CompactionReason::kUnknown,
             BlobGarbageCollectionPolicy blob_garbage_collection_policy =
                 BlobGarbageCollectionPolicy::kUseDefault,
             double blob_garbage_collection_age_cutoff = -1);

-  // The type of the proximal level output range
-  enum class ProximalOutputRangeType : int {
-    kNotSupported,  // it cannot output to the proximal level
-    kFullRange,     // any data could be output to the proximal level
+  // The type of the penultimate level output range
+  enum class PenultimateOutputRangeType : int {
+    kNotSupported,  // it cannot output to the penultimate level
+    kFullRange,     // any data could be output to the penultimate level
    kNonLastRange,  // only the keys within non_last_level compaction inputs can
-                    // be outputted to the proximal level
-    kDisabled,      // no data can be outputted to the proximal level
+                    // be outputted to the penultimate level
+    kDisabled,      // no data can be outputted to the penultimate level
  };

  // No copying allowed
@@ -282,13 +283,6 @@ class Compaction {
  // are non-overlapping and can be trivially moved.
  bool is_trivial_move() const { return is_trivial_move_; }

-  bool is_trivial_copy_compaction() const {
-    return immutable_options_.compaction_style == kCompactionStyleFIFO &&
-           compaction_reason_ == CompactionReason::kChangeTemperature &&
-           mutable_cf_options_.compaction_options_fifo
-               .allow_trivial_copy_when_change_temperature;
-  }
-
  // How many total levels are there?
  int number_levels() const { return number_levels_; }

@@ -376,29 +370,29 @@ class Compaction {

  Slice GetLargestUserKey() const { return largest_user_key_; }

-  ProximalOutputRangeType GetProximalOutputRangeType() const {
-    return proximal_output_range_type_;
+  PenultimateOutputRangeType GetPenultimateOutputRangeType() const {
+    return penultimate_output_range_type_;
  }

  // Return true if the compaction supports per_key_placement
  bool SupportsPerKeyPlacement() const;

-  // Get per_key_placement proximal output level, which is `last_level - 1`
+  // Get per_key_placement penultimate output level, which is `last_level - 1`
  // if per_key_placement feature is supported. Otherwise, return -1.
-  int GetProximalLevel() const;
+  int GetPenultimateLevel() const;

-  // Return true if the given range is overlap with proximal level output
+  // Return true if the given range is overlap with penultimate level output
  // range.
  // Both smallest_key and largest_key include timestamps if user-defined
  // timestamp is enabled.
-  bool OverlapProximalLevelOutputRange(const Slice& smallest_key,
-                                       const Slice& largest_key) const;
+  bool OverlapPenultimateLevelOutputRange(const Slice& smallest_key,
+                                          const Slice& largest_key) const;

-  // For testing purposes, check that a key is within proximal level
+  // For testing purposes, check that a key is within penultimate level
  // output range for per_key_placement feature, which is safe to place the key
-  // to the proximal level. Different compaction strategies have different
+  // to the penultimate level. Different compaction strategies have different
  // rules. `user_key` includes timestamp if user-defined timestamp is enabled.
-  void TEST_AssertWithinProximalLevelOutputRange(
+  void TEST_AssertWithinPenultimateLevelOutputRange(
      const Slice& user_key, bool expect_failure = false) const;

  CompactionReason compaction_reason() const { return compaction_reason_; }
@@ -447,25 +441,20 @@ class Compaction {

  static constexpr int kInvalidLevel = -1;

-  // Evaluate proximal output level. If the compaction supports
-  // per_key_placement feature, it returns the proximal level number.
+  // Evaluate penultimate output level. If the compaction supports
+  // per_key_placement feature, it returns the penultimate level number.
  // Otherwise, it's set to kInvalidLevel (-1), which means
-  // output_to_proximal_level is not supported.
-  // Note: even the proximal level output is supported (ProximalLevel !=
+  // output_to_penultimate_level is not supported.
+  // Note: even the penultimate level output is supported (PenultimateLevel !=
  // kInvalidLevel), some key range maybe unsafe to be outputted to the
-  // proximal level. The safe key range is populated by
-  // `PopulateProximalLevelOutputRange()`.
-  // Which could potentially disable all proximal level output.
-  static int EvaluateProximalLevel(const VersionStorageInfo* vstorage,
-                                   const MutableCFOptions& mutable_cf_options,
-                                   const ImmutableOptions& immutable_options,
-                                   const int start_level,
-                                   const int output_level);
-
-  static bool OutputToNonZeroMaxOutputLevel(int output_level,
-                                            int max_output_level) {
-    return output_level > 0 && output_level == max_output_level;
-  }
+  // penultimate level. The safe key range is populated by
+  // `PopulatePenultimateLevelOutputRange()`.
+  // Which could potentially disable all penultimate level output.
+  static int EvaluatePenultimateLevel(
+      const VersionStorageInfo* vstorage,
+      const MutableCFOptions& mutable_cf_options,
+      const ImmutableOptions& immutable_options, const int start_level,
+      const int output_level);

  // If some data cannot be safely migrated "up" the LSM tree due to a change
  // in the preclude_last_level_data_seconds setting, this indicates a sequence
@@ -493,10 +482,10 @@ class Compaction {
      InternalKey* smallest_key, InternalKey* largest_key,
      int exclude_level = -1);

-  // populate proximal level output range, which will be used to determine if
-  // a key is safe to output to the proximal level (details see
-  // `Compaction::WithinProximalLevelOutputRange()`.
-  void PopulateProximalLevelOutputRange();
+  // populate penultimate level output range, which will be used to determine if
+  // a key is safe to output to the penultimate level (details see
+  // `Compaction::WithinPenultimateLevelOutputRange()`.
+  void PopulatePenultimateLevelOutputRange();

  // If oldest snapshot is specified at Compaction construction time, we have
  // an opportunity to optimize inputs for compaction iterator for this case:
@@ -627,20 +616,20 @@ class Compaction {

  // only set when per_key_placement feature is enabled, -1 (kInvalidLevel)
  // means not supported.
-  const int proximal_level_;
+  const int penultimate_level_;

-  // Key range for proximal level output
+  // Key range for penultimate level output
  // includes timestamp if user-defined timestamp is enabled.
-  // proximal_output_range_type_ shows the range type
-  InternalKey proximal_level_smallest_;
-  InternalKey proximal_level_largest_;
-  ProximalOutputRangeType proximal_output_range_type_ =
-      ProximalOutputRangeType::kNotSupported;
+  // penultimate_output_range_type_ shows the range type
+  InternalKey penultimate_level_smallest_;
+  InternalKey penultimate_level_largest_;
+  PenultimateOutputRangeType penultimate_output_range_type_ =
+      PenultimateOutputRangeType::kNotSupported;
 };

 #ifndef NDEBUG
 // Helper struct only for tests, which contains the data to decide if a key
-// should be output to the proximal level.
+// should be output to the penultimate level.
 // TODO: remove this when the public feature knob is available
 struct PerKeyPlacementContext {
  const int level;
@@ -648,16 +637,16 @@ struct PerKeyPlacementContext {
  const Slice value;
  const SequenceNumber seq_num;

-  bool& output_to_proximal_level;
+  bool& output_to_penultimate_level;

  PerKeyPlacementContext(int _level, Slice _key, Slice _value,
                         SequenceNumber _seq_num,
-                         bool& _output_to_proximal_level)
+                         bool& _output_to_penultimate_level)
      : level(_level),
        key(_key),
        value(_value),
        seq_num(_seq_num),
-        output_to_proximal_level(_output_to_proximal_level) {}
+        output_to_penultimate_level(_output_to_penultimate_level) {}
 };
 #endif /* !NDEBUG */

@@ -109,16 +109,16 @@ const char* GetCompactionReasonString(CompactionReason compaction_reason) {
  }
 }

-const char* GetCompactionProximalOutputRangeTypeString(
-    Compaction::ProximalOutputRangeType range_type) {
+const char* GetCompactionPenultimateOutputRangeTypeString(
+    Compaction::PenultimateOutputRangeType range_type) {
  switch (range_type) {
-    case Compaction::ProximalOutputRangeType::kNotSupported:
+    case Compaction::PenultimateOutputRangeType::kNotSupported:
      return "NotSupported";
-    case Compaction::ProximalOutputRangeType::kFullRange:
+    case Compaction::PenultimateOutputRangeType::kFullRange:
      return "FullRange";
-    case Compaction::ProximalOutputRangeType::kNonLastRange:
+    case Compaction::PenultimateOutputRangeType::kNonLastRange:
      return "NonLastRange";
-    case Compaction::ProximalOutputRangeType::kDisabled:
+    case Compaction::PenultimateOutputRangeType::kDisabled:
      return "Disabled";
    default:
      assert(false);
@@ -133,7 +133,10 @@ CompactionJob::CompactionJob(
    LogBuffer* log_buffer, FSDirectory* db_directory,
    FSDirectory* output_directory, FSDirectory* blob_output_directory,
    Statistics* stats, InstrumentedMutex* db_mutex,
-    ErrorHandler* db_error_handler, JobContext* job_context,
+    ErrorHandler* db_error_handler,
+    std::vector<SequenceNumber> existing_snapshots,
+    SequenceNumber earliest_write_conflict_snapshot,
+    const SnapshotChecker* snapshot_checker, JobContext* job_context,
    std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
    bool paranoid_file_checks, bool measure_io_stats, const std::string& dbname,
    CompactionJobStats* compaction_job_stats, Env::Priority thread_pri,
@@ -144,7 +147,7 @@ CompactionJob::CompactionJob(
    BlobFileCompletionCallback* blob_callback, int* bg_compaction_scheduled,
    int* bg_bottom_compaction_scheduled)
    : compact_(new CompactionState(compaction)),
-      internal_stats_(compaction->compaction_reason(), 1),
+      compaction_stats_(compaction->compaction_reason(), 1),
      db_options_(db_options),
      mutable_db_options_copy_(mutable_db_options),
      log_buffer_(log_buffer),
@@ -152,7 +155,7 @@ CompactionJob::CompactionJob(
      stats_(stats),
      bottommost_level_(false),
      write_hint_(Env::WLTH_NOT_SET),
-      job_stats_(compaction_job_stats),
+      compaction_job_stats_(compaction_job_stats),
      job_id_(job_id),
      dbname_(dbname),
      db_id_(db_id),
@@ -170,7 +173,12 @@ CompactionJob::CompactionJob(
      blob_output_directory_(blob_output_directory),
      db_mutex_(db_mutex),
      db_error_handler_(db_error_handler),
-      earliest_snapshot_(job_context->GetEarliestSnapshotSequence()),
+      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),
      table_cache_(std::move(table_cache)),
      event_logger_(event_logger),
@@ -183,9 +191,8 @@ CompactionJob::CompactionJob(
      extra_num_subcompaction_threads_reserved_(0),
      bg_compaction_scheduled_(bg_compaction_scheduled),
      bg_bottom_compaction_scheduled_(bg_bottom_compaction_scheduled) {
-  assert(job_stats_ != nullptr);
+  assert(compaction_job_stats_ != nullptr);
  assert(log_buffer_ != nullptr);
-  assert(job_context->snapshot_context_initialized);

  const auto* cfd = compact_->compaction->column_family_data();
  ThreadStatusUtil::SetEnableTracking(db_options_.enable_thread_tracking);
@@ -217,9 +224,10 @@ void CompactionJob::ReportStartedCompaction(Compaction* compaction) {
      ThreadStatus::COMPACTION_PROP_FLAGS,
      compaction->is_manual_compaction() +
          (compaction->deletion_compaction() << 1));
-  auto total_input_bytes = compaction->CalculateTotalInputSize();
+
  ThreadStatusUtil::SetThreadOperationProperty(
-      ThreadStatus::COMPACTION_TOTAL_INPUT_BYTES, total_input_bytes);
+      ThreadStatus::COMPACTION_TOTAL_INPUT_BYTES,
+      compaction->CalculateTotalInputSize());

  IOSTATS_RESET(bytes_written);
  IOSTATS_RESET(bytes_read);
@@ -232,18 +240,9 @@ void CompactionJob::ReportStartedCompaction(Compaction* compaction) {
  // to ensure GetThreadList() can always show them all together.
  ThreadStatusUtil::SetThreadOperation(ThreadStatus::OP_COMPACTION);

-  job_stats_->is_manual_compaction = compaction->is_manual_compaction();
-  job_stats_->is_full_compaction = compaction->is_full_compaction();
-  // populate compaction stats num_input_files and total_num_of_bytes
-  size_t num_input_files = 0;
-  for (int input_level = 0;
-       input_level < static_cast<int>(compaction->num_input_levels());
-       ++input_level) {
-    const LevelFilesBrief* flevel = compaction->input_levels(input_level);
-    num_input_files += flevel->num_files;
-  }
-  job_stats_->CompactionJobStats::num_input_files = num_input_files;
-  job_stats_->total_input_bytes = total_input_bytes;
+  compaction_job_stats_->is_manual_compaction =
+      compaction->is_manual_compaction();
+  compaction_job_stats_->is_full_compaction = compaction->is_full_compaction();
 }

 void CompactionJob::Prepare(
@@ -261,8 +260,7 @@ void CompactionJob::Prepare(
  assert(storage_info);
  assert(storage_info->NumLevelFiles(compact_->compaction->level()) > 0);

-  write_hint_ = storage_info->CalculateSSTWriteHint(
-      c->output_level(), db_options_.calculate_sst_write_lifetime_hint_set);
+  write_hint_ = storage_info->CalculateSSTWriteHint(c->output_level());
  bottommost_level_ = c->bottommost_level();

  if (!known_single_subcompact.has_value() && c->ShouldFormSubcompactions()) {
@@ -303,7 +301,8 @@ void CompactionJob::Prepare(
  SequenceNumber preserve_time_min_seqno = kMaxSequenceNumber;
  SequenceNumber preclude_last_level_min_seqno = kMaxSequenceNumber;
  uint64_t preserve_time_duration =
-      MinAndMaxPreserveSeconds(c->mutable_cf_options()).max_preserve_seconds;
+      std::max(c->mutable_cf_options().preserve_internal_time_seconds,
+               c->mutable_cf_options().preclude_last_level_data_seconds);

  if (preserve_time_duration > 0) {
    const ReadOptions read_options(Env::IOActivity::kCompaction);
@@ -380,8 +379,8 @@ void CompactionJob::Prepare(
  }
  // Now combine what we would like to preclude from last level with what we
  // can safely support without dangerously moving data back up the LSM tree,
-  // to get the final seqno threshold for proximal vs. last. In particular,
-  // when the reserved output key range for the proximal level does not
+  // to get the final seqno threshold for penultimate vs. last. In particular,
+  // when the reserved output key range for the penultimate level does not
  // include the entire last level input key range, we need to keep entries
  // already in the last level there. (Even allowing within-range entries to
  // move back up could cause problems with range tombstones. Perhaps it
@@ -390,8 +389,8 @@ void CompactionJob::Prepare(
  // tracking and complexity to CompactionIterator that is probably not
  // worthwhile overall. Correctness is also more clear when splitting by
  // seqno threshold.)
-  proximal_after_seqno_ = std::max(preclude_last_level_min_seqno,
-                                   c->GetKeepInLastLevelThroughSeqno());
+  penultimate_after_seqno_ = std::max(preclude_last_level_min_seqno,
+                                      c->GetKeepInLastLevelThroughSeqno());

  options_file_number_ = versions_->options_file_number();
 }
@@ -697,17 +696,17 @@ Status CompactionJob::Run() {
    thread.join();
  }

-  internal_stats_.SetMicros(db_options_.clock->NowMicros() - start_micros);
+  compaction_stats_.SetMicros(db_options_.clock->NowMicros() - start_micros);

  for (auto& state : compact_->sub_compact_states) {
-    internal_stats_.AddCpuMicros(state.compaction_job_stats.cpu_micros);
+    compaction_stats_.AddCpuMicros(state.compaction_job_stats.cpu_micros);
    state.RemoveLastEmptyOutput();
  }

  RecordTimeToHistogram(stats_, COMPACTION_TIME,
-                        internal_stats_.output_level_stats.micros);
+                        compaction_stats_.stats.micros);
  RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
-                        internal_stats_.output_level_stats.cpu_micros);
+                        compaction_stats_.stats.cpu_micros);

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

@@ -839,8 +838,10 @@ Status CompactionJob::Run() {
  }

  ReleaseSubcompactionResources();
-  TEST_SYNC_POINT("CompactionJob::ReleaseSubcompactionResources");
+  TEST_SYNC_POINT("CompactionJob::ReleaseSubcompactionResources:0");
+  TEST_SYNC_POINT("CompactionJob::ReleaseSubcompactionResources:1");

+  TablePropertiesCollection tp;
  for (const auto& state : compact_->sub_compact_states) {
    for (const auto& output : state.GetOutputs()) {
      auto fn =
@@ -855,67 +856,46 @@ Status CompactionJob::Run() {
  // 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.
-  job_stats_->is_remote_compaction = false;
+  compaction_job_stats_->is_remote_compaction = false;

  // Finish up all bookkeeping to unify the subcompaction results.
-  compact_->AggregateCompactionStats(internal_stats_, *job_stats_);
-
+  compact_->AggregateCompactionStats(compaction_stats_, *compaction_job_stats_);
  uint64_t num_input_range_del = 0;
-  bool ok = BuildStatsFromInputTableProperties(&num_input_range_del);
-  // (Sub)compactions returned ok, do sanity check on the number of input
-  // keys.
-  if (status.ok() && ok) {
-    if (job_stats_->has_num_input_records) {
-      status = VerifyInputRecordCount(num_input_range_del);
-      if (!status.ok()) {
+  bool ok = UpdateCompactionStats(&num_input_range_del);
+  // (Sub)compactions returned ok, do sanity check on the number of input keys.
+  if (status.ok() && ok && compaction_job_stats_->has_num_input_records) {
+    size_t ts_sz = compact_->compaction->column_family_data()
+                       ->user_comparator()
+                       ->timestamp_size();
+    // When trim_ts_ is non-empty, CompactionIterator takes
+    // HistoryTrimmingIterator as input iterator and sees a trimmed view of
+    // input keys. So the number of keys it processed is not suitable for
+    // verification here.
+    // TODO: support verification when trim_ts_ is non-empty.
+    if (!(ts_sz > 0 && !trim_ts_.empty())) {
+      assert(compaction_stats_.stats.num_input_records > 0);
+      // TODO: verify the number of range deletion entries.
+      uint64_t expected =
+          compaction_stats_.stats.num_input_records - num_input_range_del;
+      uint64_t actual = compaction_job_stats_->num_input_records;
+      if (expected != actual) {
+        char scratch[2345];
+        compact_->compaction->Summary(scratch, sizeof(scratch));
+        std::string msg =
+            "Compaction number of input keys does not match "
+            "number of keys processed. Expected " +
+            std::to_string(expected) + " but processed " +
+            std::to_string(actual) + ". Compaction summary: " + scratch;
        ROCKS_LOG_WARN(
            db_options_.info_log, "[%s] [JOB %d] Compaction with status: %s",
            compact_->compaction->column_family_data()->GetName().c_str(),
-            job_context_->job_id, status.ToString().c_str());
+            job_context_->job_id, msg.c_str());
+        if (db_options_.compaction_verify_record_count) {
+          status = Status::Corruption(msg);
+        }
      }
    }
-    UpdateCompactionJobInputStats(internal_stats_, num_input_range_del);
  }
-  UpdateCompactionJobOutputStats(internal_stats_);
-
-  // Verify number of output records
-  // Only verify on table with format collects table properties
-  const auto& mutable_cf_options = compact_->compaction->mutable_cf_options();
-  if (status.ok() &&
-      (mutable_cf_options.table_factory->IsInstanceOf(
-           TableFactory::kBlockBasedTableName()) ||
-       mutable_cf_options.table_factory->IsInstanceOf(
-           TableFactory::kPlainTableName())) &&
-      db_options_.compaction_verify_record_count) {
-    uint64_t total_output_num = 0;
-    for (const auto& state : compact_->sub_compact_states) {
-      for (const auto& output : state.GetOutputs()) {
-        total_output_num += output.table_properties->num_entries -
-                            output.table_properties->num_range_deletions;
-      }
-    }
-
-    uint64_t expected = internal_stats_.output_level_stats.num_output_records;
-    if (internal_stats_.has_proximal_level_output) {
-      expected += internal_stats_.proximal_level_stats.num_output_records;
-    }
-    if (expected != total_output_num) {
-      char scratch[2345];
-      compact_->compaction->Summary(scratch, sizeof(scratch));
-      std::string msg =
-          "Number of keys in compaction output SST files does not match "
-          "number of keys added. Expected " +
-          std::to_string(expected) + " but there are " +
-          std::to_string(total_output_num) +
-          " in output SST files. Compaction summary: " + scratch;
-      ROCKS_LOG_WARN(
-          db_options_.info_log, "[%s] [JOB %d] Compaction with status: %s",
-          compact_->compaction->column_family_data()->GetName().c_str(),
-          job_context_->job_id, msg.c_str());
-      status = Status::Corruption(msg);
-    }
-  }
-
  RecordCompactionIOStats();
  LogFlush(db_options_.info_log);
  TEST_SYNC_POINT("CompactionJob::Run():End");
@@ -937,7 +917,7 @@ Status CompactionJob::Install(bool* compaction_released) {

  int output_level = compact_->compaction->output_level();
  cfd->internal_stats()->AddCompactionStats(output_level, thread_pri_,
-                                            internal_stats_);
+                                            compaction_stats_);

  if (status.ok()) {
    status = InstallCompactionResults(compaction_released);
@@ -948,7 +928,7 @@ Status CompactionJob::Install(bool* compaction_released) {

  VersionStorageInfo::LevelSummaryStorage tmp;
  auto vstorage = cfd->current()->storage_info();
-  const auto& stats = internal_stats_.output_level_stats;
+  const auto& stats = compaction_stats_.stats;

  double read_write_amp = 0.0;
  double write_amp = 0.0;
@@ -1014,20 +994,19 @@ Status CompactionJob::Install(bool* compaction_released) {
        blob_files.back()->GetBlobFileNumber());
  }

-  if (internal_stats_.has_proximal_level_output) {
-    ROCKS_LOG_BUFFER(log_buffer_,
-                     "[%s] has Proximal Level output: %" PRIu64
-                     ", level %d, number of files: %" PRIu64
-                     ", number of records: %" PRIu64,
-                     column_family_name.c_str(),
-                     internal_stats_.proximal_level_stats.bytes_written,
-                     compact_->compaction->GetProximalLevel(),
-                     internal_stats_.proximal_level_stats.num_output_files,
-                     internal_stats_.proximal_level_stats.num_output_records);
+  if (compaction_stats_.has_penultimate_level_output) {
+    ROCKS_LOG_BUFFER(
+        log_buffer_,
+        "[%s] has Penultimate Level output: %" PRIu64
+        ", level %d, number of files: %" PRIu64 ", number of records: %" PRIu64,
+        column_family_name.c_str(),
+        compaction_stats_.penultimate_level_stats.bytes_written,
+        compact_->compaction->GetPenultimateLevel(),
+        compaction_stats_.penultimate_level_stats.num_output_files,
+        compaction_stats_.penultimate_level_stats.num_output_records);
  }

-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionJob::Install:AfterUpdateCompactionJobStats", job_stats_);
+  UpdateCompactionJobStats(stats);

  auto stream = event_logger_->LogToBuffer(log_buffer_, 8192);
  stream << "job" << job_id_ << "event" << "compaction_finished"
@@ -1049,16 +1028,17 @@ Status CompactionJob::Install(bool* compaction_released) {
         << CompressionTypeToString(compact_->compaction->output_compression());

  stream << "num_single_delete_mismatches"
-         << job_stats_->num_single_del_mismatch;
+         << compaction_job_stats_->num_single_del_mismatch;
  stream << "num_single_delete_fallthrough"
-         << job_stats_->num_single_del_fallthru;
+         << compaction_job_stats_->num_single_del_fallthru;

  if (measure_io_stats_) {
-    stream << "file_write_nanos" << job_stats_->file_write_nanos;
-    stream << "file_range_sync_nanos" << job_stats_->file_range_sync_nanos;
-    stream << "file_fsync_nanos" << job_stats_->file_fsync_nanos;
+    stream << "file_write_nanos" << compaction_job_stats_->file_write_nanos;
+    stream << "file_range_sync_nanos"
+           << compaction_job_stats_->file_range_sync_nanos;
+    stream << "file_fsync_nanos" << compaction_job_stats_->file_fsync_nanos;
    stream << "file_prepare_write_nanos"
-           << job_stats_->file_prepare_write_nanos;
+           << compaction_job_stats_->file_prepare_write_nanos;
  }

  stream << "lsm_state";
@@ -1076,16 +1056,16 @@ Status CompactionJob::Install(bool* compaction_released) {
    stream << "blob_file_tail" << blob_files.back()->GetBlobFileNumber();
  }

-  if (internal_stats_.has_proximal_level_output) {
+  if (compaction_stats_.has_penultimate_level_output) {
    InternalStats::CompactionStats& pl_stats =
-        internal_stats_.proximal_level_stats;
-    stream << "proximal_level_num_output_files" << pl_stats.num_output_files;
-    stream << "proximal_level_bytes_written" << pl_stats.bytes_written;
-    stream << "proximal_level_num_output_records"
+        compaction_stats_.penultimate_level_stats;
+    stream << "penultimate_level_num_output_files" << pl_stats.num_output_files;
+    stream << "penultimate_level_bytes_written" << pl_stats.bytes_written;
+    stream << "penultimate_level_num_output_records"
           << pl_stats.num_output_records;
-    stream << "proximal_level_num_output_files_blob"
+    stream << "penultimate_level_num_output_files_blob"
           << pl_stats.num_output_files_blob;
-    stream << "proximal_level_bytes_written_blob"
+    stream << "penultimate_level_bytes_written_blob"
           << pl_stats.bytes_written_blob;
  }

@@ -1184,7 +1164,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  // creation across both CompactionJob and CompactionServiceCompactionJob
  sub_compact->AssignRangeDelAggregator(
      std::make_unique<CompactionRangeDelAggregator>(
-          &cfd->internal_comparator(), job_context_->snapshot_seqs,
+          &cfd->internal_comparator(), existing_snapshots_,
          &full_history_ts_low_, &trim_ts_));

  // TODO: since we already use C++17, should use
@@ -1325,15 +1305,15 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      env_, cfd->user_comparator(), cfd->ioptions().merge_operator.get(),
      compaction_filter, db_options_.info_log.get(),
      false /* internal key corruption is expected */,
-      job_context_->GetLatestSnapshotSequence(), job_context_->snapshot_checker,
-      compact_->compaction->level(), db_options_.stats);
+      existing_snapshots_.empty() ? 0 : existing_snapshots_.back(),
+      snapshot_checker_, compact_->compaction->level(), db_options_.stats);

  const auto& mutable_cf_options =
      sub_compact->compaction->mutable_cf_options();

  std::vector<std::string> blob_file_paths;

-  // TODO: BlobDB to support output_to_proximal_level compaction, which needs
+  // TODO: BlobDB to support output_to_penultimate_level compaction, which needs
  //  2 builders, so may need to move to `CompactionOutputs`
  std::unique_ptr<BlobFileBuilder> blob_file_builder(
      (mutable_cf_options.enable_blob_files &&
@@ -1362,10 +1342,9 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {

  auto c_iter = std::make_unique<CompactionIterator>(
      input, cfd->user_comparator(), &merge, versions_->LastSequence(),
-      &(job_context_->snapshot_seqs), earliest_snapshot_,
-      job_context_->earliest_write_conflict_snapshot, job_snapshot_seq,
-      job_context_->snapshot_checker, env_,
-      ShouldReportDetailedTime(env_, stats_),
+      &existing_snapshots_, earliest_snapshot_,
+      earliest_write_conflict_snapshot_, job_snapshot_seq, snapshot_checker_,
+      env_, ShouldReportDetailedTime(env_, stats_),
      /*expect_valid_internal_key=*/true, sub_compact->RangeDelAgg(),
      blob_file_builder.get(), db_options_.allow_data_in_errors,
      db_options_.enforce_single_del_contracts, manual_compaction_canceled_,
@@ -1419,30 +1398,30 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    }

    const auto& ikey = c_iter->ikey();
-    bool use_proximal_output = ikey.sequence > proximal_after_seqno_;
+    bool use_penultimate_output = ikey.sequence > penultimate_after_seqno_;
 #ifndef NDEBUG
    if (sub_compact->compaction->SupportsPerKeyPlacement()) {
      // Could be overridden by unittest
      PerKeyPlacementContext context(sub_compact->compaction->output_level(),
                                     ikey.user_key, c_iter->value(),
-                                     ikey.sequence, use_proximal_output);
+                                     ikey.sequence, use_penultimate_output);
      TEST_SYNC_POINT_CALLBACK("CompactionIterator::PrepareOutput.context",
                               &context);
-      if (use_proximal_output) {
-        // Verify that entries sent to the proximal level are within the
+      if (use_penultimate_output) {
+        // Verify that entries sent to the penultimate level are within the
        // allowed range (because the input key range of the last level could
-        // be larger than the allowed output key range of the proximal
+        // be larger than the allowed output key range of the penultimate
        // level). This check uses user keys (ignores sequence numbers) because
        // compaction boundaries are a "clean cut" between user keys (see
        // CompactionPicker::ExpandInputsToCleanCut()), which is especially
        // important when preferred sequence numbers has been swapped in for
        // kTypeValuePreferredSeqno / TimedPut.
-        sub_compact->compaction->TEST_AssertWithinProximalLevelOutputRange(
+        sub_compact->compaction->TEST_AssertWithinPenultimateLevelOutputRange(
            c_iter->user_key());
      }
    } else {
-      assert(proximal_after_seqno_ == kMaxSequenceNumber);
-      assert(!use_proximal_output);
+      assert(penultimate_after_seqno_ == kMaxSequenceNumber);
+      assert(!use_penultimate_output);
    }
 #endif  // NDEBUG

@@ -1451,7 +1430,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    // and `close_file_func`.
    // TODO: it would be better to have the compaction file open/close moved
    // into `CompactionOutputs` which has the output file information.
-    status = sub_compact->AddToOutput(*c_iter, use_proximal_output,
+    status = sub_compact->AddToOutput(*c_iter, use_penultimate_output,
                                      open_file_func, close_file_func);
    if (!status.ok()) {
      break;
@@ -1654,20 +1633,24 @@ Status CompactionJob::FinishCompactionOutputFile(
  Status s = input_status;

  // Add range tombstones
+  auto earliest_snapshot = kMaxSequenceNumber;
+  if (existing_snapshots_.size() > 0) {
+    earliest_snapshot = existing_snapshots_[0];
+  }
  if (s.ok()) {
    // Inclusive lower bound, exclusive upper bound
    std::pair<SequenceNumber, SequenceNumber> keep_seqno_range{
        0, kMaxSequenceNumber};
    if (sub_compact->compaction->SupportsPerKeyPlacement()) {
-      if (outputs.IsProximalLevel()) {
-        keep_seqno_range.first = proximal_after_seqno_;
+      if (outputs.IsPenultimateLevel()) {
+        keep_seqno_range.first = penultimate_after_seqno_;
      } else {
-        keep_seqno_range.second = proximal_after_seqno_;
+        keep_seqno_range.second = penultimate_after_seqno_;
      }
    }
    CompactionIterationStats range_del_out_stats;
    // NOTE1: Use `bottommost_level_ = true` for both bottommost and
-    // output_to_proximal_level compaction here, as it's only used to decide
+    // output_to_penultimate_level compaction here, as it's only used to decide
    // if range dels could be dropped. (Logically, we are taking a single sorted
    // run returned from CompactionIterator and physically splitting it between
    // two output levels.)
@@ -1679,7 +1662,7 @@ Status CompactionJob::FinishCompactionOutputFile(
      s = outputs.AddRangeDels(*sub_compact->RangeDelAgg(), comp_start_user_key,
                               comp_end_user_key, range_del_out_stats,
                               bottommost_level_, cfd->internal_comparator(),
-                               earliest_snapshot_, keep_seqno_range,
+                               earliest_snapshot, keep_seqno_range,
                               next_table_min_key, full_history_ts_low_);
    }
    RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
@@ -1736,11 +1719,14 @@ Status CompactionJob::FinishCompactionOutputFile(
  if (s.ok()) {
    tp = outputs.GetTableProperties();
  }
+
  if (s.ok() && current_entries == 0 && tp.num_range_deletions == 0) {
    // If there is nothing to output, no necessary to generate a sst file.
    // This happens when the output level is bottom level, at the same time
    // the sub_compact output nothing.
-    std::string fname = GetTableFileName(meta->fd.GetNumber());
+    std::string fname =
+        TableFileName(sub_compact->compaction->immutable_options().cf_paths,
+                      meta->fd.GetNumber(), meta->fd.GetPathId());

    // TODO(AR) it is not clear if there are any larger implications if
    // DeleteFile fails here
@@ -1827,22 +1813,22 @@ Status CompactionJob::InstallCompactionResults(bool* compaction_released) {

  {
    Compaction::InputLevelSummaryBuffer inputs_summary;
-    if (internal_stats_.has_proximal_level_output) {
+    if (compaction_stats_.has_penultimate_level_output) {
      ROCKS_LOG_BUFFER(
          log_buffer_,
-          "[%s] [JOB %d] Compacted %s => output_to_proximal_level: %" PRIu64
+          "[%s] [JOB %d] Compacted %s => output_to_penultimate_level: %" PRIu64
          " bytes + last: %" PRIu64 " bytes. Total: %" PRIu64 " bytes",
          compaction->column_family_data()->GetName().c_str(), job_id_,
          compaction->InputLevelSummary(&inputs_summary),
-          internal_stats_.proximal_level_stats.bytes_written,
-          internal_stats_.output_level_stats.bytes_written,
-          internal_stats_.TotalBytesWritten());
+          compaction_stats_.penultimate_level_stats.bytes_written,
+          compaction_stats_.stats.bytes_written,
+          compaction_stats_.TotalBytesWritten());
    } else {
      ROCKS_LOG_BUFFER(log_buffer_,
                       "[%s] [JOB %d] Compacted %s => %" PRIu64 " bytes",
                       compaction->column_family_data()->GetName().c_str(),
                       job_id_, compaction->InputLevelSummary(&inputs_summary),
-                       internal_stats_.TotalBytesWritten());
+                       compaction_stats_.TotalBytesWritten());
    }
  }

@@ -1939,10 +1925,6 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,

  // no need to lock because VersionSet::next_file_number_ is atomic
  uint64_t file_number = versions_->NewFileNumber();
-#ifndef NDEBUG
-  TEST_SYNC_POINT_CALLBACK(
-      "CompactionJob::OpenCompactionOutputFile::NewFileNumber", &file_number);
-#endif
  std::string fname = GetTableFileName(file_number);
  // Fire events.
  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
@@ -1965,11 +1947,11 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
  // Here last_level_temperature supersedes default_write_temperature, when
  // enabled and applicable
  if (last_level_temp != Temperature::kUnknown &&
-      sub_compact->compaction->is_last_level() && !outputs.IsProximalLevel()) {
+      sub_compact->compaction->is_last_level() &&
+      !outputs.IsPenultimateLevel()) {
    temperature = last_level_temp;
  }
  fo_copy.temperature = temperature;
-  fo_copy.write_hint = write_hint_;

  Status s;
  IOStatus io_s = NewWritableFile(fs_.get(), fname, &writable_file, fo_copy);
@@ -2055,9 +2037,7 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
  }

  writable_file->SetIOPriority(GetRateLimiterPriority());
-  // Subsequent attempts to override the hint via SetWriteLifeTimeHint
-  // with the very same value will be ignored by the fs.
-  writable_file->SetWriteLifeTimeHint(fo_copy.write_hint);
+  writable_file->SetWriteLifeTimeHint(write_hint_);
  FileTypeSet tmp_set = db_options_.checksum_handoff_file_types;
  writable_file->SetPreallocationBlockSize(static_cast<size_t>(
      sub_compact->compaction->OutputFilePreallocationSize()));
@@ -2082,7 +2062,7 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
      bottommost_level_, TableFileCreationReason::kCompaction,
      0 /* oldest_key_time */, current_time, db_id_, db_session_id_,
      sub_compact->compaction->max_output_file_size(), file_number,
-      proximal_after_seqno_ /*last_level_inclusive_max_seqno_threshold*/);
+      penultimate_after_seqno_ /*last_level_inclusive_max_seqno_threshold*/);

  outputs.NewBuilder(tboptions);

@@ -2106,13 +2086,12 @@ void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
 }
 }  // namespace

-bool CompactionJob::BuildStatsFromInputTableProperties(
-    uint64_t* num_input_range_del) {
+bool CompactionJob::UpdateCompactionStats(uint64_t* num_input_range_del) {
  assert(compact_);

  Compaction* compaction = compact_->compaction;
-  internal_stats_.output_level_stats.num_input_files_in_non_output_levels = 0;
-  internal_stats_.output_level_stats.num_input_files_in_output_level = 0;
+  compaction_stats_.stats.num_input_files_in_non_output_levels = 0;
+  compaction_stats_.stats.num_input_files_in_output_level = 0;

  bool has_error = false;
  const ReadOptions read_options(Env::IOActivity::kCompaction);
@@ -2124,14 +2103,13 @@ bool CompactionJob::BuildStatsFromInputTableProperties(
    size_t num_input_files = flevel->num_files;
    uint64_t* bytes_read;
    if (compaction->level(input_level) != compaction->output_level()) {
-      internal_stats_.output_level_stats.num_input_files_in_non_output_levels +=
+      compaction_stats_.stats.num_input_files_in_non_output_levels +=
          static_cast<int>(num_input_files);
-      bytes_read =
-          &internal_stats_.output_level_stats.bytes_read_non_output_levels;
+      bytes_read = &compaction_stats_.stats.bytes_read_non_output_levels;
    } else {
-      internal_stats_.output_level_stats.num_input_files_in_output_level +=
+      compaction_stats_.stats.num_input_files_in_output_level +=
          static_cast<int>(num_input_files);
-      bytes_read = &internal_stats_.output_level_stats.bytes_read_output_level;
+      bytes_read = &compaction_stats_.stats.bytes_read_output_level;
    }
    for (size_t i = 0; i < num_input_files; ++i) {
      const FileMetaData* file_meta = flevel->files[i].file_metadata;
@@ -2151,8 +2129,7 @@ bool CompactionJob::BuildStatsFromInputTableProperties(
          has_error = true;
        }
      }
-      internal_stats_.output_level_stats.num_input_records +=
-          file_input_entries;
+      compaction_stats_.stats.num_input_records += file_input_entries;
      if (num_input_range_del) {
        *num_input_range_del += file_num_range_del;
      }
@@ -2163,122 +2140,62 @@ bool CompactionJob::BuildStatsFromInputTableProperties(
    size_t num_filtered_input_files = filtered_flevel.size();
    uint64_t* bytes_skipped;
    if (compaction->level(input_level) != compaction->output_level()) {
-      internal_stats_.output_level_stats
-          .num_filtered_input_files_in_non_output_levels +=
+      compaction_stats_.stats.num_filtered_input_files_in_non_output_levels +=
          static_cast<int>(num_filtered_input_files);
-      bytes_skipped =
-          &internal_stats_.output_level_stats.bytes_skipped_non_output_levels;
+      bytes_skipped = &compaction_stats_.stats.bytes_skipped_non_output_levels;
    } else {
-      internal_stats_.output_level_stats
-          .num_filtered_input_files_in_output_level +=
+      compaction_stats_.stats.num_filtered_input_files_in_output_level +=
          static_cast<int>(num_filtered_input_files);
-      bytes_skipped =
-          &internal_stats_.output_level_stats.bytes_skipped_output_level;
+      bytes_skipped = &compaction_stats_.stats.bytes_skipped_output_level;
    }
    for (const FileMetaData* filtered_file_meta : filtered_flevel) {
      *bytes_skipped += filtered_file_meta->fd.GetFileSize();
    }
  }

-  // TODO - find a better place to set these two
-  assert(job_stats_);
-  internal_stats_.output_level_stats.bytes_read_blob =
-      job_stats_->total_blob_bytes_read;
-  internal_stats_.output_level_stats.num_dropped_records =
-      internal_stats_.DroppedRecords();
+  assert(compaction_job_stats_);
+  compaction_stats_.stats.bytes_read_blob =
+      compaction_job_stats_->total_blob_bytes_read;
+
+  compaction_stats_.stats.num_dropped_records =
+      compaction_stats_.DroppedRecords();
  return !has_error;
 }

-void CompactionJob::UpdateCompactionJobInputStats(
-    const InternalStats::CompactionStatsFull& internal_stats,
-    uint64_t num_input_range_del) const {
-  assert(job_stats_);
+void CompactionJob::UpdateCompactionJobStats(
+    const InternalStats::CompactionStats& stats) const {
+  compaction_job_stats_->elapsed_micros = stats.micros;
+
  // input information
-  job_stats_->total_input_bytes =
-      internal_stats.output_level_stats.bytes_read_non_output_levels +
-      internal_stats.output_level_stats.bytes_read_output_level;
-  job_stats_->num_input_records =
-      internal_stats.output_level_stats.num_input_records - num_input_range_del;
-  job_stats_->num_input_files =
-      internal_stats.output_level_stats.num_input_files_in_non_output_levels +
-      internal_stats.output_level_stats.num_input_files_in_output_level;
-  job_stats_->num_input_files_at_output_level =
-      internal_stats.output_level_stats.num_input_files_in_output_level;
-  job_stats_->num_filtered_input_files =
-      internal_stats.output_level_stats
-          .num_filtered_input_files_in_non_output_levels +
-      internal_stats.output_level_stats
-          .num_filtered_input_files_in_output_level;
-  job_stats_->num_filtered_input_files_at_output_level =
-      internal_stats.output_level_stats
-          .num_filtered_input_files_in_output_level;
-  job_stats_->total_skipped_input_bytes =
-      internal_stats.output_level_stats.bytes_skipped_non_output_levels +
-      internal_stats.output_level_stats.bytes_skipped_output_level;
-
-  if (internal_stats.has_proximal_level_output) {
-    job_stats_->total_input_bytes +=
-        internal_stats.proximal_level_stats.bytes_read_non_output_levels +
-        internal_stats.proximal_level_stats.bytes_read_output_level;
-    job_stats_->num_input_records +=
-        internal_stats.proximal_level_stats.num_input_records;
-    job_stats_->num_input_files +=
-        internal_stats.proximal_level_stats
-            .num_input_files_in_non_output_levels +
-        internal_stats.proximal_level_stats.num_input_files_in_output_level;
-    job_stats_->num_input_files_at_output_level +=
-        internal_stats.proximal_level_stats.num_input_files_in_output_level;
-    job_stats_->num_filtered_input_files +=
-        internal_stats.proximal_level_stats
-            .num_filtered_input_files_in_non_output_levels +
-        internal_stats.proximal_level_stats
-            .num_filtered_input_files_in_output_level;
-    job_stats_->num_filtered_input_files_at_output_level +=
-        internal_stats.proximal_level_stats
-            .num_filtered_input_files_in_output_level;
-    job_stats_->total_skipped_input_bytes +=
-        internal_stats.proximal_level_stats.bytes_skipped_non_output_levels +
-        internal_stats.proximal_level_stats.bytes_skipped_output_level;
-  }
-}
-
-void CompactionJob::UpdateCompactionJobOutputStats(
-    const InternalStats::CompactionStatsFull& internal_stats) const {
-  assert(job_stats_);
-  job_stats_->elapsed_micros = internal_stats.output_level_stats.micros;
-  job_stats_->cpu_micros = internal_stats.output_level_stats.cpu_micros;
+  compaction_job_stats_->total_input_bytes =
+      stats.bytes_read_non_output_levels + stats.bytes_read_output_level;
+  compaction_job_stats_->num_input_records = stats.num_input_records;
+  compaction_job_stats_->num_input_files =
+      stats.num_input_files_in_non_output_levels +
+      stats.num_input_files_in_output_level;
+  compaction_job_stats_->num_input_files_at_output_level =
+      stats.num_input_files_in_output_level;
+  compaction_job_stats_->num_filtered_input_files =
+      stats.num_filtered_input_files_in_non_output_levels +
+      stats.num_filtered_input_files_in_output_level;
+  compaction_job_stats_->num_filtered_input_files_at_output_level =
+      stats.num_filtered_input_files_in_output_level;
+  compaction_job_stats_->total_skipped_input_bytes =
+      stats.bytes_skipped_non_output_levels + stats.bytes_skipped_output_level;

  // output information
-  job_stats_->total_output_bytes =
-      internal_stats.output_level_stats.bytes_written;
-  job_stats_->total_output_bytes_blob =
-      internal_stats.output_level_stats.bytes_written_blob;
-  job_stats_->num_output_records =
-      internal_stats.output_level_stats.num_output_records;
-  job_stats_->num_output_files =
-      internal_stats.output_level_stats.num_output_files;
-  job_stats_->num_output_files_blob =
-      internal_stats.output_level_stats.num_output_files_blob;
+  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;

-  if (internal_stats.has_proximal_level_output) {
-    job_stats_->total_output_bytes +=
-        internal_stats.proximal_level_stats.bytes_written;
-    job_stats_->total_output_bytes_blob +=
-        internal_stats.proximal_level_stats.bytes_written_blob;
-    job_stats_->num_output_records +=
-        internal_stats.proximal_level_stats.num_output_records;
-    job_stats_->num_output_files +=
-        internal_stats.proximal_level_stats.num_output_files;
-    job_stats_->num_output_files_blob +=
-        internal_stats.proximal_level_stats.num_output_files_blob;
-  }
-
-  if (job_stats_->num_output_files > 0) {
+  if (stats.num_output_files > 0) {
    CopyPrefix(compact_->SmallestUserKey(),
               CompactionJobStats::kMaxPrefixLength,
-               &job_stats_->smallest_output_key_prefix);
+               &compaction_job_stats_->smallest_output_key_prefix);
    CopyPrefix(compact_->LargestUserKey(), CompactionJobStats::kMaxPrefixLength,
-               &job_stats_->largest_output_key_prefix);
+               &compaction_job_stats_->largest_output_key_prefix);
  }
 }

@@ -2299,8 +2216,8 @@ void CompactionJob::LogCompaction() {
                   cfd->GetName().c_str(), scratch);
    // build event logger report
    auto stream = event_logger_->Log();
-    stream << "job" << job_id_ << "event" << "compaction_started" << "cf_name"
-           << cfd->GetName() << "compaction_reason"
+    stream << "job" << job_id_ << "event" << "compaction_started"
+           << "compaction_reason"
           << GetCompactionReasonString(compaction->compaction_reason());
    for (size_t i = 0; i < compaction->num_input_levels(); ++i) {
      stream << ("files_L" + std::to_string(compaction->level(i)));
@@ -2312,24 +2229,23 @@ void CompactionJob::LogCompaction() {
    }
    stream << "score" << compaction->score() << "input_data_size"
           << compaction->CalculateTotalInputSize() << "oldest_snapshot_seqno"
-           << (job_context_->snapshot_seqs.empty()
+           << (existing_snapshots_.empty()
                   ? int64_t{-1}  // Use -1 for "none"
-                   : static_cast<int64_t>(
-                         job_context_->GetEarliestSnapshotSequence()));
+                   : static_cast<int64_t>(existing_snapshots_[0]));
    if (compaction->SupportsPerKeyPlacement()) {
-      stream << "proximal_after_seqno" << proximal_after_seqno_;
+      stream << "prenultimate_after_seqno" << penultimate_after_seqno_;
      stream << "preserve_seqno_after" << preserve_seqno_after_;
-      stream << "proximal_output_level" << compaction->GetProximalLevel();
-      stream << "proximal_output_range"
-             << GetCompactionProximalOutputRangeTypeString(
-                    compaction->GetProximalOutputRangeType());
+      stream << "penultimate_output_level" << compaction->GetPenultimateLevel();
+      stream << "penultimate_output_range"
+             << GetCompactionPenultimateOutputRangeTypeString(
+                    compaction->GetPenultimateOutputRangeType());

-      if (compaction->GetProximalOutputRangeType() ==
-          Compaction::ProximalOutputRangeType::kDisabled) {
+      if (compaction->GetPenultimateOutputRangeType() ==
+          Compaction::PenultimateOutputRangeType::kDisabled) {
        ROCKS_LOG_WARN(
            db_options_.info_log,
-            "[%s] [JOB %d] Proximal level output is disabled, likely "
-            "because of the range conflict in the proximal level",
+            "[%s] [JOB %d] Penultimate level output is disabled, likely "
+            "because of the range conflict in the penultimate level",
            cfd->GetName().c_str(), job_id_);
      }
    }
@@ -2354,36 +2270,4 @@ Env::IOPriority CompactionJob::GetRateLimiterPriority() {
  return Env::IO_LOW;
 }

-Status CompactionJob::VerifyInputRecordCount(
-    uint64_t num_input_range_del) const {
-  size_t ts_sz = compact_->compaction->column_family_data()
-                     ->user_comparator()
-                     ->timestamp_size();
-  // When trim_ts_ is non-empty, CompactionIterator takes
-  // HistoryTrimmingIterator as input iterator and sees a trimmed view of
-  // input keys. So the number of keys it processed is not suitable for
-  // verification here.
-  // TODO: support verification when trim_ts_ is non-empty.
-  if (!(ts_sz > 0 && !trim_ts_.empty())) {
-    assert(internal_stats_.output_level_stats.num_input_records > 0);
-    // TODO: verify the number of range deletion entries.
-    uint64_t expected = internal_stats_.output_level_stats.num_input_records -
-                        num_input_range_del;
-    uint64_t actual = job_stats_->num_input_records;
-    if (expected != actual) {
-      char scratch[2345];
-      compact_->compaction->Summary(scratch, sizeof(scratch));
-      std::string msg =
-          "Compaction number of input keys does not match "
-          "number of keys processed. Expected " +
-          std::to_string(expected) + " but processed " +
-          std::to_string(actual) + ". Compaction summary: " + scratch;
-      if (db_options_.compaction_verify_record_count) {
-        return Status::Corruption(msg);
-      }
-    }
-  }
-  return Status::OK();
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -67,7 +67,7 @@ class SubcompactionState;
 // if needed.
 //
 // CompactionJob has 2 main stats:
-// 1. CompactionJobStats job_stats_
+// 1. CompactionJobStats compaction_job_stats_
 //    CompactionJobStats is a public data structure which is part of Compaction
 //    event listener that rocksdb share the job stats with the user.
 //    Internally it's an aggregation of all the compaction_job_stats from each
@@ -81,7 +81,7 @@ class SubcompactionState;
 // +------------------------+     |
 // | CompactionJob          |     |          +------------------------+
 // |                        |     |          | SubcompactionState     |
-// |   job_stats            +-----+          |                        |
+// |   compaction_job_stats +-----+          |                        |
 // |                        |     +--------->|   compaction_job_stats |
 // |                        |     |          |                        |
 // +------------------------+     |          +------------------------+
@@ -98,13 +98,16 @@ class SubcompactionState;
 //                                +--------->+                        |
 //                                           +------------------------+
 //
-// 2. CompactionStatsFull internal_stats_
+// 2. CompactionStatsFull compaction_stats_
 //    `CompactionStatsFull` is an internal stats about the compaction, which
 //    is eventually sent to `ColumnFamilyData::internal_stats_` and used for
 //    logging and public metrics.
 //    Internally, it's an aggregation of stats_ from each `SubcompactionState`.
-//    It has 2 parts, ordinary output level stats and the proximal level output
-//    stats.
+//    It has 2 parts, normal stats about the main compaction information and
+//    the penultimate level output stats.
+//    `SubcompactionState` maintains the CompactionOutputs for normal output and
+//    the penultimate level output if exists, the per_level stats is
+//    stored with the outputs.
 //                                                +---------------------------+
 //                                                | SubcompactionState        |
 //                                                |                           |
@@ -116,15 +119,15 @@ class SubcompactionState;
 //                                            |   |                           |
 //                                            |   | +----------------------+  |
 // +--------------------------------+         |   | | CompactionOutputs    |  |
-// | CompactionJob                  |         |   | | (proximal_level)     |  |
+// | CompactionJob                  |         |   | | (penultimate_level)  |  |
 // |                                |    +--------->|   stats_             |  |
-// |   internal_stats_              |    |    |   | +----------------------+  |
+// |   compaction_stats_            |    |    |   | +----------------------+  |
 // |    +-------------------------+ |    |    |   |                           |
-// |    |output_level_stats       |------|----+   +---------------------------+
+// |    |stats (normal)           |------|----+   +---------------------------+
 // |    +-------------------------+ |    |    |
 // |                                |    |    |
 // |    +-------------------------+ |    |    |   +---------------------------+
-// |    |proximal_level_stats     |------+    |   | SubcompactionState        |
+// |    |penultimate_level_stats  +------+    |   | SubcompactionState        |
 // |    +-------------------------+ |    |    |   |                           |
 // |                                |    |    |   | +----------------------+  |
 // |                                |    |    |   | | CompactionOutputs    |  |
@@ -134,7 +137,7 @@ class SubcompactionState;
 //                                       |        |                           |
 //                                       |        | +----------------------+  |
 //                                       |        | | CompactionOutputs    |  |
-//                                       |        | | (proximal_level)     |  |
+//                                       |        | | (penultimate_level)  |  |
 //                                       +--------->|   stats_             |  |
 //                                                | +----------------------+  |
 //                                                |                           |
@@ -142,27 +145,27 @@ class SubcompactionState;

 class CompactionJob {
 public:
-  CompactionJob(int job_id, Compaction* compaction,
-                const ImmutableDBOptions& db_options,
-                const MutableDBOptions& mutable_db_options,
-                const FileOptions& file_options, VersionSet* versions,
-                const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
-                FSDirectory* db_directory, FSDirectory* output_directory,
-                FSDirectory* blob_output_directory, Statistics* stats,
-                InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-                JobContext* job_context, std::shared_ptr<Cache> table_cache,
-                EventLogger* event_logger, bool paranoid_file_checks,
-                bool measure_io_stats, const std::string& dbname,
-                CompactionJobStats* compaction_job_stats,
-                Env::Priority thread_pri,
-                const std::shared_ptr<IOTracer>& io_tracer,
-                const std::atomic<bool>& manual_compaction_canceled,
-                const std::string& db_id = "",
-                const std::string& db_session_id = "",
-                std::string full_history_ts_low = "", std::string trim_ts = "",
-                BlobFileCompletionCallback* blob_callback = nullptr,
-                int* bg_compaction_scheduled = nullptr,
-                int* bg_bottom_compaction_scheduled = nullptr);
+  CompactionJob(
+      int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
+      const MutableDBOptions& mutable_db_options,
+      const FileOptions& file_options, VersionSet* versions,
+      const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
+      FSDirectory* db_directory, FSDirectory* output_directory,
+      FSDirectory* blob_output_directory, Statistics* stats,
+      InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
+      std::vector<SequenceNumber> existing_snapshots,
+      SequenceNumber earliest_write_conflict_snapshot,
+      const SnapshotChecker* snapshot_checker, JobContext* job_context,
+      std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
+      bool paranoid_file_checks, bool measure_io_stats,
+      const std::string& dbname, CompactionJobStats* compaction_job_stats,
+      Env::Priority thread_pri, const std::shared_ptr<IOTracer>& io_tracer,
+      const std::atomic<bool>& manual_compaction_canceled,
+      const std::string& db_id = "", const std::string& db_session_id = "",
+      std::string full_history_ts_low = "", std::string trim_ts = "",
+      BlobFileCompletionCallback* blob_callback = nullptr,
+      int* bg_compaction_scheduled = nullptr,
+      int* bg_bottom_compaction_scheduled = nullptr);

  virtual ~CompactionJob();

@@ -196,9 +199,23 @@ class CompactionJob {
  IOStatus io_status() const { return io_status_; }

 protected:
-  void UpdateCompactionJobOutputStats(
-      const InternalStats::CompactionStatsFull& internal_stats) const;
-
+  // Update the following stats in compaction_stats_.stats
+  // - num_input_files_in_non_output_levels
+  // - num_input_files_in_output_level
+  // - bytes_read_non_output_levels
+  // - bytes_read_output_level
+  // - num_input_records
+  // - bytes_read_blob
+  // - num_dropped_records
+  //
+  // @param num_input_range_del if non-null, will be set to the number of range
+  // deletion entries in this compaction input.
+  //
+  // 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();
@@ -207,7 +224,7 @@ class CompactionJob {
  void ProcessKeyValueCompaction(SubcompactionState* sub_compact);

  CompactionState* compact_;
-  InternalStats::CompactionStatsFull internal_stats_;
+  InternalStats::CompactionStatsFull compaction_stats_;
  const ImmutableDBOptions& db_options_;
  const MutableDBOptions mutable_db_options_copy_;
  LogBuffer* log_buffer_;
@@ -220,37 +237,11 @@ class CompactionJob {

  IOStatus io_status_;

-  CompactionJobStats* job_stats_;
+  CompactionJobStats* compaction_job_stats_;

 private:
  friend class CompactionJobTestBase;

-  // Collect the following stats from Input Table Properties
-  // - num_input_files_in_non_output_levels
-  // - num_input_files_in_output_level
-  // - bytes_read_non_output_levels
-  // - bytes_read_output_level
-  // - num_input_records
-  // - bytes_read_blob
-  // - num_dropped_records
-  // and set them in internal_stats_.output_level_stats
-  //
-  // @param num_input_range_del if non-null, will be set to the number of range
-  // deletion entries in this compaction input.
-  //
-  // Returns true iff internal_stats_.output_level_stats.num_input_records and
-  // num_input_range_del are calculated successfully.
-  //
-  // This should be called only once for compactions (not per subcompaction)
-  bool BuildStatsFromInputTableProperties(
-      uint64_t* num_input_range_del = nullptr);
-
-  void UpdateCompactionJobInputStats(
-      const InternalStats::CompactionStatsFull& internal_stats,
-      uint64_t num_input_range_del) const;
-
-  Status VerifyInputRecordCount(uint64_t num_input_range_del) const;
-
  // Generates a histogram representing potential divisions of key ranges from
  // the input. It adds the starting and/or ending keys of certain input files
  // to the working set and then finds the approximate size of data in between
@@ -321,8 +312,21 @@ class CompactionJob {
  FSDirectory* blob_output_directory_;
  InstrumentedMutex* db_mutex_;
  ErrorHandler* db_error_handler_;
+  // If there were two snapshots with seq numbers s1 and
+  // s2 and s1 < s2, and if we find two instances of a key k1 then lies
+  // entirely within s1 and s2, then the earlier version of k1 can be safely
+  // 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.
+  SequenceNumber earliest_write_conflict_snapshot_;
+
+  const SnapshotChecker* const snapshot_checker_;
+
  JobContext* job_context_;

  std::shared_ptr<Cache> table_cache_;
@@ -359,8 +363,8 @@ class CompactionJob {

  // Minimal sequence number to preclude the data from the last level. If the
  // key has bigger (newer) sequence number than this, it will be precluded from
-  // the last level (output to proximal level).
-  SequenceNumber proximal_after_seqno_ = kMaxSequenceNumber;
+  // the last level (output to penultimate level).
+  SequenceNumber penultimate_after_seqno_ = kMaxSequenceNumber;

  // Options File Number used for Remote Compaction
  // Setting this requires DBMutex.
@@ -414,9 +418,8 @@ struct CompactionServiceInput {
 // CompactionServiceOutputFile is the metadata for the output SST file
 struct CompactionServiceOutputFile {
  std::string file_name;
-  uint64_t file_size{};
-  SequenceNumber smallest_seqno{};
-  SequenceNumber largest_seqno{};
+  SequenceNumber smallest_seqno;
+  SequenceNumber largest_seqno;
  std::string smallest_internal_key;
  std::string largest_internal_key;
  uint64_t oldest_ancester_time = kUnknownOldestAncesterTime;
@@ -424,26 +427,21 @@ struct CompactionServiceOutputFile {
  uint64_t epoch_number = kUnknownEpochNumber;
  std::string file_checksum = kUnknownFileChecksum;
  std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
-  uint64_t paranoid_hash{};
+  uint64_t paranoid_hash;
  bool marked_for_compaction;
  UniqueId64x2 unique_id{};
  TableProperties table_properties;
-  bool is_proximal_level_output;
-  Temperature file_temperature = Temperature::kUnknown;

  CompactionServiceOutputFile() = default;
  CompactionServiceOutputFile(
-      const std::string& name, uint64_t size, 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& 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,
      bool _marked_for_compaction, UniqueId64x2 _unique_id,
-      const TableProperties& _table_properties, bool _is_proximal_level_output,
-      Temperature _file_temperature)
+      const TableProperties& _table_properties)
      : file_name(name),
-        file_size(size),
        smallest_seqno(smallest),
        largest_seqno(largest),
        smallest_internal_key(std::move(_smallest_internal_key)),
@@ -456,9 +454,7 @@ struct CompactionServiceOutputFile {
        paranoid_hash(_paranoid_hash),
        marked_for_compaction(_marked_for_compaction),
        unique_id(std::move(_unique_id)),
-        table_properties(_table_properties),
-        is_proximal_level_output(_is_proximal_level_output),
-        file_temperature(_file_temperature) {}
+        table_properties(_table_properties) {}
 };

 // CompactionServiceResult contains the compaction result from a different db
@@ -474,21 +470,8 @@ struct CompactionServiceResult {

  uint64_t bytes_read = 0;
  uint64_t bytes_written = 0;
-
-  // Job-level Compaction Stats.
-  //
-  // NOTE: Job level stats cannot be rebuilt from scratch by simply aggregating
-  // per-level stats due to some fields populated directly during compaction
-  // (e.g. RecordDroppedKeys()). This is why we need both job-level stats and
-  // per-level in the serialized result. If rebuilding job-level stats from
-  // per-level stats become possible in the future, consider deprecating this
-  // field.
  CompactionJobStats stats;

-  // Per-level Compaction Stats for both output_level_stats and
-  // proximal_level_stats
-  InternalStats::CompactionStatsFull internal_stats;
-
  // serialization interface to read and write the object
  static Status Read(const std::string& data_str, CompactionServiceResult* obj);
  Status Write(std::string* output);
@@ -511,9 +494,9 @@ class CompactionServiceCompactionJob : private CompactionJob {
      const std::atomic<bool>* shutting_down, LogBuffer* log_buffer,
      FSDirectory* output_directory, Statistics* stats,
      InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-      JobContext* job_context, std::shared_ptr<Cache> table_cache,
-      EventLogger* event_logger, const std::string& dbname,
-      const std::shared_ptr<IOTracer>& io_tracer,
+      std::vector<SequenceNumber> existing_snapshots,
+      std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
+      const std::string& dbname, const std::shared_ptr<IOTracer>& io_tracer,
      const std::atomic<bool>& manual_compaction_canceled,
      const std::string& db_id, const std::string& db_session_id,
      std::string output_path,
@@ -534,6 +517,9 @@ 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;
@@ -43,6 +43,7 @@ void VerifyInitializationOfCompactionJobStats(
  ASSERT_EQ(compaction_job_stats.elapsed_micros, 0U);

  ASSERT_EQ(compaction_job_stats.num_input_records, 0U);
+  ASSERT_EQ(compaction_job_stats.num_input_files, 0U);
  ASSERT_EQ(compaction_job_stats.num_input_files_at_output_level, 0U);

  ASSERT_EQ(compaction_job_stats.num_output_records, 0U);
@@ -51,6 +52,7 @@ void VerifyInitializationOfCompactionJobStats(
  ASSERT_TRUE(compaction_job_stats.is_manual_compaction);
  ASSERT_FALSE(compaction_job_stats.is_remote_compaction);

+  ASSERT_EQ(compaction_job_stats.total_input_bytes, 0U);
  ASSERT_EQ(compaction_job_stats.total_output_bytes, 0U);

  ASSERT_EQ(compaction_job_stats.total_input_raw_key_bytes, 0U);
@@ -458,10 +460,9 @@ class CompactionJobTestBase : public testing::Test {
      ReadOptions read_opts;
      Status s = cf_options_.table_factory->NewTableReader(
          read_opts,
-          TableReaderOptions(cfd->ioptions(), /*prefix_extractor=*/nullptr,
-                             /*compression_manager=*/nullptr, FileOptions(),
+          TableReaderOptions(cfd->ioptions(), nullptr, FileOptions(),
                             cfd_->internal_comparator(),
-                             /*block_protection_bytes_per_key=*/0),
+                             0 /* block_protection_bytes_per_key */),
          std::move(freader), file_size, &table_reader, false);
      ASSERT_OK(s);
      assert(table_reader);
@@ -594,11 +595,11 @@ class CompactionJobTestBase : public testing::Test {
      const std::vector<std::vector<FileMetaData*>>& input_files,
      const std::vector<int> input_levels,
      std::function<void(Compaction& comp)>&& verify_func,
-      std::vector<SequenceNumber>&& snapshots = {}) {
+      const std::vector<SequenceNumber>& snapshots = {}) {
    const int kLastLevel = cf_options_.num_levels - 1;
    verify_per_key_placement_ = std::move(verify_func);
    mock::KVVector empty_map;
-    RunCompaction(input_files, input_levels, {empty_map}, std::move(snapshots),
+    RunCompaction(input_files, input_levels, {empty_map}, snapshots,
                  kMaxSequenceNumber, kLastLevel, false);
  }

@@ -607,7 +608,7 @@ class CompactionJobTestBase : public testing::Test {
      const std::vector<std::vector<FileMetaData*>>& input_files,
      const std::vector<int>& input_levels,
      const std::vector<mock::KVVector>& expected_results,
-      std::vector<SequenceNumber>&& snapshots = {},
+      const std::vector<SequenceNumber>& snapshots = {},
      SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
      int output_level = 1, bool verify = true,
      std::vector<uint64_t> expected_oldest_blob_file_numbers = {},
@@ -651,8 +652,7 @@ class CompactionJobTestBase : public testing::Test {
        mutable_cf_options_.max_compaction_bytes, 0, kNoCompression,
        cfd->GetLatestMutableCFOptions().compression_opts,
        Temperature::kUnknown, max_subcompactions, grandparents,
-        /*earliest_snapshot*/ std::nullopt, /*snapshot_checker*/ nullptr,
-        CompactionReason::kManualCompaction);
+        /*earliest_snapshot*/ std::nullopt, /*snapshot_checker*/ nullptr, true);
    compaction.FinalizeInputInfo(cfd->current());

    assert(db_options_.info_log);
@@ -665,15 +665,13 @@ class CompactionJobTestBase : public testing::Test {
                ucmp_->timestamp_size() == full_history_ts_low_.size());
    const std::atomic<bool> kManualCompactionCanceledFalse{false};
    JobContext job_context(1, false /* create_superversion */);
-    job_context.InitSnapshotContext(snapshot_checker, nullptr,
-                                    earliest_write_conflict_snapshot,
-                                    std::move(snapshots));
    CompactionJob compaction_job(
        0, &compaction, db_options_, mutable_db_options_, env_options_,
        versions_.get(), &shutting_down_, &log_buffer, nullptr, nullptr,
-        nullptr, nullptr, &mutex_, &error_handler_, &job_context, table_cache_,
-        &event_logger, false, false, dbname_, &compaction_job_stats_,
-        Env::Priority::USER, nullptr /* IOTracer */,
+        nullptr, nullptr, &mutex_, &error_handler_, snapshots,
+        earliest_write_conflict_snapshot, snapshot_checker, &job_context,
+        table_cache_, &event_logger, false, false, dbname_,
+        &compaction_job_stats_, Env::Priority::USER, nullptr /* IOTracer */,
        /*manual_compaction_canceled=*/kManualCompactionCanceledFalse,
        env_->GenerateUniqueId(), DBImpl::GenerateDbSessionId(nullptr),
        full_history_ts_low_);
@@ -1476,7 +1474,7 @@ TEST_F(CompactionJobTest, OldestBlobFileNumber) {
                /* expected_oldest_blob_file_numbers */ {19});
 }

-TEST_F(CompactionJobTest, VerifyProximalLevelOutput) {
+TEST_F(CompactionJobTest, VerifyPenultimateLevelOutput) {
  cf_options_.last_level_temperature = Temperature::kCold;
  SyncPoint::GetInstance()->SetCallBack(
      "Compaction::SupportsPerKeyPlacement:Enabled", [&](void* arg) {
@@ -1489,7 +1487,8 @@ TEST_F(CompactionJobTest, VerifyProximalLevelOutput) {
  SyncPoint::GetInstance()->SetCallBack(
      "CompactionIterator::PrepareOutput.context", [&](void* arg) {
        auto context = static_cast<PerKeyPlacementContext*>(arg);
-        context->output_to_proximal_level = context->seq_num > latest_cold_seq;
+        context->output_to_penultimate_level =
+            context->seq_num > latest_cold_seq;
      });
  SyncPoint::GetInstance()->EnableProcessing();

@@ -1535,11 +1534,11 @@ TEST_F(CompactionJobTest, VerifyProximalLevelOutput) {
      /*verify_func=*/[&](Compaction& comp) {
        for (char c = 'a'; c <= 'z'; c++) {
          if (c == 'a') {
-            comp.TEST_AssertWithinProximalLevelOutputRange(
+            comp.TEST_AssertWithinPenultimateLevelOutputRange(
                "a", true /*expect_failure*/);
          } else {
            std::string c_str{c};
-            comp.TEST_AssertWithinProximalLevelOutputRange(c_str);
+            comp.TEST_AssertWithinPenultimateLevelOutputRange(c_str);
          }
        }
      });
@@ -1671,7 +1670,6 @@ TEST_F(CompactionJobTest, ResultSerialization) {
    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) /* file_size */,
        rnd64.Uniform(UINT64_MAX) /* smallest_seqno */,
        rnd64.Uniform(UINT64_MAX) /* largest_seqno */,
        rnd.RandomBinaryString(
@@ -1684,8 +1682,7 @@ TEST_F(CompactionJobTest, ResultSerialization) {
        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 /* unique_id */, tp,
-        false /* is_proximal_level_output */, Temperature::kHot);
+        rnd.OneIn(2) /* marked_for_compaction */, id /* unique_id */, tp);
  }
  result.output_level = rnd.Uniform(10);
  result.output_path = rnd.RandomString(rnd.Uniform(kStrMaxLen));
@@ -1739,8 +1736,6 @@ TEST_F(CompactionJobTest, ResultSerialization) {
    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);
-    ASSERT_EQ(deserialized_tmp.output_files[0].file_temperature,
-              Temperature::kHot);
  }

  // Test unknown field
@@ -2038,7 +2033,7 @@ TEST_F(CompactionJobTest, CutToAlignGrandparentBoundarySameKey) {
    snapshots.emplace_back(i);
  }
  RunCompaction({lvl0_files, lvl1_files}, input_levels,
-                {expected_file1, expected_file2}, std::move(snapshots));
+                {expected_file1, expected_file2}, snapshots);
 }

 TEST_F(CompactionJobTest, CutForMaxCompactionBytesSameKey) {
@@ -2097,8 +2092,7 @@ TEST_F(CompactionJobTest, CutForMaxCompactionBytesSameKey) {
    snapshots.emplace_back(i);
  }
  RunCompaction({lvl0_files, lvl1_files}, input_levels,
-                {expected_file1, expected_file2, expected_file3},
-                std::move(snapshots));
+                {expected_file1, expected_file2, expected_file3}, snapshots);
 }

 class CompactionJobTimestampTest : public CompactionJobTestBase {
@@ -54,8 +54,7 @@ Status CompactionOutputs::Finish(
  }
  current_output().finished = true;
  stats_.bytes_written += current_bytes;
-  stats_.bytes_written_pre_comp += builder_->PreCompressionSize();
-  stats_.num_output_files = static_cast<int>(outputs_.size());
+  stats_.num_output_files = outputs_.size();

  return s;
 }
@@ -793,8 +792,8 @@ void CompactionOutputs::FillFilesToCutForTtl() {
 }

 CompactionOutputs::CompactionOutputs(const Compaction* compaction,
-                                     const bool is_proximal_level)
-    : compaction_(compaction), is_proximal_level_(is_proximal_level) {
+                                     const bool is_penultimate_level)
+    : compaction_(compaction), is_penultimate_level_(is_penultimate_level) {
  partitioner_ = compaction->output_level() == 0
                     ? nullptr
                     : compaction->CreateSstPartitioner();
@@ -30,32 +30,29 @@ class CompactionOutputs {
  // compaction output file
  struct Output {
    Output(FileMetaData&& _meta, const InternalKeyComparator& _icmp,
-           bool _enable_hash, bool _finished, uint64_t precalculated_hash,
-           bool _is_proximal_level)
+           bool _enable_hash, bool _finished, uint64_t precalculated_hash)
        : meta(std::move(_meta)),
          validator(_icmp, _enable_hash, precalculated_hash),
-          finished(_finished),
-          is_proximal_level(_is_proximal_level) {}
+          finished(_finished) {}
    FileMetaData meta;
    OutputValidator validator;
    bool finished;
-    bool is_proximal_level;
    std::shared_ptr<const TableProperties> table_properties;
  };

  CompactionOutputs() = delete;

  explicit CompactionOutputs(const Compaction* compaction,
-                             const bool is_proximal_level);
+                             const bool is_penultimate_level);

-  bool IsProximalLevel() const { return is_proximal_level_; }
+  bool IsPenultimateLevel() const { return is_penultimate_level_; }

  // Add generated output to the list
  void AddOutput(FileMetaData&& meta, const InternalKeyComparator& icmp,
                 bool enable_hash, bool finished = false,
                 uint64_t precalculated_hash = 0) {
    outputs_.emplace_back(std::move(meta), icmp, enable_hash, finished,
-                          precalculated_hash, is_proximal_level_);
+                          precalculated_hash);
  }

  // Set new table builder for the current output
@@ -66,29 +63,34 @@ class CompactionOutputs {
    file_writer_.reset(writer);
  }

+  // TODO: Remove it when remote compaction support tiered compaction
+  void AddBytesWritten(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 {
-    if (is_proximal_level_) {
+    if (is_penultimate_level_) {
      assert(blob_file_additions_.empty());
    }
    return blob_file_additions_;
  }

  std::vector<BlobFileAddition>* GetBlobFileAdditionsPtr() {
-    assert(!is_proximal_level_);
+    assert(!is_penultimate_level_);
    return &blob_file_additions_;
  }

  bool HasBlobFileAdditions() const { return !blob_file_additions_.empty(); }

  BlobGarbageMeter* CreateBlobGarbageMeter() {
-    assert(!is_proximal_level_);
+    assert(!is_penultimate_level_);
    blob_garbage_meter_ = std::make_unique<BlobGarbageMeter>();
    return blob_garbage_meter_.get();
  }

  BlobGarbageMeter* GetBlobGarbageMeter() const {
-    if (is_proximal_level_) {
+    if (is_penultimate_level_) {
      // blobdb doesn't support per_key_placement yet
      assert(blob_garbage_meter_ == nullptr);
      return nullptr;
@@ -97,9 +99,8 @@ class CompactionOutputs {
  }

  void UpdateBlobStats() {
-    assert(!is_proximal_level_);
-    stats_.num_output_files_blob =
-        static_cast<int>(blob_file_additions_.size());
+    assert(!is_penultimate_level_);
+    stats_.num_output_files_blob = blob_file_additions_.size();
    for (const auto& blob : blob_file_additions_) {
      stats_.bytes_written_blob += blob.GetTotalBlobBytes();
    }
@@ -303,12 +304,12 @@ class CompactionOutputs {
  std::vector<BlobFileAddition> blob_file_additions_;
  std::unique_ptr<BlobGarbageMeter> blob_garbage_meter_;

-  // Per level's output stat
-  InternalStats::CompactionStats stats_;
+  // Basic compaction output stats for this level's outputs
+  InternalStats::CompactionOutputsStats stats_;

-  // indicate if this CompactionOutputs obj for proximal_level, should always
+  // indicate if this CompactionOutputs obj for penultimate_level, should always
  // be false if per_key_placement feature is not enabled.
-  const bool is_proximal_level_;
+  const bool is_penultimate_level_;

  // partitioner information
  std::string last_key_for_partitioner_;
@@ -362,7 +363,7 @@ class CompactionOutputs {
  std::vector<size_t> level_ptrs_;
 };

-// helper struct to concatenate the last level and proximal level outputs
+// helper struct to concatenate the last level and penultimate level outputs
 // which could be replaced by std::ranges::join_view() in c++20
 struct OutputIterator {
 public:
@@ -272,8 +272,8 @@ bool CompactionPicker::RangeOverlapWithCompaction(
      return true;
    }
    if (c->SupportsPerKeyPlacement()) {
-      if (c->OverlapProximalLevelOutputRange(smallest_user_key,
-                                             largest_user_key)) {
+      if (c->OverlapPenultimateLevelOutputRange(smallest_user_key,
+                                                largest_user_key)) {
        return true;
      }
    }
@@ -284,7 +284,7 @@ bool CompactionPicker::RangeOverlapWithCompaction(

 bool CompactionPicker::FilesRangeOverlapWithCompaction(
    const std::vector<CompactionInputFiles>& inputs, int level,
-    int proximal_level) const {
+    int penultimate_level) const {
  bool is_empty = true;
  for (auto& in : inputs) {
    if (!in.empty()) {
@@ -301,18 +301,18 @@ bool CompactionPicker::FilesRangeOverlapWithCompaction(
  //  files cannot be overlapped in the order of L0 files.
  InternalKey smallest, largest;
  GetRange(inputs, &smallest, &largest, Compaction::kInvalidLevel);
-  if (proximal_level != Compaction::kInvalidLevel) {
+  if (penultimate_level != Compaction::kInvalidLevel) {
    if (ioptions_.compaction_style == kCompactionStyleUniversal) {
      if (RangeOverlapWithCompaction(smallest.user_key(), largest.user_key(),
-                                     proximal_level)) {
+                                     penultimate_level)) {
        return true;
      }
    } else {
-      InternalKey proximal_smallest, proximal_largest;
-      GetRange(inputs, &proximal_smallest, &proximal_largest, level);
-      if (RangeOverlapWithCompaction(proximal_smallest.user_key(),
-                                     proximal_largest.user_key(),
-                                     proximal_level)) {
+      InternalKey penultimate_smallest, penultimate_largest;
+      GetRange(inputs, &penultimate_smallest, &penultimate_largest, level);
+      if (RangeOverlapWithCompaction(penultimate_smallest.user_key(),
+                                     penultimate_largest.user_key(),
+                                     penultimate_level)) {
        return true;
      }
    }
@@ -337,9 +337,7 @@ Compaction* CompactionPicker::CompactFiles(
    const CompactionOptions& compact_options,
    const std::vector<CompactionInputFiles>& input_files, int output_level,
    VersionStorageInfo* vstorage, const MutableCFOptions& mutable_cf_options,
-    const MutableDBOptions& mutable_db_options, uint32_t output_path_id,
-    std::optional<SequenceNumber> earliest_snapshot,
-    const SnapshotChecker* snapshot_checker) {
+    const MutableDBOptions& mutable_db_options, uint32_t output_path_id) {
 #ifndef NDEBUG
  assert(input_files.size());
  // This compaction output should not overlap with a running compaction as
@@ -355,7 +353,7 @@ Compaction* CompactionPicker::CompactFiles(
  }
  assert(output_level == 0 || !FilesRangeOverlapWithCompaction(
                                  input_files, output_level,
-                                  Compaction::EvaluateProximalLevel(
+                                  Compaction::EvaluatePenultimateLevel(
                                      vstorage, mutable_cf_options, ioptions_,
                                      start_level, output_level)));
 #endif /* !NDEBUG */
@@ -382,8 +380,8 @@ Compaction* CompactionPicker::CompactFiles(
      GetCompressionOptions(mutable_cf_options, vstorage, output_level),
      mutable_cf_options.default_write_temperature,
      compact_options.max_subcompactions,
-      /* grandparents */ {}, earliest_snapshot, snapshot_checker,
-      CompactionReason::kManualCompaction);
+      /* grandparents */ {}, /* earliest_snapshot */ std::nullopt,
+      /* snapshot_checker */ nullptr, true);
  RegisterCompaction(c);
  return c;
 }
@@ -661,9 +659,9 @@ Compaction* CompactionPicker::CompactRange(
    // overlaping outputs in the same level.
    if (FilesRangeOverlapWithCompaction(
            inputs, output_level,
-            Compaction::EvaluateProximalLevel(vstorage, mutable_cf_options,
-                                              ioptions_, start_level,
-                                              output_level))) {
+            Compaction::EvaluatePenultimateLevel(vstorage, mutable_cf_options,
+                                                 ioptions_, start_level,
+                                                 output_level))) {
      // This compaction output could potentially conflict with the output
      // of a currently running compaction, we cannot run it.
      *manual_conflict = true;
@@ -682,9 +680,10 @@ Compaction* CompactionPicker::CompactRange(
        mutable_cf_options.default_write_temperature,
        compact_range_options.max_subcompactions,
        /* grandparents */ {}, /* earliest_snapshot */ std::nullopt,
-        /* snapshot_checker */ nullptr, CompactionReason::kManualCompaction,
-        trim_ts, /* score */ -1,
-        /* l0_files_might_overlap */ true,
+        /* snapshot_checker */ nullptr,
+        /* is manual */ true, trim_ts, /* score */ -1,
+        /* deletion_compaction */ false, /* l0_files_might_overlap */ true,
+        CompactionReason::kUnknown,
        compact_range_options.blob_garbage_collection_policy,
        compact_range_options.blob_garbage_collection_age_cutoff);

@@ -849,9 +848,9 @@ Compaction* CompactionPicker::CompactRange(
  // overlaping outputs in the same level.
  if (FilesRangeOverlapWithCompaction(
          compaction_inputs, output_level,
-          Compaction::EvaluateProximalLevel(vstorage, mutable_cf_options,
-                                            ioptions_, input_level,
-                                            output_level))) {
+          Compaction::EvaluatePenultimateLevel(vstorage, mutable_cf_options,
+                                               ioptions_, input_level,
+                                               output_level))) {
    // This compaction output could potentially conflict with the output
    // of a currently running compaction, we cannot run it.
    *manual_conflict = true;
@@ -874,8 +873,9 @@ Compaction* CompactionPicker::CompactRange(
      mutable_cf_options.default_write_temperature,
      compact_range_options.max_subcompactions, std::move(grandparents),
      /* earliest_snapshot */ std::nullopt, /* snapshot_checker */ nullptr,
-      CompactionReason::kManualCompaction, trim_ts, /* score */ -1,
-      /* l0_files_might_overlap */ true,
+      /* is manual */ true, trim_ts, /* score */ -1,
+      /* deletion_compaction */ false, /* l0_files_might_overlap */ true,
+      CompactionReason::kUnknown,
      compact_range_options.blob_garbage_collection_policy,
      compact_range_options.blob_garbage_collection_age_cutoff);

@@ -1137,7 +1137,7 @@ Status CompactionPicker::SanitizeAndConvertCompactionInputFiles(
  if (output_level != 0 &&
      FilesRangeOverlapWithCompaction(
          *converted_input_files, output_level,
-          Compaction::EvaluateProximalLevel(
+          Compaction::EvaluatePenultimateLevel(
              version->storage_info(), version->GetMutableCFOptions(),
              ioptions_, (*converted_input_files)[0].level, output_level))) {
    return Status::Aborted(
@@ -1154,7 +1154,7 @@ void CompactionPicker::RegisterCompaction(Compaction* c) {
  assert(ioptions_.compaction_style != kCompactionStyleLevel ||
         c->output_level() == 0 ||
         !FilesRangeOverlapWithCompaction(*c->inputs(), c->output_level(),
-                                          c->GetProximalLevel()));
+                                          c->GetPenultimateLevel()));
  // CompactionReason::kExternalSstIngestion's start level is just a placeholder
  // number without actual meaning as file ingestion technically does not have
  // an input level like other compactions
@@ -65,7 +65,7 @@ class CompactionPicker {
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& existing_snapshots,
      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer, bool require_max_output_level) = 0;
+      LogBuffer* log_buffer) = 0;

  // The returned Compaction might not include the whole requested range.
  // In that case, compaction_end will be set to the next key that needs
@@ -117,17 +117,12 @@ class CompactionPicker {
  // 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.
-  //
-  //  TODO - Remove default values for earliest_snapshot and snapshot_checker
-  //  and require all callers to pass them in so that DB::CompactFiles() can
-  //  also benefit from Standalone Range Tombstone Optimization
-  Compaction* CompactFiles(
-      const CompactionOptions& compact_options,
-      const std::vector<CompactionInputFiles>& input_files, int output_level,
-      VersionStorageInfo* vstorage, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options, uint32_t output_path_id,
-      std::optional<SequenceNumber> earliest_snapshot = std::nullopt,
-      const SnapshotChecker* snapshot_checker = nullptr);
+  Compaction* CompactFiles(const CompactionOptions& compact_options,
+                           const std::vector<CompactionInputFiles>& input_files,
+                           int output_level, VersionStorageInfo* vstorage,
+                           const MutableCFOptions& mutable_cf_options,
+                           const MutableDBOptions& mutable_db_options,
+                           uint32_t output_path_id);

  // Converts a set of compaction input file numbers into
  // a list of CompactionInputFiles.
@@ -143,12 +138,6 @@ class CompactionPicker {
    return !level0_compactions_in_progress_.empty();
  }

-  // Is any compaction in progress
-  bool IsCompactionInProgress() const {
-    return !(level0_compactions_in_progress_.empty() &&
-             compactions_in_progress_.empty());
-  }
-
  // Return true if the passed key range overlap with a compaction output
  // that is currently running.
  bool RangeOverlapWithCompaction(const Slice& smallest_user_key,
@@ -201,7 +190,7 @@ class CompactionPicker {
  // key range of a currently running compaction.
  bool FilesRangeOverlapWithCompaction(
      const std::vector<CompactionInputFiles>& inputs, int level,
-      int proximal_level) const;
+      int penultimate_level) const;

  bool SetupOtherInputs(const std::string& cf_name,
                        const MutableCFOptions& mutable_cf_options,
@@ -277,8 +266,7 @@ class NullCompactionPicker : public CompactionPicker {
      const MutableDBOptions& /*mutable_db_options*/,
      const std::vector<SequenceNumber>& /*existing_snapshots*/,
      const SnapshotChecker* /*snapshot_checker*/,
-      VersionStorageInfo* /*vstorage*/, LogBuffer* /* log_buffer */,
-      bool /*require_max_output_level*/ = false) override {
+      VersionStorageInfo* /*vstorage*/, LogBuffer* /* log_buffer */) override {
    return nullptr;
  }

@@ -127,9 +127,11 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
      mutable_cf_options.compression_opts,
      mutable_cf_options.default_write_temperature,
      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr, CompactionReason::kFIFOTtl,
+      /* snapshot_checker */ nullptr,
+      /* is manual */ false,
      /* trim_ts */ "", vstorage->CompactionScore(0),
-      /* l0_files_might_overlap */ true);
+      /* is deletion compaction */ true, /* l0_files_might_overlap */ true,
+      CompactionReason::kFIFOTtl);
  return c;
 }

@@ -198,10 +200,11 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
            mutable_cf_options.default_write_temperature,
            0 /* max_subcompactions */, {},
            /* earliest_snapshot */ std::nullopt,
-            /* snapshot_checker */ nullptr,
-            CompactionReason::kFIFOReduceNumFiles,
+            /* snapshot_checker */ nullptr, /* is manual */ false,
            /* trim_ts */ "", vstorage->CompactionScore(0),
-            /* l0_files_might_overlap */ true);
+            /* is deletion compaction */ false,
+            /* l0_files_might_overlap */ true,
+            CompactionReason::kFIFOReduceNumFiles);
        return c;
      }
    }
@@ -294,9 +297,11 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
      mutable_cf_options.compression_opts,
      mutable_cf_options.default_write_temperature,
      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr, CompactionReason::kFIFOMaxSize,
+      /* snapshot_checker */ nullptr,
+      /* is manual */ false,
      /* trim_ts */ "", vstorage->CompactionScore(0),
-      /* l0_files_might_overlap */ true);
+      /* is deletion compaction */ true,
+      /* l0_files_might_overlap */ true, CompactionReason::kFIFOMaxSize);
  return c;
 }

@@ -411,9 +416,10 @@ Compaction* FIFOCompactionPicker::PickTemperatureChangeCompaction(
      mutable_cf_options.compression, mutable_cf_options.compression_opts,
      compaction_target_temp,
      /* max_subcompactions */ 0, {}, /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr, CompactionReason::kChangeTemperature,
-      /* trim_ts */ "", vstorage->CompactionScore(0),
-      /* l0_files_might_overlap */ true);
+      /* snapshot_checker */ nullptr,
+      /* is manual */ false, /* trim_ts */ "", vstorage->CompactionScore(0),
+      /* is deletion compaction */ false, /* l0_files_might_overlap */ true,
+      CompactionReason::kChangeTemperature);
  return c;
 }

@@ -422,7 +428,7 @@ Compaction* FIFOCompactionPicker::PickCompaction(
    const MutableDBOptions& mutable_db_options,
    const std::vector<SequenceNumber>& /* existing_snapshots */,
    const SnapshotChecker* /* snapshot_checker */, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, bool /* require_max_output_level*/) {
+    LogBuffer* log_buffer) {
  Compaction* c = nullptr;
  if (mutable_cf_options.ttl > 0) {
    c = PickTTLCompaction(cf_name, mutable_cf_options, mutable_db_options,
@@ -23,8 +23,7 @@ class FIFOCompactionPicker : public CompactionPicker {
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& /* existing_snapshots */,
      const SnapshotChecker* /* snapshot_checker */,
-      VersionStorageInfo* version, LogBuffer* log_buffer,
-      bool /* require_max_output_level*/ = false) override;
+      VersionStorageInfo* version, LogBuffer* log_buffer) override;

  Compaction* CompactRange(const std::string& cf_name,
                           const MutableCFOptions& mutable_cf_options,
@@ -145,6 +145,7 @@ class LevelCompactionBuilder {
  int parent_index_ = -1;
  int base_index_ = -1;
  double start_level_score_ = 0;
+  bool is_manual_ = false;
  bool is_l0_trivial_move_ = false;
  CompactionInputFiles start_level_inputs_;
  std::vector<CompactionInputFiles> compaction_inputs_;
@@ -413,9 +414,9 @@ void LevelCompactionBuilder::SetupOtherFilesWithRoundRobinExpansion() {
                                                    &tmp_start_level_inputs) ||
        compaction_picker_->FilesRangeOverlapWithCompaction(
            {tmp_start_level_inputs}, output_level_,
-            Compaction::EvaluateProximalLevel(vstorage_, mutable_cf_options_,
-                                              ioptions_, start_level_,
-                                              output_level_))) {
+            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
+                                                 ioptions_, start_level_,
+                                                 output_level_))) {
      // Constraint 1a
      tmp_start_level_inputs.clear();
      return;
@@ -489,9 +490,9 @@ bool LevelCompactionBuilder::SetupOtherInputsIfNeeded() {
    // We need to disallow this from happening.
    if (compaction_picker_->FilesRangeOverlapWithCompaction(
            compaction_inputs_, output_level_,
-            Compaction::EvaluateProximalLevel(vstorage_, mutable_cf_options_,
-                                              ioptions_, start_level_,
-                                              output_level_))) {
+            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
+                                                 ioptions_, start_level_,
+                                                 output_level_))) {
      // This compaction output could potentially conflict with the output
      // of a currently running compaction, we cannot run it.
      return false;
@@ -560,8 +561,9 @@ Compaction* LevelCompactionBuilder::GetCompaction() {
      mutable_cf_options_.default_write_temperature,
      /* max_subcompactions */ 0, std::move(grandparents_),
      /* earliest_snapshot */ std::nullopt, /* snapshot_checker */ nullptr,
-      compaction_reason_,
-      /* trim_ts */ "", start_level_score_, l0_files_might_overlap);
+      is_manual_,
+      /* trim_ts */ "", start_level_score_, false /* deletion_compaction */,
+      l0_files_might_overlap, compaction_reason_);

  // If it's level 0 compaction, make sure we don't execute any other level 0
  // compactions in parallel
@@ -844,9 +846,9 @@ bool LevelCompactionBuilder::PickFileToCompact() {
                                                    &start_level_inputs_) ||
        compaction_picker_->FilesRangeOverlapWithCompaction(
            {start_level_inputs_}, output_level_,
-            Compaction::EvaluateProximalLevel(vstorage_, mutable_cf_options_,
-                                              ioptions_, start_level_,
-                                              output_level_))) {
+            Compaction::EvaluatePenultimateLevel(vstorage_, mutable_cf_options_,
+                                                 ioptions_, start_level_,
+                                                 output_level_))) {
      // A locked (pending compaction) input-level file was pulled in due to
      // user-key overlap.
      start_level_inputs_.clear();
@@ -976,7 +978,7 @@ Compaction* LevelCompactionPicker::PickCompaction(
    const MutableDBOptions& mutable_db_options,
    const std::vector<SequenceNumber>& /*existing_snapshots */,
    const SnapshotChecker* /*snapshot_checker*/, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, bool /* require_max_output_level*/) {
+    LogBuffer* log_buffer) {
  LevelCompactionBuilder builder(cf_name, vstorage, this, log_buffer,
                                 mutable_cf_options, ioptions_,
                                 mutable_db_options);
@@ -25,8 +25,7 @@ class LevelCompactionPicker : public CompactionPicker {
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& /* existing_snapshots */,
      const SnapshotChecker* /* snapshot_checker */,
-      VersionStorageInfo* vstorage, LogBuffer* log_buffer,
-      bool /*require_max_output_level*/ = false) override;
+      VersionStorageInfo* vstorage, LogBuffer* log_buffer) override;

  bool NeedsCompaction(const VersionStorageInfo* vstorage) const override;
 };
@@ -1134,15 +1134,10 @@ TEST_F(CompactionPickerTest, FIFOToCold1) {
    fifo_options_.max_table_files_size = kMaxSize;
    fifo_options_.file_temperature_age_thresholds = {
        {Temperature::kCold, kColdThreshold}};
-    fifo_options_.allow_trivial_copy_when_change_temperature = true;
-    fifo_options_.trivial_copy_buffer_size = 16 * 1024 * 1024;
    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;
-
-    auto copiedIOptions = ioptions_;
-    copiedIOptions.compaction_style = kCompactionStyleFIFO;
-    FIFOCompactionPicker fifo_compaction_picker(copiedIOptions, &icmp_);
+    FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);

    int64_t current_time = 0;
    ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
@@ -1191,10 +1186,7 @@ TEST_F(CompactionPickerTest, FIFOToColdMaxCompactionSize) {
    mutable_cf_options_.compaction_options_fifo = fifo_options_;
    mutable_cf_options_.level0_file_num_compaction_trigger = 100;
    mutable_cf_options_.max_compaction_bytes = kFileSize * 9;
-
-    auto copiedIOptions = ioptions_;
-    copiedIOptions.compaction_style = kCompactionStyleFIFO;
-    FIFOCompactionPicker fifo_compaction_picker(copiedIOptions, &icmp_);
+    FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);

    int64_t current_time = 0;
    ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
@@ -1261,10 +1253,7 @@ TEST_F(CompactionPickerTest, FIFOToColdWithExistingCold) {
    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;
-
-    auto copiedIOptions = ioptions_;
-    copiedIOptions.compaction_style = kCompactionStyleFIFO;
-    FIFOCompactionPicker fifo_compaction_picker(copiedIOptions, &icmp_);
+    FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);

    int64_t current_time = 0;
    ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
@@ -1329,10 +1318,7 @@ TEST_F(CompactionPickerTest, FIFOToColdWithHotBetweenCold) {
    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;
-
-    auto copiedIOptions = ioptions_;
-    copiedIOptions.compaction_style = kCompactionStyleFIFO;
-    FIFOCompactionPicker fifo_compaction_picker(copiedIOptions, &icmp_);
+    FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);

    int64_t current_time = 0;
    ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
@@ -1399,10 +1385,7 @@ TEST_F(CompactionPickerTest, FIFOToHotAndWarm) {
    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;
-
-    auto copiedIOptions = ioptions_;
-    copiedIOptions.compaction_style = kCompactionStyleFIFO;
-    FIFOCompactionPicker fifo_compaction_picker(copiedIOptions, &icmp_);
+    FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);

    int64_t current_time = 0;
    ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
@@ -3694,7 +3677,7 @@ TEST_F(CompactionPickerTest, UniversalSizeRatioTierCompactionLastLevel) {
  const uint64_t kFileSize = 100000;
  const int kNumLevels = 7;
  const int kLastLevel = kNumLevels - 1;
-  const int kProximalLevel = kLastLevel - 1;
+  const int kPenultimateLevel = kLastLevel - 1;

  ioptions_.compaction_style = kCompactionStyleUniversal;
  mutable_cf_options_.preclude_last_level_data_seconds = 1000;
@@ -3719,14 +3702,14 @@ TEST_F(CompactionPickerTest, UniversalSizeRatioTierCompactionLastLevel) {
  // Here to make sure it's size ratio compaction instead of size amp
  ASSERT_EQ(compaction->compaction_reason(),
            CompactionReason::kUniversalSizeRatio);
-  ASSERT_EQ(compaction->output_level(), kProximalLevel - 1);
+  ASSERT_EQ(compaction->output_level(), kPenultimateLevel - 1);
  ASSERT_EQ(compaction->input_levels(0)->num_files, 2);
  ASSERT_EQ(compaction->input_levels(5)->num_files, 0);
  ASSERT_EQ(compaction->input_levels(6)->num_files, 0);
 }

 TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionNotSuport) {
-  // Tiered compaction only support level_num > 2 (otherwise the proximal
+  // Tiered compaction only support level_num > 2 (otherwise the penultimate
  // level is going to be level 0, which may make thing more complicated), so
  // when there's only 2 level, still treating level 1 as the last level for
  // size amp compaction
@@ -3770,7 +3753,7 @@ TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionLastLevel) {
  const uint64_t kFileSize = 100000;
  const int kNumLevels = 7;
  const int kLastLevel = kNumLevels - 1;
-  const int kProximalLevel = kLastLevel - 1;
+  const int kPenultimateLevel = kLastLevel - 1;

  ioptions_.compaction_style = kCompactionStyleUniversal;
  mutable_cf_options_.preclude_last_level_data_seconds = 1000;
@@ -3792,10 +3775,10 @@ TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionLastLevel) {
          vstorage_.get(), &log_buffer_));

  // It's a Size Amp compaction, but doesn't include the last level file and
-  // output to the proximal level.
+  // output to the penultimate level.
  ASSERT_EQ(compaction->compaction_reason(),
            CompactionReason::kUniversalSizeAmplification);
-  ASSERT_EQ(compaction->output_level(), kProximalLevel);
+  ASSERT_EQ(compaction->output_level(), kPenultimateLevel);
  ASSERT_EQ(compaction->input_levels(0)->num_files, 2);
  ASSERT_EQ(compaction->input_levels(5)->num_files, 1);
  ASSERT_EQ(compaction->input_levels(6)->num_files, 0);
@@ -3957,7 +3940,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest, OverlapWithNormalCompaction) {
  ASSERT_EQ(enable_per_key_placement_,
            level_compaction_picker.FilesRangeOverlapWithCompaction(
                input_files, 6,
-                Compaction::EvaluateProximalLevel(
+                Compaction::EvaluatePenultimateLevel(
                    vstorage_.get(), mutable_cf_options_, ioptions_, 0, 6)));
 }

@@ -4045,7 +4028,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  ASSERT_EQ(enable_per_key_placement_,
            universal_compaction_picker.FilesRangeOverlapWithCompaction(
                input_files, 6,
-                Compaction::EvaluateProximalLevel(
+                Compaction::EvaluatePenultimateLevel(
                    vstorage_.get(), mutable_cf_options_, ioptions_, 0, 6)));
 }

@@ -4093,9 +4076,9 @@ TEST_P(PerKeyPlacementCompactionPickerTest, NormalCompactionOverlapUniversal) {
                input_files, 5, Compaction::kInvalidLevel));
 }

-TEST_P(PerKeyPlacementCompactionPickerTest, ProximalOverlapUniversal) {
+TEST_P(PerKeyPlacementCompactionPickerTest, PenultimateOverlapUniversal) {
  // This test is make sure the Tiered compaction would lock whole range of
-  // both output level and proximal level
+  // both output level and penultimate level
  if (enable_per_key_placement_) {
    mutable_cf_options_.preclude_last_level_data_seconds = 10000;
  }
@@ -4115,7 +4098,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest, ProximalOverlapUniversal) {
  UpdateVersionStorageInfo();

  // the existing compaction is the 1st L4 file + L6 file
-  // then compaction of the 2nd L4 file to L5 (proximal level) is overlapped
+  // then compaction of the 2nd L4 file to L5 (penultimate level) is overlapped
  // when the tiered compaction feature is on.
  CompactionOptions comp_options;
  std::unordered_set<uint64_t> input_set;
@@ -4204,9 +4187,9 @@ TEST_P(PerKeyPlacementCompactionPickerTest, LastLevelOnlyOverlapUniversal) {
 }

 TEST_P(PerKeyPlacementCompactionPickerTest,
-       LastLevelOnlyFailProximalUniversal) {
+       LastLevelOnlyFailPenultimateUniversal) {
  // This is to test last_level only compaction still unable to do the
-  // proximal level compaction if there's already a file in the proximal
+  // penultimate level compaction if there's already a file in the penultimate
  // level.
  // This should rarely happen in universal compaction, as the non-empty L5
  // should be included in the compaction.
@@ -4239,9 +4222,9 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
      mutable_db_options_, 0));

  ASSERT_TRUE(comp1);
-  ASSERT_EQ(comp1->GetProximalLevel(), Compaction::kInvalidLevel);
+  ASSERT_EQ(comp1->GetPenultimateLevel(), Compaction::kInvalidLevel);

-  // As comp1 cannot be output to the proximal level, compacting file 40 to
+  // As comp1 cannot be output to the penultimate level, compacting file 40 to
  // L5 is always safe.
  input_set.clear();
  input_files.clear();
@@ -4256,14 +4239,14 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
      comp_options, input_files, 5, vstorage_.get(), mutable_cf_options_,
      mutable_db_options_, 0));
  ASSERT_TRUE(comp2);
-  ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetProximalLevel());
+  ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetPenultimateLevel());
 }

 TEST_P(PerKeyPlacementCompactionPickerTest,
       LastLevelOnlyConflictWithOngoingUniversal) {
  // This is to test last_level only compaction still unable to do the
-  // proximal level compaction if there's already an ongoing compaction to
-  // the proximal level
+  // penultimate level compaction if there's already an ongoing compaction to
+  // the penultimate level
  if (enable_per_key_placement_) {
    mutable_cf_options_.preclude_last_level_data_seconds = 10000;
  }
@@ -4282,7 +4265,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  Add(6, 60U, "101", "351", 60000000U);
  UpdateVersionStorageInfo();

-  // create an ongoing compaction to L5 (proximal level)
+  // create an ongoing compaction to L5 (penultimate level)
  CompactionOptions comp_options;
  std::unordered_set<uint64_t> input_set;
  input_set.insert(40);
@@ -4295,7 +4278,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
      mutable_db_options_, 0));

  ASSERT_TRUE(comp1);
-  ASSERT_EQ(comp1->GetProximalLevel(), Compaction::kInvalidLevel);
+  ASSERT_EQ(comp1->GetPenultimateLevel(), Compaction::kInvalidLevel);

  input_set.clear();
  input_files.clear();
@@ -4306,7 +4289,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  ASSERT_EQ(enable_per_key_placement_,
            universal_compaction_picker.FilesRangeOverlapWithCompaction(
                input_files, 6,
-                Compaction::EvaluateProximalLevel(
+                Compaction::EvaluatePenultimateLevel(
                    vstorage_.get(), mutable_cf_options_, ioptions_, 6, 6)));

  if (!enable_per_key_placement_) {
@@ -4314,7 +4297,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
        comp_options, input_files, 6, vstorage_.get(), mutable_cf_options_,
        mutable_db_options_, 0));
    ASSERT_TRUE(comp2);
-    ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetProximalLevel());
+    ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetPenultimateLevel());
  }
 }

@@ -4323,7 +4306,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  // This is similar to `LastLevelOnlyConflictWithOngoingUniversal`, the only
  // change is the ongoing compaction to L5 has no overlap with the last level
  // compaction, so it's safe to move data from the last level to the
-  // proximal level.
+  // penultimate level.
  if (enable_per_key_placement_) {
    mutable_cf_options_.preclude_last_level_data_seconds = 10000;
  }
@@ -4342,7 +4325,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  Add(6, 60U, "101", "351", 60000000U);
  UpdateVersionStorageInfo();

-  // create an ongoing compaction to L5 (proximal level)
+  // create an ongoing compaction to L5 (penultimate level)
  CompactionOptions comp_options;
  std::unordered_set<uint64_t> input_set;
  input_set.insert(42);
@@ -4355,7 +4338,7 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
      mutable_db_options_, 0));

  ASSERT_TRUE(comp1);
-  ASSERT_EQ(comp1->GetProximalLevel(), Compaction::kInvalidLevel);
+  ASSERT_EQ(comp1->GetPenultimateLevel(), Compaction::kInvalidLevel);

  input_set.clear();
  input_files.clear();
@@ -4366,8 +4349,8 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
  // always safe to move data up
  ASSERT_FALSE(universal_compaction_picker.FilesRangeOverlapWithCompaction(
      input_files, 6,
-      Compaction::EvaluateProximalLevel(vstorage_.get(), mutable_cf_options_,
-                                        ioptions_, 6, 6)));
+      Compaction::EvaluatePenultimateLevel(vstorage_.get(), mutable_cf_options_,
+                                           ioptions_, 6, 6)));

  // 2 compactions can be run in parallel
  std::unique_ptr<Compaction> comp2(universal_compaction_picker.CompactFiles(
@@ -4375,9 +4358,9 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
      mutable_db_options_, 0));
  ASSERT_TRUE(comp2);
  if (enable_per_key_placement_) {
-    ASSERT_NE(Compaction::kInvalidLevel, comp2->GetProximalLevel());
+    ASSERT_NE(Compaction::kInvalidLevel, comp2->GetPenultimateLevel());
  } else {
-    ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetProximalLevel());
+    ASSERT_EQ(Compaction::kInvalidLevel, comp2->GetPenultimateLevel());
  }
 }

@@ -38,8 +38,7 @@ class UniversalCompactionBuilder {
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& existing_snapshots,
      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-      UniversalCompactionPicker* picker, LogBuffer* log_buffer,
-      bool require_max_output_level)
+      UniversalCompactionPicker* picker, LogBuffer* log_buffer)
      : ioptions_(ioptions),
        icmp_(icmp),
        cf_name_(cf_name),
@@ -47,8 +46,7 @@ class UniversalCompactionBuilder {
        mutable_db_options_(mutable_db_options),
        vstorage_(vstorage),
        picker_(picker),
-        log_buffer_(log_buffer),
-        require_max_output_level_(require_max_output_level) {
+        log_buffer_(log_buffer) {
    assert(icmp_);
    const auto* ucmp = icmp_->user_comparator();
    assert(ucmp);
@@ -104,174 +102,6 @@ class UniversalCompactionBuilder {
    bool level_has_marked_standalone_rangedel;
  };

-  unsigned int GetMaxNumFilesToCompactBasedOnMaxReadAmp(
-      const int file_num_compaction_trigger, const unsigned int ratio,
-      int* num_sr_not_compacted_output, int* max_num_runs_output) const {
-    assert(num_sr_not_compacted_output);
-    assert(max_num_runs_output);
-    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
-    }
-
-    // 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++) {
-      if (sorted_runs_[i].being_compacted == false &&
-          !sorted_runs_[i].level_has_marked_standalone_rangedel) {
-        num_sr_not_compacted++;
-      }
-    }
-
-    *num_sr_not_compacted_output = num_sr_not_compacted;
-    *max_num_runs_output = max_num_runs;
-
-    if (num_sr_not_compacted > max_num_runs) {
-      return num_sr_not_compacted - max_num_runs + 1;
-    } else {
-      return 0;
-    }
-  }
-
-  Compaction* MaybePickPeriodicCompaction(Compaction* const prev_picked_c) {
-    if (prev_picked_c != nullptr ||
-        vstorage_->FilesMarkedForPeriodicCompaction().empty()) {
-      return prev_picked_c;
-    }
-    // Always need to do a full compaction for periodic compaction.
-    Compaction* c = PickPeriodicCompaction();
-    TEST_SYNC_POINT_CALLBACK("PostPickPeriodicCompaction", c);
-    if (c != nullptr) {
-      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: picked for periodic compaction\n",
-                       cf_name_.c_str());
-    }
-    return c;
-  }
-
-  Compaction* MaybePickSizeAmpCompaction(Compaction* const prev_picked_c,
-                                         int file_num_compaction_trigger) {
-    if (prev_picked_c != nullptr ||
-        sorted_runs_.size() <
-            static_cast<size_t>(file_num_compaction_trigger)) {
-      return prev_picked_c;
-    }
-    Compaction* c = PickCompactionToReduceSizeAmp();
-    if (c != nullptr) {
-      TEST_SYNC_POINT("PickCompactionToReduceSizeAmpReturnNonnullptr");
-      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: picked for size amp compaction \n",
-                       cf_name_.c_str());
-    }
-    return c;
-  }
-
-  Compaction* MaybePickCompactionToReduceSortedRunsBasedFileRatio(
-      Compaction* const prev_picked_c, int file_num_compaction_trigger,
-      unsigned int ratio) {
-    if (prev_picked_c != nullptr ||
-        sorted_runs_.size() <
-            static_cast<size_t>(file_num_compaction_trigger)) {
-      return prev_picked_c;
-    }
-    Compaction* c = PickCompactionToReduceSortedRuns(ratio, UINT_MAX);
-    if (c != nullptr) {
-      TEST_SYNC_POINT("PickCompactionToReduceSortedRunsReturnNonnullptr");
-      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: picked for size ratio compaction to "
-                       "reduce sorted run\n",
-                       cf_name_.c_str());
-    }
-    return c;
-  }
-
-  Compaction* MaybePickCompactionToReduceSortedRuns(
-      Compaction* const prev_picked_c, int file_num_compaction_trigger,
-      unsigned int ratio) {
-    if (prev_picked_c != nullptr ||
-        sorted_runs_.size() <
-            static_cast<size_t>(file_num_compaction_trigger)) {
-      return prev_picked_c;
-    }
-
-    int num_sr_not_compacted = 0;
-    int max_num_runs = 0;
-    const unsigned int max_num_files_to_compact =
-        GetMaxNumFilesToCompactBasedOnMaxReadAmp(file_num_compaction_trigger,
-                                                 ratio, &num_sr_not_compacted,
-                                                 &max_num_runs);
-    if (max_num_files_to_compact == 0) {
-      ROCKS_LOG_BUFFER(
-          log_buffer_,
-          "[%s] Universal: skipping compaction to reduce sorted run, num "
-          "sorted 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_);
-      return nullptr;
-    }
-
-    Compaction* c =
-        PickCompactionToReduceSortedRuns(UINT_MAX, max_num_files_to_compact);
-    if (c != nullptr) {
-      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: picked for sorted run num compaction "
-                       "to reduce sorted run, to "
-                       "compact file num -- %u, max num runs allowed"
-                       "-- %d, max_run_size -- %" PRIu64 "\n",
-                       cf_name_.c_str(), max_num_files_to_compact, max_num_runs,
-                       max_run_size_);
-    }
-    return c;
-  }
-
-  Compaction* MaybePickDeleteTriggeredCompaction(
-      Compaction* const prev_picked_c) {
-    if (prev_picked_c != nullptr) {
-      return prev_picked_c;
-    }
-    Compaction* c = PickDeleteTriggeredCompaction();
-    if (c != nullptr) {
-      TEST_SYNC_POINT("PickDeleteTriggeredCompactionReturnNonnullptr");
-      ROCKS_LOG_BUFFER(
-          log_buffer_,
-          "[%s] Universal: picked for delete triggered compaction\n",
-          cf_name_.c_str());
-    }
-    return c;
-  }
-
  // Pick Universal compaction to limit read amplification
  Compaction* PickCompactionToReduceSortedRuns(
      unsigned int ratio, unsigned int max_number_of_files_to_compact);
@@ -419,13 +249,6 @@ class UniversalCompactionBuilder {
    return num_l0_to_exclude;
  }

-  bool MeetsOutputLevelRequirements(int output_level) const {
-    return !require_max_output_level_ ||
-           Compaction::OutputToNonZeroMaxOutputLevel(
-               output_level,
-               vstorage_->MaxOutputLevel(ioptions_.allow_ingest_behind));
-  }
-
  const ImmutableOptions& ioptions_;
  const InternalKeyComparator* icmp_;
  double score_;
@@ -437,7 +260,6 @@ class UniversalCompactionBuilder {
  VersionStorageInfo* vstorage_;
  UniversalCompactionPicker* picker_;
  LogBuffer* log_buffer_;
-  bool require_max_output_level_;
  // Optional earliest snapshot at time of compaction picking. This is only
  // provided if the column family doesn't enable user-defined timestamps.
  // And this information is only passed to `Compaction` picked by deletion
@@ -466,9 +288,7 @@ class UniversalCompactionBuilder {
 // and the index of the file in that level

 struct InputFileInfo {
-  InputFileInfo() : InputFileInfo(nullptr, 0, 0) {}
-  InputFileInfo(FileMetaData* file_meta, size_t l, size_t i)
-      : f(file_meta), level(l), index(i) {}
+  InputFileInfo() : f(nullptr), level(0), index(0) {}

  FileMetaData* f;
  size_t level;
@@ -501,14 +321,22 @@ SmallestKeyHeap create_level_heap(Compaction* c, const Comparator* ucmp) {
  SmallestKeyHeap smallest_key_priority_q =
      SmallestKeyHeap(SmallestKeyHeapComparator(ucmp));

+  InputFileInfo input_file;
+
  for (size_t l = 0; l < c->num_input_levels(); l++) {
    if (c->num_input_files(l) != 0) {
      if (l == 0 && c->start_level() == 0) {
        for (size_t i = 0; i < c->num_input_files(0); i++) {
-          smallest_key_priority_q.emplace(c->input(0, i), 0, i);
+          input_file.f = c->input(0, i);
+          input_file.level = 0;
+          input_file.index = i;
+          smallest_key_priority_q.push(std::move(input_file));
        }
      } else {
-        smallest_key_priority_q.emplace(c->input(l, 0), l, 0);
+        input_file.f = c->input(l, 0);
+        input_file.level = l;
+        input_file.index = 0;
+        smallest_key_priority_q.push(std::move(input_file));
      }
    }
  }
@@ -546,7 +374,7 @@ bool UniversalCompactionBuilder::IsInputFilesNonOverlapping(Compaction* c) {
  auto comparator = icmp_->user_comparator();
  int first_iter = 1;

-  InputFileInfo prev, curr;
+  InputFileInfo prev, curr, next;

  SmallestKeyHeap smallest_key_priority_q =
      create_level_heap(c, icmp_->user_comparator());
@@ -569,10 +397,17 @@ bool UniversalCompactionBuilder::IsInputFilesNonOverlapping(Compaction* c) {
      prev = curr;
    }

+    next.f = nullptr;
+
    if (c->level(curr.level) != 0 &&
        curr.index < c->num_input_files(curr.level) - 1) {
-      smallest_key_priority_q.emplace(c->input(curr.level, curr.index + 1),
-                                      curr.level, curr.index + 1);
+      next.f = c->input(curr.level, curr.index + 1);
+      next.level = curr.level;
+      next.index = curr.index + 1;
+    }
+
+    if (next.f) {
+      smallest_key_priority_q.push(std::move(next));
    }
  }
  return true;
@@ -598,11 +433,10 @@ Compaction* UniversalCompactionPicker::PickCompaction(
    const MutableDBOptions& mutable_db_options,
    const std::vector<SequenceNumber>& existing_snapshots,
    const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, bool require_max_output_level) {
+    LogBuffer* log_buffer) {
  UniversalCompactionBuilder builder(
      ioptions_, icmp_, cf_name, mutable_cf_options, mutable_db_options,
-      existing_snapshots, snapshot_checker, vstorage, this, log_buffer,
-      require_max_output_level);
+      existing_snapshots, snapshot_checker, vstorage, this, log_buffer);
  return builder.PickCompaction();
 }

@@ -733,21 +567,13 @@ bool UniversalCompactionBuilder::ShouldSkipMarkedFile(
 Compaction* UniversalCompactionBuilder::PickCompaction() {
  const int kLevel0 = 0;
  score_ = vstorage_->CompactionScore(kLevel0);
-  const int max_output_level =
+  int max_output_level =
      vstorage_->MaxOutputLevel(ioptions_.allow_ingest_behind);
-  const int file_num_compaction_trigger =
-      mutable_cf_options_.level0_file_num_compaction_trigger;
-  const unsigned int ratio =
-      mutable_cf_options_.compaction_options_universal.size_ratio;
-
-  if (max_output_level == 0 &&
-      !MeetsOutputLevelRequirements(0 /* output_level */)) {
-    return nullptr;
-  }
-
  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;

  if (sorted_runs_.size() == 0 ||
      (vstorage_->FilesMarkedForPeriodicCompaction().empty() &&
@@ -759,7 +585,6 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
        "UniversalCompactionBuilder::PickCompaction:Return", nullptr);
    return nullptr;
  }
-
  VersionStorageInfo::LevelSummaryStorage tmp;
  ROCKS_LOG_BUFFER_MAX_SZ(
      log_buffer_, 3072,
@@ -767,14 +592,119 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
      cf_name_.c_str(), sorted_runs_.size(), vstorage_->LevelSummary(&tmp));

  Compaction* c = nullptr;
+  // Periodic compaction has higher priority than other type of compaction
+  // because it's a hard requirement.
+  if (!vstorage_->FilesMarkedForPeriodicCompaction().empty()) {
+    // Always need to do a full compaction for periodic compaction.
+    c = PickPeriodicCompaction();
+    TEST_SYNC_POINT_CALLBACK("PostPickPeriodicCompaction", c);
+  }

-  c = MaybePickPeriodicCompaction(c);
-  c = MaybePickSizeAmpCompaction(c, file_num_compaction_trigger);
-  c = MaybePickCompactionToReduceSortedRunsBasedFileRatio(
-      c, file_num_compaction_trigger, ratio);
-  c = MaybePickCompactionToReduceSortedRuns(c, file_num_compaction_trigger,
-                                            ratio);
-  c = MaybePickDeleteTriggeredCompaction(c);
+  if (c == nullptr &&
+      sorted_runs_.size() >= static_cast<size_t>(file_num_compaction_trigger)) {
+    // Check for size amplification.
+    if ((c = PickCompactionToReduceSizeAmp()) != nullptr) {
+      TEST_SYNC_POINT("PickCompactionToReduceSizeAmpReturnNonnullptr");
+      ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: compacting for size amp\n",
+                       cf_name_.c_str());
+    } else {
+      // Size amplification is within limits. Try reducing read
+      // amplification while maintaining file size ratios.
+      unsigned int ratio =
+          mutable_cf_options_.compaction_options_universal.size_ratio;
+
+      if ((c = PickCompactionToReduceSortedRuns(ratio, UINT_MAX)) != nullptr) {
+        TEST_SYNC_POINT("PickCompactionToReduceSortedRunsReturnNonnullptr");
+        ROCKS_LOG_BUFFER(log_buffer_,
+                         "[%s] Universal: compacting for size ratio\n",
+                         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.
+
+        // 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
+        }
+        // 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++) {
+          if (sorted_runs_[i].being_compacted == false &&
+              !sorted_runs_[i].level_has_marked_standalone_rangedel) {
+            num_sr_not_compacted++;
+          }
+        }
+
+        // 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 ((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_);
+          }
+        } 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_);
+        }
+      }
+    }
+  }
+
+  if (c == nullptr) {
+    if ((c = PickDeleteTriggeredCompaction()) != nullptr) {
+      TEST_SYNC_POINT("PickDeleteTriggeredCompactionReturnNonnullptr");
+      ROCKS_LOG_BUFFER(log_buffer_,
+                       "[%s] Universal: delete triggered compaction\n",
+                       cf_name_.c_str());
+    }
+  }

  if (c == nullptr) {
    TEST_SYNC_POINT_CALLBACK(
@@ -783,7 +713,6 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
  }
  assert(c->output_level() <=
         vstorage_->MaxOutputLevel(ioptions_.allow_ingest_behind));
-  assert(MeetsOutputLevelRequirements(c->output_level()));

  if (mutable_cf_options_.compaction_options_universal.allow_trivial_move ==
          true &&
@@ -909,16 +838,14 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
      if (sr->being_compacted) {
        ROCKS_LOG_BUFFER(log_buffer_,
                         "[%s] Universal: %s"
-                         "[%d] being compacted, skipping for compaction to "
-                         "reduce sorted runs",
+                         "[%d] being compacted, skipping",
                         cf_name_.c_str(), file_num_buf, loop);
      } else if (sr->level_has_marked_standalone_rangedel) {
-        ROCKS_LOG_BUFFER(
-            log_buffer_,
-            "[%s] Universal: %s"
-            "[%d] has standalone range tombstone files marked for "
-            "compaction, skipping for compaction to reduce sorted runs",
-            cf_name_.c_str(), file_num_buf, loop);
+        ROCKS_LOG_BUFFER(log_buffer_,
+                         "[%s] Universal: %s"
+                         "[%d] has standalone range tombstone files marked for "
+                         "compaction, skipping",
+                         cf_name_.c_str(), file_num_buf, loop);
      }

      sr = nullptr;
@@ -931,8 +858,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf), true);
      ROCKS_LOG_BUFFER(log_buffer_,
-                       "[%s] Universal: Possible candidate for compaction to "
-                       "reduce sorted runs %s[%d].",
+                       "[%s] Universal: Possible candidate %s[%d].",
                       cf_name_.c_str(), file_num_buf, loop);
    }

@@ -1034,10 +960,6 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
    output_level = sorted_runs_[first_index_after].level - 1;
  }

-  if (!MeetsOutputLevelRequirements(output_level)) {
-    return nullptr;
-  }
-
  std::vector<CompactionInputFiles> inputs(max_output_level + 1);
  for (size_t i = 0; i < inputs.size(); ++i) {
    inputs[i].level = start_level + static_cast<int>(i);
@@ -1074,7 +996,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(

  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
                               inputs, output_level,
-                               Compaction::EvaluateProximalLevel(
+                               Compaction::EvaluatePenultimateLevel(
                                   vstorage_, mutable_cf_options_, ioptions_,
                                   start_level, output_level))) {
    return nullptr;
@@ -1097,9 +1019,10 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
                        mutable_cf_options_.default_write_temperature,
                        /* max_subcompactions */ 0, grandparents,
                        /* earliest_snapshot */ std::nullopt,
-                        /* snapshot_checker */ nullptr, compaction_reason,
-                        /* trim_ts */ "", score_,
-                        /* l0_files_might_overlap */ true);
+                        /* snapshot_checker */ nullptr,
+                        /* is manual */ false, /* trim_ts */ "", score_,
+                        false /* deletion_compaction */,
+                        /* l0_files_might_overlap */ true, compaction_reason);
 }

 // Look at overall size amplification. If size amplification
@@ -1129,19 +1052,18 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
      char file_num_buf[kFormatFileNumberBufSize];
      sr->Dump(file_num_buf, sizeof(file_num_buf), true);
      if (sr->being_compacted) {
-        ROCKS_LOG_BUFFER(log_buffer_,
-                         "[%s] Universal: stopping for size amp compaction at "
-                         "sorted run undergoing compaction: "
-                         "%s[%" ROCKSDB_PRIszt "]",
-                         cf_name_.c_str(), file_num_buf, start_index - 1);
+        ROCKS_LOG_BUFFER(
+            log_buffer_,
+            "[%s] Universal: stopping at sorted run undergoing compaction: "
+            "%s[%" ROCKSDB_PRIszt "]",
+            cf_name_.c_str(), file_num_buf, start_index - 1);
      } else if (sr->level_has_marked_standalone_rangedel) {
-        ROCKS_LOG_BUFFER(log_buffer_,
-                         "[%s] Universal: stopping for size amp compaction at "
-                         "sorted run that has "
-                         "standalone range "
-                         "tombstone files marked for compaction: "
-                         "%s[%" ROCKSDB_PRIszt "]",
-                         cf_name_.c_str(), file_num_buf, start_index - 1);
+        ROCKS_LOG_BUFFER(
+            log_buffer_,
+            "[%s] Universal: stopping at sorted run that has standalone range "
+            "tombstone files marked for compaction: "
+            "%s[%" ROCKSDB_PRIszt "]",
+            cf_name_.c_str(), file_num_buf, start_index - 1);
      }
      break;
    }
@@ -1157,12 +1079,11 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
  {
    const size_t num_l0_to_exclude = MightExcludeNewL0sToReduceWriteStop(
        num_l0_files, end_index, start_index, candidate_size);
-    ROCKS_LOG_BUFFER(
-        log_buffer_,
-        "[%s] Universal: Excluding for size amp compaction %" ROCKSDB_PRIszt
-        " latest L0 files to reduce potential write stop "
-        "triggered by `level0_stop_writes_trigger`",
-        cf_name_.c_str(), num_l0_to_exclude);
+    ROCKS_LOG_BUFFER(log_buffer_,
+                     "[%s] Universal: Excluding %" ROCKSDB_PRIszt
+                     " latest L0 files to reduce potential write stop "
+                     "triggered by `level0_stop_writes_trigger`",
+                     cf_name_.c_str(), num_l0_to_exclude);
  }

  {
@@ -1180,18 +1101,18 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {

  // size amplification = percentage of additional size
  if (candidate_size * 100 < ratio * base_sr_size) {
-    ROCKS_LOG_BUFFER(log_buffer_,
-                     "[%s] Universal: size amp compction not needed. "
-                     "newer-files-total-size %" PRIu64
-                     " earliest-file-size %" PRIu64,
-                     cf_name_.c_str(), candidate_size, base_sr_size);
+    ROCKS_LOG_BUFFER(
+        log_buffer_,
+        "[%s] Universal: size amp not needed. newer-files-total-size %" PRIu64
+        " earliest-file-size %" PRIu64,
+        cf_name_.c_str(), candidate_size, base_sr_size);
    return nullptr;
  } else {
-    ROCKS_LOG_BUFFER(log_buffer_,
-                     "[%s] Universal: size amp compaction needed. "
-                     "newer-files-total-size %" PRIu64
-                     " earliest-file-size %" PRIu64,
-                     cf_name_.c_str(), candidate_size, base_sr_size);
+    ROCKS_LOG_BUFFER(
+        log_buffer_,
+        "[%s] Universal: size amp needed. newer-files-total-size %" PRIu64
+        " earliest-file-size %" PRIu64,
+        cf_name_.c_str(), candidate_size, base_sr_size);
  }
  // Since incremental compaction can't include more than second last
  // level, it can introduce penalty, compared to full compaction. We
@@ -1424,7 +1345,7 @@ Compaction* UniversalCompactionBuilder::PickIncrementalForReduceSizeAmp(
  // intra L0 compactions outputs could have overlap
  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
                               inputs, output_level,
-                               Compaction::EvaluateProximalLevel(
+                               Compaction::EvaluatePenultimateLevel(
                                   vstorage_, mutable_cf_options_, ioptions_,
                                   start_level, output_level))) {
    return nullptr;
@@ -1446,9 +1367,10 @@ Compaction* UniversalCompactionBuilder::PickIncrementalForReduceSizeAmp(
      /* max_subcompactions */ 0, /* grandparents */ {},
      /* earliest_snapshot */ std::nullopt,
      /* snapshot_checker */ nullptr,
-      CompactionReason::kUniversalSizeAmplification,
-      /* trim_ts */ "", score_,
-      /* l0_files_might_overlap */ true);
+      /* is manual */ false,
+      /* trim_ts */ "", score_, false /* deletion_compaction */,
+      /* l0_files_might_overlap */ true,
+      CompactionReason::kUniversalSizeAmplification);
 }

 // Pick files marked for compaction. Typically, files are marked by
@@ -1541,10 +1463,6 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
    }
    assert(output_level <= max_output_level);

-    if (!MeetsOutputLevelRequirements(output_level)) {
-      return nullptr;
-    }
-
    if (output_level != 0) {
      if (start_level == 0) {
        if (!picker_->GetOverlappingL0Files(vstorage_, &start_level_inputs,
@@ -1568,9 +1486,9 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      }
      if (picker_->FilesRangeOverlapWithCompaction(
              inputs, output_level,
-              Compaction::EvaluateProximalLevel(vstorage_, mutable_cf_options_,
-                                                ioptions_, start_level,
-                                                output_level))) {
+              Compaction::EvaluatePenultimateLevel(
+                  vstorage_, mutable_cf_options_, ioptions_, start_level,
+                  output_level))) {
        return nullptr;
      }

@@ -1598,9 +1516,11 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level),
      mutable_cf_options_.default_write_temperature,
      /* max_subcompactions */ 0, grandparents, earliest_snapshot_,
-      snapshot_checker_, CompactionReason::kFilesMarkedForCompaction,
-      /* trim_ts */ "", score_,
-      /* l0_files_might_overlap */ true);
+      snapshot_checker_,
+      /* is manual */ false,
+      /* trim_ts */ "", score_, false /* deletion_compaction */,
+      /* l0_files_might_overlap */ true,
+      CompactionReason::kFilesMarkedForCompaction);
 }

 Compaction* UniversalCompactionBuilder::PickCompactionToOldest(
@@ -1667,14 +1587,10 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
    output_level = sorted_runs_[end_index + 1].level - 1;
  }

-  if (!MeetsOutputLevelRequirements(output_level)) {
-    return nullptr;
-  }
-
  // intra L0 compactions outputs could have overlap
  if (output_level != 0 && picker_->FilesRangeOverlapWithCompaction(
                               inputs, output_level,
-                               Compaction::EvaluateProximalLevel(
+                               Compaction::EvaluatePenultimateLevel(
                                   vstorage_, mutable_cf_options_, ioptions_,
                                   start_level, output_level))) {
    return nullptr;
@@ -1696,9 +1612,10 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
      mutable_cf_options_.default_write_temperature,
      /* max_subcompactions */ 0, /* grandparents */ {},
      /* earliest_snapshot */ std::nullopt,
-      /* snapshot_checker */ nullptr, compaction_reason,
-      /* trim_ts */ "", score_,
-      /* l0_files_might_overlap */ true);
+      /* snapshot_checker */ nullptr,
+      /* is manual */ false,
+      /* trim_ts */ "", score_, false /* deletion_compaction */,
+      /* l0_files_might_overlap */ true, compaction_reason);
 }

 Compaction* UniversalCompactionBuilder::PickPeriodicCompaction() {
@@ -18,15 +18,12 @@ class UniversalCompactionPicker : public CompactionPicker {
  UniversalCompactionPicker(const ImmutableOptions& ioptions,
                            const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}
-
-  // If `require_max_output_level` is true, only pick compaction
-  // with max output level or return nullptr if no such compaction exists.
  Compaction* PickCompaction(
      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
      const MutableDBOptions& mutable_db_options,
      const std::vector<SequenceNumber>& existing_snapshots,
      const SnapshotChecker* snapshot_checker, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer, bool require_max_output_level = false) override;
+      LogBuffer* log_buffer) override;
  int MaxOutputLevel() const override { return NumberLevels() - 1; }

  bool NeedsCompaction(const VersionStorageInfo* vstorage) const override;
@@ -41,7 +41,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
  }

  compaction_input.cf_name = compaction->column_family_data()->GetName();
-  compaction_input.snapshots = job_context_->snapshot_seqs;
+  compaction_input.snapshots = existing_snapshots_;
  compaction_input.has_begin = sub_compact->start.has_value();
  compaction_input.begin =
      compaction_input.has_begin ? sub_compact->start->ToString() : "";
@@ -74,14 +74,10 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
      compaction->column_family_data()->GetName().c_str(), job_id_,
      compaction_input.output_level, input_files_oss.str().c_str());
  CompactionServiceJobInfo info(
-      dbname_, db_id_, db_session_id_,
-      compaction->column_family_data()->GetID(),
-      compaction->column_family_data()->GetName(), GetCompactionId(sub_compact),
+      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(), compaction->start_level(),
-      compaction->output_level());
-
+      compaction->bottommost_level());
  CompactionServiceScheduleResponse response =
      db_options_.compaction_service->Schedule(info, compaction_input_binary);
  switch (response.status) {
@@ -114,9 +110,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
      break;
  }

-  std::string debug_str_before_wait =
-      compaction->input_version()->DebugString(/*hex=*/true);
-
  ROCKS_LOG_INFO(db_options_.info_log,
                 "[%s] [JOB %d] Waiting for remote compaction...",
                 compaction->column_family_data()->GetName().c_str(), job_id_);
@@ -125,17 +118,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
      db_options_.compaction_service->Wait(response.scheduled_job_id,
                                           &compaction_result_binary);

-  if (compaction_status != CompactionServiceJobStatus::kSuccess) {
-    ROCKS_LOG_ERROR(
-        db_options_.info_log,
-        "[%s] [JOB %d] Wait() status is not kSuccess. "
-        "\nDebugString Before Wait():\n%s"
-        "\nDebugString After Wait():\n%s",
-        compaction->column_family_data()->GetName().c_str(), job_id_,
-        debug_str_before_wait.c_str(),
-        compaction->input_version()->DebugString(/*hex=*/true).c_str());
-  }
-
  if (compaction_status == CompactionServiceJobStatus::kUseLocal) {
    ROCKS_LOG_INFO(
        db_options_.info_log,
@@ -221,24 +203,18 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    }

    FileMetaData meta;
-    uint64_t file_size = file.file_size;
-
-    // TODO - Clean this up in the next release.
-    // For backward compatibility - in case the remote worker does not populate
-    // the file_size yet. If missing, continue to populate this from the file
-    // system.
-    if (file_size == 0) {
-      s = fs_->GetFileSize(tgt_file, IOOptions(), &file_size, nullptr);
-    }
-
+    uint64_t file_size;
+    // FIXME: file_size should be part of CompactionServiceOutputFile so that
+    // we don't get DB corruption if the full file size has not been propagated
+    // back to the caller through the file system (which could have metadata
+    // lag or caching bugs).
+    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;
    }
-    assert(file_size > 0);
-
    meta.fd = FileDescriptor(file_num, compaction->output_path_id(), file_size,
                             file.smallest_seqno, file.largest_seqno);
    meta.smallest.DecodeFrom(file.smallest_internal_key);
@@ -250,35 +226,19 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    meta.file_checksum_func_name = file.file_checksum_func_name;
    meta.marked_for_compaction = file.marked_for_compaction;
    meta.unique_id = file.unique_id;
-    meta.temperature = file.file_temperature;
-    meta.tail_size =
-        FileMetaData::CalculateTailSize(file_size, file.table_properties);
+
    auto cfd = compaction->column_family_data();
-    CompactionOutputs* compaction_outputs =
-        sub_compact->Outputs(file.is_proximal_level_output);
-    assert(compaction_outputs);
-    compaction_outputs->AddOutput(std::move(meta), cfd->internal_comparator(),
-                                  false, true, file.paranoid_hash);
-    compaction_outputs->UpdateTableProperties(file.table_properties);
+    sub_compact->Current().AddOutput(std::move(meta),
+                                     cfd->internal_comparator(), false, true,
+                                     file.paranoid_hash);
+    sub_compact->Current().UpdateTableProperties(file.table_properties);
  }
-
-  // Set per-level stats
-  auto compaction_output_stats =
-      sub_compact->OutputStats(false /* is_proximal_level */);
-  assert(compaction_output_stats);
-  compaction_output_stats->Add(
-      compaction_result.internal_stats.output_level_stats);
-  if (compaction->SupportsPerKeyPlacement()) {
-    compaction_output_stats =
-        sub_compact->OutputStats(true /* is_proximal_level */);
-    assert(compaction_output_stats);
-    compaction_output_stats->Add(
-        compaction_result.internal_stats.proximal_level_stats);
-  }
-
-  // Set job stats
  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);
  RecordTick(stats_, REMOTE_COMPACT_READ_BYTES, compaction_result.bytes_read);
  RecordTick(stats_, REMOTE_COMPACT_WRITE_BYTES,
             compaction_result.bytes_written);
@@ -298,15 +258,27 @@ 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,
    VersionSet* versions, const std::atomic<bool>* shutting_down,
    LogBuffer* log_buffer, FSDirectory* output_directory, Statistics* stats,
    InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler,
-    JobContext* job_context, std::shared_ptr<Cache> table_cache,
-    EventLogger* event_logger, const std::string& dbname,
-    const std::shared_ptr<IOTracer>& io_tracer,
+    std::vector<SequenceNumber> existing_snapshots,
+    std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
+    const std::string& dbname, const std::shared_ptr<IOTracer>& io_tracer,
    const std::atomic<bool>& manual_compaction_canceled,
    const std::string& db_id, const std::string& db_session_id,
    std::string output_path,
@@ -315,8 +287,9 @@ CompactionServiceCompactionJob::CompactionServiceCompactionJob(
    : CompactionJob(job_id, compaction, db_options, mutable_db_options,
                    file_options, versions, shutting_down, log_buffer, nullptr,
                    output_directory, nullptr, stats, db_mutex,
-                    db_error_handler, job_context, std::move(table_cache),
-                    event_logger,
+                    db_error_handler, std::move(existing_snapshots),
+                    kMaxSequenceNumber, nullptr, nullptr,
+                    std::move(table_cache), event_logger,
                    compaction->mutable_cf_options().paranoid_file_checks,
                    compaction->mutable_cf_options().report_bg_io_stats, dbname,
                    &(compaction_service_result->stats), Env::Priority::USER,
@@ -358,14 +331,15 @@ Status CompactionServiceCompactionJob::Run() {

  ProcessKeyValueCompaction(sub_compact);

-  uint64_t elapsed_micros = db_options_.clock->NowMicros() - start_micros;
-  internal_stats_.SetMicros(elapsed_micros);
-  internal_stats_.AddCpuMicros(elapsed_micros);
+  compaction_stats_.stats.micros =
+      db_options_.clock->NowMicros() - start_micros;
+  compaction_stats_.stats.cpu_micros =
+      sub_compact->compaction_job_stats.cpu_micros;

  RecordTimeToHistogram(stats_, COMPACTION_TIME,
-                        internal_stats_.output_level_stats.micros);
+                        compaction_stats_.stats.micros);
  RecordTimeToHistogram(stats_, COMPACTION_CPU_TIME,
-                        internal_stats_.output_level_stats.cpu_micros);
+                        compaction_stats_.stats.cpu_micros);

  Status status = sub_compact->status;
  IOStatus io_s = sub_compact->io_status;
@@ -395,45 +369,38 @@ Status CompactionServiceCompactionJob::Run() {

  // Build Compaction Job Stats

-  // 1. Aggregate internal stats and job stats for all subcompactions
-  // internal stats: sub_compact.proximal_level_outputs_.stats and
-  //                 sub_compact.compaction_outputs_.stats into
-  //                 internal_stats_.output_level_stats and
-  //                 internal_stats_.proximal_level_stats
-  // job-level stats: sub_compact.compaction_job_stats into compact.job_stats_
-  //
-  // For remote compaction, there's only one subcompaction.
-  compact_->AggregateCompactionStats(internal_stats_, *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 job-level output stats with the aggregated internal_stats_
-  // Please note that input stats will be updated by primary host when all
-  // subcompactions are finished
-  UpdateCompactionJobOutputStats(internal_stats_);
-  // and set fields that are not propagated as part of the update
+  // 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;

-  // 3. Update IO Stats that are not part of the the update above
-  // (bytes_read, bytes_written)
+  // 4. Update IO Stats that are not part of the aggregations above (bytes_read,
+  // bytes_written)
  RecordCompactionIOStats();

  // Build Output
-  compaction_result_->internal_stats = internal_stats_;
  compaction_result_->output_level = compact_->compaction->output_level();
  compaction_result_->output_path = output_path_;
  if (status.ok()) {
    for (const auto& output_file : sub_compact->GetOutputs()) {
      auto& meta = output_file.meta;
      compaction_result_->output_files.emplace_back(
-          MakeTableFileName(meta.fd.GetNumber()), meta.fd.GetFileSize(),
-          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, *output_file.table_properties,
-          output_file.is_proximal_level, meta.temperature);
+          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,
+          *output_file.table_properties);
    }
  }

@@ -533,10 +500,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {offsetof(struct CompactionServiceOutputFile, file_name),
          OptionType::kEncodedString, OptionVerificationType::kNormal,
          OptionTypeFlags::kNone}},
-        {"file_size",
-         {offsetof(struct CompactionServiceOutputFile, file_size),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
        {"smallest_seqno",
         {offsetof(struct CompactionServiceOutputFile, smallest_seqno),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -609,16 +572,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
            const auto this_one = static_cast<const TableProperties*>(addr1);
            const auto that_one = static_cast<const TableProperties*>(addr2);
            return this_one->AreEqual(opts, that_one, mismatch);
-          }}},
-        {"is_proximal_level_output",
-         {offsetof(struct CompactionServiceOutputFile,
-                   is_proximal_level_output),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"file_temperature",
-         {offsetof(struct CompactionServiceOutputFile, file_temperature),
-          OptionType::kTemperature, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}}};
+          }}}};

 static std::unordered_map<std::string, OptionTypeInfo>
    compaction_job_stats_type_info = {
@@ -743,125 +697,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          OptionTypeFlags::kNone}},
 };

-static std::unordered_map<std::string, OptionTypeInfo>
-    compaction_stats_type_info = {
-        {"micros",
-         {offsetof(struct InternalStats::CompactionStats, micros),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"cpu_micros",
-         {offsetof(struct InternalStats::CompactionStats, cpu_micros),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_read_non_output_levels",
-         {offsetof(struct InternalStats::CompactionStats,
-                   bytes_read_non_output_levels),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_read_output_level",
-         {offsetof(struct InternalStats::CompactionStats,
-                   bytes_read_output_level),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_skipped_non_output_levels",
-         {offsetof(struct InternalStats::CompactionStats,
-                   bytes_skipped_non_output_levels),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_skipped_output_level",
-         {offsetof(struct InternalStats::CompactionStats,
-                   bytes_skipped_output_level),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_read_blob",
-         {offsetof(struct InternalStats::CompactionStats, bytes_read_blob),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_written",
-         {offsetof(struct InternalStats::CompactionStats, bytes_written),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_written_blob",
-         {offsetof(struct InternalStats::CompactionStats, bytes_written_blob),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"bytes_moved",
-         {offsetof(struct InternalStats::CompactionStats, bytes_moved),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_input_files_in_non_output_levels",
-         {offsetof(struct InternalStats::CompactionStats,
-                   num_input_files_in_non_output_levels),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_input_files_in_output_level",
-         {offsetof(struct InternalStats::CompactionStats,
-                   num_input_files_in_output_level),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_filtered_input_files_in_non_output_levels",
-         {offsetof(struct InternalStats::CompactionStats,
-                   num_filtered_input_files_in_non_output_levels),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_filtered_input_files_in_output_level",
-         {offsetof(struct InternalStats::CompactionStats,
-                   num_filtered_input_files_in_output_level),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_output_files",
-         {offsetof(struct InternalStats::CompactionStats, num_output_files),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_output_files_blob",
-         {offsetof(struct InternalStats::CompactionStats,
-                   num_output_files_blob),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_input_records",
-         {offsetof(struct InternalStats::CompactionStats, num_input_records),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_dropped_records",
-         {offsetof(struct InternalStats::CompactionStats, num_dropped_records),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"num_output_records",
-         {offsetof(struct InternalStats::CompactionStats, num_output_records),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"count",
-         {offsetof(struct InternalStats::CompactionStats, count),
-          OptionType::kUInt64T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"counts", OptionTypeInfo::Array<
-                       int, static_cast<int>(CompactionReason::kNumOfReasons)>(
-                       offsetof(struct InternalStats::CompactionStats, counts),
-                       OptionVerificationType::kNormal, OptionTypeFlags::kNone,
-                       {0, OptionType::kInt})},
-};
-
-static std::unordered_map<std::string, OptionTypeInfo>
-    compaction_internal_stats_type_info = {
-        {"output_level_stats",
-         OptionTypeInfo::Struct(
-             "output_level_stats", &compaction_stats_type_info,
-             offsetof(struct InternalStats::CompactionStatsFull,
-                      output_level_stats),
-             OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
-        {"has_proximal_level_output",
-         {offsetof(struct InternalStats::CompactionStatsFull,
-                   has_proximal_level_output),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kNone}},
-        {"proximal_level_stats",
-         OptionTypeInfo::Struct(
-             "proximal_level_stats", &compaction_stats_type_info,
-             offsetof(struct InternalStats::CompactionStatsFull,
-                      proximal_level_stats),
-             OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
-};
-
 namespace {
 // this is a helper struct to serialize and deserialize class Status, because
 // Status's members are not public.
@@ -968,11 +803,6 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_result_type_info = {
                  "stats", &compaction_job_stats_type_info,
                  offsetof(struct CompactionServiceResult, stats),
                  OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
-    {"internal_stats",
-     OptionTypeInfo::Struct(
-         "internal_stats", &compaction_internal_stats_type_info,
-         offsetof(struct CompactionServiceResult, internal_stats),
-         OptionVerificationType::kNormal, OptionTypeFlags::kNone)},
 };

 Status CompactionServiceInput::Read(const std::string& data_str,
@@ -7,7 +7,6 @@
 #include "port/stack_trace.h"
 #include "rocksdb/utilities/options_util.h"
 #include "table/unique_id_impl.h"
-#include "utilities/merge_operators/string_append/stringappend.h"

 namespace ROCKSDB_NAMESPACE {

@@ -22,10 +21,10 @@ class MyTestCompactionService : public CompactionService {
      : db_path_(std::move(db_path)),
        options_(options),
        statistics_(statistics),
-        start_info_("na", "na", "na", 0, "na", 0, Env::TOTAL,
-                    CompactionReason::kUnknown, false, false, false, -1, -1),
-        wait_info_("na", "na", "na", 0, "na", 0, Env::TOTAL,
-                   CompactionReason::kUnknown, false, false, false, -1, -1),
+        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),
        listeners_(listeners),
        table_properties_collector_factories_(
            std::move(table_properties_collector_factories)) {}
@@ -85,7 +84,6 @@ class MyTestCompactionService : public CompactionService {
    options_override.table_factory = options_.table_factory;
    options_override.sst_partitioner_factory = options_.sst_partitioner_factory;
    options_override.statistics = statistics_;
-    options_override.info_log = options_.info_log;
    if (!listeners_.empty()) {
      options_override.listeners = listeners_;
    }
@@ -279,17 +277,8 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
  Statistics* primary_statistics = GetPrimaryStatistics();
  Statistics* compactor_statistics = GetCompactorStatistics();

-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTable::PrefetchTail::TaiSizeNotRecorded",
-      [&](void* /* arg */) {
-        // Trigger assertion to verify precise tail prefetch size calculation
-        assert(false);
-      });
-
-  SyncPoint::GetInstance()->EnableProcessing();
  GenerateTestData();
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  SyncPoint::GetInstance()->DisableProcessing();
  VerifyTestData();

  auto my_cs = GetCompactionService();
@@ -368,12 +357,11 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
  } else {
    ASSERT_OK(result.status);
  }
-  ASSERT_GE(result.internal_stats.output_level_stats.micros, 1);
-  ASSERT_GE(result.internal_stats.output_level_stats.cpu_micros, 1);
+  ASSERT_GE(result.stats.elapsed_micros, 1);
+  ASSERT_GE(result.stats.cpu_micros, 1);

-  ASSERT_EQ(20, result.internal_stats.output_level_stats.num_output_records);
-  ASSERT_EQ(result.output_files.size(),
-            result.internal_stats.output_level_stats.num_output_files);
+  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) {
@@ -384,14 +372,13 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
    ASSERT_GT(file_size, 0);
    total_size += file_size;
  }
-  ASSERT_EQ(total_size, result.internal_stats.TotalBytesWritten());
+  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();
-  SyncPoint::GetInstance()->DisableProcessing();
 }

 TEST_F(CompactionServiceTest, ManualCompaction) {
@@ -435,121 +422,6 @@ TEST_F(CompactionServiceTest, ManualCompaction) {
  ASSERT_OK(result.status);
  ASSERT_TRUE(result.stats.is_manual_compaction);
  ASSERT_TRUE(result.stats.is_remote_compaction);
-
-  auto info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(0, info.cf_id);
-  ASSERT_EQ(kDefaultColumnFamilyName, info.cf_name);
-
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(0, info.cf_id);
-  ASSERT_EQ(kDefaultColumnFamilyName, info.cf_name);
-
-  // Test non-default CF
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr));
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(handles_[1]->GetID(), info.cf_id);
-  ASSERT_EQ(handles_[1]->GetName(), info.cf_name);
-
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(handles_[1]->GetID(), info.cf_id);
-  ASSERT_EQ(handles_[1]->GetName(), info.cf_name);
-}
-
-TEST_F(CompactionServiceTest, StandaloneDeleteRangeTombstoneOptimization) {
-  Options options = CurrentOptions();
-  options.compaction_style = CompactionStyle::kCompactionStyleUniversal;
-  ReopenWithCompactionService(&options);
-
-  size_t num_files_after_filtered = 0;
-  SyncPoint::GetInstance()->SetCallBack(
-      "VersionSet::MakeInputIterator:NewCompactionMergingIterator",
-      [&](void* arg) {
-        num_files_after_filtered = *static_cast<size_t*>(arg);
-      });
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::vector<std::string> files;
-  {
-    // Writes first version of data in range partitioned files.
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file1 = dbname_ + "file1.sst";
-    ASSERT_OK(sst_file_writer.Open(file1));
-    ASSERT_OK(sst_file_writer.Put("a", "a1"));
-    ASSERT_OK(sst_file_writer.Put("b", "b1"));
-    ExternalSstFileInfo file1_info;
-    ASSERT_OK(sst_file_writer.Finish(&file1_info));
-    files.push_back(std::move(file1));
-
-    std::string file2 = dbname_ + "file2.sst";
-    ASSERT_OK(sst_file_writer.Open(file2));
-    ASSERT_OK(sst_file_writer.Put("x", "x1"));
-    ASSERT_OK(sst_file_writer.Put("y", "y1"));
-    ExternalSstFileInfo file2_info;
-    ASSERT_OK(sst_file_writer.Finish(&file2_info));
-    files.push_back(std::move(file2));
-  }
-
-  IngestExternalFileOptions ifo;
-  ASSERT_OK(db_->IngestExternalFile(files, ifo));
-  ASSERT_EQ(Get("a"), "a1");
-  ASSERT_EQ(Get("b"), "b1");
-  ASSERT_EQ(Get("x"), "x1");
-  ASSERT_EQ(Get("y"), "y1");
-  ASSERT_EQ(2, NumTableFilesAtLevel(6));
-
-  auto my_cs = GetCompactionService();
-  uint64_t comp_num = my_cs->GetCompactionNum();
-
-  {
-    // Atomically delete old version of data with one range delete file.
-    // And a new batch of range partitioned files with new version of data.
-    files.clear();
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file2 = dbname_ + "file2.sst";
-    ASSERT_OK(sst_file_writer.Open(file2));
-    ASSERT_OK(sst_file_writer.DeleteRange("a", "z"));
-    ExternalSstFileInfo file2_info;
-    ASSERT_OK(sst_file_writer.Finish(&file2_info));
-    files.push_back(std::move(file2));
-
-    std::string file3 = dbname_ + "file3.sst";
-    ASSERT_OK(sst_file_writer.Open(file3));
-    ASSERT_OK(sst_file_writer.Put("a", "a2"));
-    ASSERT_OK(sst_file_writer.Put("b", "b2"));
-    ExternalSstFileInfo file3_info;
-    ASSERT_OK(sst_file_writer.Finish(&file3_info));
-    files.push_back(std::move(file3));
-
-    std::string file4 = dbname_ + "file4.sst";
-    ASSERT_OK(sst_file_writer.Open(file4));
-    ASSERT_OK(sst_file_writer.Put("x", "x2"));
-    ASSERT_OK(sst_file_writer.Put("y", "y2"));
-    ExternalSstFileInfo file4_info;
-    ASSERT_OK(sst_file_writer.Finish(&file4_info));
-    files.push_back(std::move(file4));
-  }
-
-  ASSERT_OK(db_->IngestExternalFile(files, ifo));
-  ASSERT_OK(db_->WaitForCompact(WaitForCompactOptions()));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  CompactionServiceResult result;
-  my_cs->GetResult(&result);
-  ASSERT_OK(result.status);
-  ASSERT_TRUE(result.stats.is_manual_compaction);
-  ASSERT_TRUE(result.stats.is_remote_compaction);
-
-  ASSERT_EQ(num_files_after_filtered, 1);
-
-  Close();
-  SyncPoint::GetInstance()->DisableProcessing();
 }

 TEST_F(CompactionServiceTest, CompactionOutputFileIOError) {
@@ -844,119 +716,6 @@ TEST_F(CompactionServiceTest, VerifyStatsLocalFallback) {
  VerifyTestData();
 }

-TEST_F(CompactionServiceTest, VerifyInputRecordCount) {
-  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();
-
-  // Only iterator through 10 keys and force compaction to finish.
-  int num_iter = 0;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::stop", [&](void* stop_ptr) {
-        num_iter++;
-        if (num_iter == 10) {
-          *(bool*)stop_ptr = true;
-        }
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // CompactRange() should fail
-  Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
-  ASSERT_NOK(s);
-  ASSERT_TRUE(s.IsCorruption());
-  const char* expected_message =
-      "Compaction number of input keys does not match number of keys "
-      "processed.";
-  ASSERT_TRUE(std::strstr(s.getState(), expected_message));
-
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-TEST_F(CompactionServiceTest, EmptyResult) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-
-  auto my_cs = GetCompactionService();
-
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-
-  // Delete range to cover entire range
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), "key", "keyz"));
-  ASSERT_OK(Flush());
-
-  // In this unit test, both remote compaction and primary db instance are
-  // running in the same process, so NewFileNumber will never have a collision.
-  // In the real-world remote compactions, when the compaction is indeed running
-  // in another process, this is not going to be the case.
-  // To simulate the SST file with the same name created in the tmp directory,
-  // override the file number in remote compaction to re-use old SST file
-  // number.
-  bool need_to_override_file_number = false;
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImplSecondary::OpenAndCompact::BeforeLoadingOptions:0",
-      [&](void*) { need_to_override_file_number = true; });
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::OpenCompactionOutputFile::NewFileNumber",
-      [&](void* file_number) {
-        if (need_to_override_file_number) {
-          auto n = static_cast<uint64_t*>(file_number);
-          ColumnFamilyMetaData cf_meta;
-          db_->GetColumnFamilyMetaData(&cf_meta);
-          for (const auto& level : cf_meta.levels) {
-            for (const auto& file : level.files) {
-              // Use one of the existing file name
-              *n = test::GetFileNumber(file.name);
-              need_to_override_file_number = false;
-              return;
-            }
-          }
-        }
-      });
-
-  // Inject failure, so that the remote compaction fails after
-  // ProcessKeyValueCompaction()
-  SyncPoint::GetInstance()->SetCallBack(
-      "DBImplSecondary::CompactWithoutInstallation::End", [&](void* status) {
-        // override job status
-        auto s = static_cast<Status*>(status);
-        *s = Status::Aborted("MyTestCompactionService failed to compact!");
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Compaction should fail and SST files in the primary db should exist
-  {
-    ASSERT_NOK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-    ColumnFamilyMetaData meta;
-    db_->GetColumnFamilyMetaData(&meta);
-    for (const auto& level : meta.levels) {
-      for (const auto& file : level.files) {
-        std::string fname = file.db_path + "/" + file.name;
-        ASSERT_OK(db_->GetEnv()->FileExists(fname));
-      }
-    }
-  }
-  Close();
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(CompactionServiceTest, CorruptedOutput) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
@@ -1090,12 +849,6 @@ TEST_F(CompactionServiceTest, TruncatedOutput) {
  Slice end(end_str);
  uint64_t comp_num = my_cs->GetCompactionNum();

-  // Skip calculating tail size to avoid crashing due to truncated file size
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "FileMetaData::CalculateTailSize", [&](void* arg) {
-        bool* skip = static_cast<bool*>(arg);
-        *skip = true;
-      });
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
      "CompactionServiceCompactionJob::Run:0", [&](void* arg) {
        CompactionServiceResult* compaction_result =
@@ -1112,7 +865,7 @@ TEST_F(CompactionServiceTest, TruncatedOutput) {
          ASSERT_OK(s);
          ASSERT_GT(file_size, 0);

-          ASSERT_OK(test::TruncateFile(env_, file_name, file_size / 4));
+          ASSERT_OK(test::TruncateFile(env_, file_name, file_size / 2));
        }
      });
  SyncPoint::GetInstance()->EnableProcessing();
@@ -1387,32 +1140,6 @@ TEST_F(CompactionServiceTest, CompactionFilter) {
  ASSERT_GE(my_cs->GetCompactionNum(), 1);
 }

-TEST_F(CompactionServiceTest, MergeOperator) {
-  Options options = CurrentOptions();
-  options.merge_operator.reset(new StringAppendOperator(','));
-  ReopenWithCompactionService(&options);
-  GenerateTestData();
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  for (int i = 0; i < 200; i++) {
-    ASSERT_OK(db_->Merge(WriteOptions(), Key(i),
-                         "merge_op_append_" + std::to_string(i)));
-  }
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  // verify result
-  for (int i = 0; i < 200; i++) {
-    auto result = Get(Key(i));
-    if (i % 2) {
-      ASSERT_EQ(result, "value" + std::to_string(i) + ",merge_op_append_" +
-                            std::to_string(i));
-    } else {
-      ASSERT_EQ(result, "value_new" + std::to_string(i) + ",merge_op_append_" +
-                            std::to_string(i));
-    }
-  }
-  auto my_cs = GetCompactionService();
-  ASSERT_GE(my_cs->GetCompactionNum(), 1);
-}
-
 TEST_F(CompactionServiceTest, Snapshot) {
  Options options = CurrentOptions();
  ReopenWithCompactionService(&options);
@@ -1461,52 +1188,34 @@ TEST_F(CompactionServiceTest, PrecludeLastLevel) {

  for (int i = 0; i < kNumTrigger; i++) {
    for (int j = 0; j < kNumKeys; j++) {
-      ASSERT_OK(Put(Key(j * kNumTrigger + i), "v" + std::to_string(i)));
+      // FIXME: need to assign outputs to levels to allow overlapping ranges:
+      // ASSERT_OK(Put(Key(j * kNumTrigger + i), "v" + std::to_string(i)));
+      // instead of this (too easy):
+      ASSERT_OK(Put(Key(i * kNumKeys + j), "v" + std::to_string(i)));
    }
    ASSERT_OK(Flush());
  }
  ASSERT_OK(dbfull()->TEST_WaitForCompact());

-  // Data split between proximal (kUnknown) and last (kCold) levels
-  ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
+  // Data split between penultimate (kUnknown) and last (kCold) levels
+  // FIXME: need to assign outputs to levels to get this:
+  // ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
+  // ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
+  // ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
+  // instead of this (WRONG but currently expected):
+  ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel());
+  // Check manifest temperatures
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
-
+  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
  // TODO: Check FileSystem temperatures with FileTemperatureTestFS

  for (int i = 0; i < kNumTrigger; i++) {
    for (int j = 0; j < kNumKeys; j++) {
-      ASSERT_EQ(Get(Key(j * kNumTrigger + i)), "v" + std::to_string(i));
+      // FIXME
+      // ASSERT_EQ(Get(Key(j * kNumTrigger + i)), "v" + std::to_string(i));
+      ASSERT_EQ(Get(Key(i * kNumKeys + j)), "v" + std::to_string(i));
    }
  }
-
-  // Verify Output Stats
-  auto my_cs = GetCompactionService();
-  {
-    CompactionServiceResult result;
-    my_cs->GetResult(&result);
-    ASSERT_OK(result.status);
-    ASSERT_GT(result.internal_stats.output_level_stats.cpu_micros, 0);
-    ASSERT_GT(result.internal_stats.output_level_stats.micros, 0);
-    ASSERT_EQ(result.internal_stats.output_level_stats.num_output_records +
-                  result.internal_stats.proximal_level_stats.num_output_records,
-              kNumTrigger * kNumKeys);
-    ASSERT_EQ(result.internal_stats.output_level_stats.num_output_files +
-                  result.internal_stats.proximal_level_stats.num_output_files,
-              2);
-
-    CompactionServiceJobInfo info = my_cs->GetCompactionInfoForStart();
-    ASSERT_EQ(0, info.base_input_level);
-    ASSERT_EQ(kNumLevels - 1, info.output_level);
-  }
-  SyncPoint::GetInstance()->DisableProcessing();
-  // Disable Preclude feature and run full compaction to the bottommost level
-  {
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-    CompactionServiceJobInfo info = my_cs->GetCompactionInfoForStart();
-    ASSERT_EQ(kNumLevels - 2, info.base_input_level);
-    ASSERT_EQ(kNumLevels - 1, info.output_level);
-  }
 }

 TEST_F(CompactionServiceTest, ConcurrentCompaction) {
@@ -1576,17 +1285,12 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
  ASSERT_EQ(true, info.is_manual_compaction);
  ASSERT_EQ(false, info.is_full_compaction);
  ASSERT_EQ(true, info.bottommost_level);
-  ASSERT_EQ(1, info.base_input_level);
-  ASSERT_EQ(2, info.output_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);
-  ASSERT_EQ(1, info.base_input_level);
-  ASSERT_EQ(2, info.output_level);
-  ASSERT_EQ(kDefaultColumnFamilyName, info.cf_name);

  // Test priority BOTTOM
  env_->SetBackgroundThreads(1, Env::BOTTOM);
@@ -1618,24 +1322,18 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
  ASSERT_EQ(false, info.is_full_compaction);
  ASSERT_EQ(true, info.bottommost_level);
  ASSERT_EQ(Env::BOTTOM, info.priority);
-  ASSERT_EQ(0, info.base_input_level);
-  ASSERT_EQ(db_->NumberLevels() - 1, info.output_level);
  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);
-  ASSERT_EQ(0, info.base_input_level);
-  ASSERT_EQ(db_->NumberLevels() - 1, info.output_level);

  // Test Non-Bottommost Level
  options.num_levels = 4;
  ReopenWithCompactionService(&options);
  my_cs =
      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-  int compaction_num = my_cs->GetCompactionNum();
-  ASSERT_EQ(0, compaction_num);

  for (int i = 0; i < options.level0_file_num_compaction_trigger; i++) {
    for (int j = 0; j < 10; j++) {
@@ -1644,22 +1342,16 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
    }
    ASSERT_OK(Flush());
  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());

-  // This is trivial move. Done locally.
-  ASSERT_EQ(0, my_cs->GetCompactionNum());
+  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);
-  ASSERT_EQ(-1, info.base_input_level);
-  ASSERT_EQ(-1, info.output_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);
-  ASSERT_EQ(-1, info.base_input_level);
-  ASSERT_EQ(-1, info.output_level);

  // Test Full Compaction + Bottommost Level
  options.num_levels = 6;
@@ -1674,10 +1366,7 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
    }
    ASSERT_OK(Flush());
  }
-  MoveFilesToLevel(options.num_levels - 1);

-  // Force final level compaction
-  // base_input_level == output_level == last_level
  CompactRangeOptions cro;
  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
@@ -1689,15 +1378,10 @@ TEST_F(CompactionServiceTest, CompactionInfo) {
  ASSERT_EQ(true, info.bottommost_level);
  ASSERT_EQ(CompactionReason::kManualCompaction, info.compaction_reason);
  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(options.num_levels - 1, info.base_input_level);
-  ASSERT_EQ(options.num_levels - 1, info.output_level);
  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);
-  ASSERT_EQ(options.num_levels - 1, info.base_input_level);
-  ASSERT_EQ(options.num_levels - 1, info.output_level);
-  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
 }

 TEST_F(CompactionServiceTest, FallbackLocalAuto) {
@@ -36,11 +36,11 @@ Slice CompactionState::LargestUserKey() {
 }

 void CompactionState::AggregateCompactionStats(
-    InternalStats::CompactionStatsFull& internal_stats,
-    CompactionJobStats& job_stats) {
+    InternalStats::CompactionStatsFull& compaction_stats,
+    CompactionJobStats& compaction_job_stats) {
  for (const auto& sc : sub_compact_states) {
-    sc.AggregateCompactionOutputStats(internal_stats);
-    job_stats.Add(sc.compaction_job_stats);
+    sc.AggregateCompactionOutputStats(compaction_stats);
+    compaction_job_stats.Add(sc.compaction_job_stats);
  }
 }
 }  // namespace ROCKSDB_NAMESPACE
@@ -29,8 +29,8 @@ class CompactionState {
  Status status;

  void AggregateCompactionStats(
-      InternalStats::CompactionStatsFull& internal_stats,
-      CompactionJobStats& job_stats);
+      InternalStats::CompactionStatsFull& compaction_stats,
+      CompactionJobStats& compaction_job_stats);

  explicit CompactionState(Compaction* c) : compaction(c) {}

@@ -14,32 +14,33 @@

 namespace ROCKSDB_NAMESPACE {
 void SubcompactionState::AggregateCompactionOutputStats(
-    InternalStats::CompactionStatsFull& internal_stats) const {
+    InternalStats::CompactionStatsFull& compaction_stats) const {
  // Outputs should be closed. By extension, any files created just for
  // range deletes have already been written also.
  assert(compaction_outputs_.HasBuilder() == false);
-  assert(proximal_level_outputs_.HasBuilder() == false);
+  assert(penultimate_level_outputs_.HasBuilder() == false);

  // FIXME: These stats currently include abandonned output files
  // assert(compaction_outputs_.stats_.num_output_files ==
  //        compaction_outputs_.outputs_.size());
-  // assert(proximal_level_outputs_.stats_.num_output_files ==
-  //        proximal_level_outputs_.outputs_.size());
+  // assert(penultimate_level_outputs_.stats_.num_output_files ==
+  //        penultimate_level_outputs_.outputs_.size());

-  internal_stats.output_level_stats.Add(compaction_outputs_.stats_);
-  if (proximal_level_outputs_.HasOutput()) {
-    internal_stats.has_proximal_level_output = true;
-    internal_stats.proximal_level_stats.Add(proximal_level_outputs_.stats_);
+  compaction_stats.stats.Add(compaction_outputs_.stats_);
+  if (penultimate_level_outputs_.HasOutput()) {
+    compaction_stats.has_penultimate_level_output = true;
+    compaction_stats.penultimate_level_stats.Add(
+        penultimate_level_outputs_.stats_);
  }
 }

 OutputIterator SubcompactionState::GetOutputs() const {
-  return OutputIterator(proximal_level_outputs_.outputs_,
+  return OutputIterator(penultimate_level_outputs_.outputs_,
                        compaction_outputs_.outputs_);
 }

 void SubcompactionState::Cleanup(Cache* cache) {
-  proximal_level_outputs_.Cleanup();
+  penultimate_level_outputs_.Cleanup();
  compaction_outputs_.Cleanup();

  if (!status.ok()) {
@@ -62,9 +63,9 @@ void SubcompactionState::Cleanup(Cache* cache) {
 }

 Slice SubcompactionState::SmallestUserKey() const {
-  if (proximal_level_outputs_.HasOutput()) {
+  if (penultimate_level_outputs_.HasOutput()) {
    Slice a = compaction_outputs_.SmallestUserKey();
-    Slice b = proximal_level_outputs_.SmallestUserKey();
+    Slice b = penultimate_level_outputs_.SmallestUserKey();
    if (a.empty()) {
      return b;
    }
@@ -84,9 +85,9 @@ Slice SubcompactionState::SmallestUserKey() const {
 }

 Slice SubcompactionState::LargestUserKey() const {
-  if (proximal_level_outputs_.HasOutput()) {
+  if (penultimate_level_outputs_.HasOutput()) {
    Slice a = compaction_outputs_.LargestUserKey();
-    Slice b = proximal_level_outputs_.LargestUserKey();
+    Slice b = penultimate_level_outputs_.LargestUserKey();
    if (a.empty()) {
      return b;
    }
@@ -106,12 +107,12 @@ Slice SubcompactionState::LargestUserKey() const {
 }

 Status SubcompactionState::AddToOutput(
-    const CompactionIterator& iter, bool use_proximal_output,
+    const CompactionIterator& iter, bool use_penultimate_output,
    const CompactionFileOpenFunc& open_file_func,
    const CompactionFileCloseFunc& close_file_func) {
  // update target output
-  current_outputs_ =
-      use_proximal_output ? &proximal_level_outputs_ : &compaction_outputs_;
+  current_outputs_ = use_penultimate_output ? &penultimate_level_outputs_
+                                            : &compaction_outputs_;
  return current_outputs_->AddToOutput(iter, open_file_func, close_file_func);
 }

@@ -26,13 +26,13 @@ namespace ROCKSDB_NAMESPACE {
 // Maintains state and outputs for each sub-compaction
 // It contains 2 `CompactionOutputs`:
 //  1. one for the normal output files
-//  2. another for the proximal level outputs
+//  2. another for the penultimate level outputs
 // a `current` pointer maintains the current output group, when calling
 // `AddToOutput()`, it checks the output of the current compaction_iterator key
 // and point `current` to the target output group. By default, it just points to
 // normal compaction_outputs, if the compaction_iterator key should be placed on
-// the proximal level, `current` is changed to point to
-// `proximal_level_outputs`.
+// the penultimate level, `current` is changed to point to
+// `penultimate_level_outputs`.
 // The later operations uses `Current()` to get the target group.
 //
 // +----------+          +-----------------------------+      +---------+
@@ -43,7 +43,7 @@ namespace ROCKSDB_NAMESPACE {
 //       |                                                    |  ...    |
 //       |
 //       |               +-----------------------------+      +---------+
-//       +-------------> | proximal_level_outputs      |----->| output  |
+//       +-------------> | penultimate_level_outputs   |----->| output  |
 //                       +-----------------------------+      +---------+
 //                                                            |  ...    |

@@ -78,7 +78,7 @@ class SubcompactionState {
  Slice LargestUserKey() const;

  // Get all outputs from the subcompaction. For per_key_placement compaction,
-  // it returns both the last level outputs and proximal level outputs.
+  // it returns both the last level outputs and penultimate level outputs.
  OutputIterator GetOutputs() const;

  // Assign range dels aggregator. The various tombstones will potentially
@@ -92,7 +92,7 @@ class SubcompactionState {

  void RemoveLastEmptyOutput() {
    compaction_outputs_.RemoveLastEmptyOutput();
-    proximal_level_outputs_.RemoveLastEmptyOutput();
+    penultimate_level_outputs_.RemoveLastEmptyOutput();
  }

  void BuildSubcompactionJobInfo(
@@ -106,11 +106,7 @@ class SubcompactionState {
    subcompaction_job_info.subcompaction_job_id = static_cast<int>(sub_job_id);
    subcompaction_job_info.base_input_level = c->start_level();
    subcompaction_job_info.output_level = c->output_level();
-    subcompaction_job_info.compaction_reason = c->compaction_reason();
-    subcompaction_job_info.compression = c->output_compression();
    subcompaction_job_info.stats = compaction_job_stats;
-    subcompaction_job_info.blob_compression_type =
-        c->mutable_cf_options().blob_compression_type;
  }

  SubcompactionState() = delete;
@@ -123,14 +119,14 @@ class SubcompactionState {
        start(_start),
        end(_end),
        sub_job_id(_sub_job_id),
-        compaction_outputs_(c, /*is_proximal_level=*/false),
-        proximal_level_outputs_(c, /*is_proximal_level=*/true) {
+        compaction_outputs_(c, /*is_penultimate_level=*/false),
+        penultimate_level_outputs_(c, /*is_penultimate_level=*/true) {
    assert(compaction != nullptr);
    // Set output split key (used for RoundRobin feature) only for normal
-    // compaction_outputs, output to proximal_level feature doesn't support
+    // compaction_outputs, output to penultimate_level feature doesn't support
    // RoundRobin feature (and may never going to be supported, because for
    // RoundRobin, the data time is mostly naturally sorted, no need to have
-    // per-key placement with output_to_proximal_level).
+    // per-key placement with output_to_penultimate_level).
    compaction_outputs_.SetOutputSlitKey(start, end);
  }

@@ -145,17 +141,18 @@ class SubcompactionState {
        compaction_job_stats(std::move(state.compaction_job_stats)),
        sub_job_id(state.sub_job_id),
        compaction_outputs_(std::move(state.compaction_outputs_)),
-        proximal_level_outputs_(std::move(state.proximal_level_outputs_)),
+        penultimate_level_outputs_(std::move(state.penultimate_level_outputs_)),
        range_del_agg_(std::move(state.range_del_agg_)) {
-    current_outputs_ = state.current_outputs_ == &state.proximal_level_outputs_
-                           ? &proximal_level_outputs_
-                           : &compaction_outputs_;
+    current_outputs_ =
+        state.current_outputs_ == &state.penultimate_level_outputs_
+            ? &penultimate_level_outputs_
+            : &compaction_outputs_;
  }

  // Add all the new files from this compaction to version_edit
  void AddOutputsEdit(VersionEdit* out_edit) const {
-    for (const auto& file : proximal_level_outputs_.outputs_) {
-      out_edit->AddFile(compaction->GetProximalLevel(), file.meta);
+    for (const auto& file : penultimate_level_outputs_.outputs_) {
+      out_edit->AddFile(compaction->GetPenultimateLevel(), file.meta);
    }
    for (const auto& file : compaction_outputs_.outputs_) {
      out_edit->AddFile(compaction->output_level(), file.meta);
@@ -165,32 +162,13 @@ class SubcompactionState {
  void Cleanup(Cache* cache);

  void AggregateCompactionOutputStats(
-      InternalStats::CompactionStatsFull& internal_stats) const;
+      InternalStats::CompactionStatsFull& compaction_stats) const;

  CompactionOutputs& Current() const {
    assert(current_outputs_);
    return *current_outputs_;
  }

-  CompactionOutputs* Outputs(bool is_proximal_level) {
-    assert(compaction);
-    if (is_proximal_level) {
-      assert(compaction->SupportsPerKeyPlacement());
-      return &proximal_level_outputs_;
-    }
-    return &compaction_outputs_;
-  }
-
-  // Per-level stats for the output
-  InternalStats::CompactionStats* OutputStats(bool is_proximal_level) {
-    assert(compaction);
-    if (is_proximal_level) {
-      assert(compaction->SupportsPerKeyPlacement());
-      return &proximal_level_outputs_.stats_;
-    }
-    return &compaction_outputs_.stats_;
-  }
-
  CompactionRangeDelAggregator* RangeDelAgg() const {
    return range_del_agg_.get();
  }
@@ -201,11 +179,12 @@ class SubcompactionState {
  }

  // Add compaction_iterator key/value to the `Current` output group.
-  Status AddToOutput(const CompactionIterator& iter, bool use_proximal_output,
+  Status AddToOutput(const CompactionIterator& iter,
+                     bool use_penultimate_output,
                     const CompactionFileOpenFunc& open_file_func,
                     const CompactionFileCloseFunc& close_file_func);

-  // Close all compaction output files, both output_to_proximal_level outputs
+  // Close all compaction output files, both output_to_penultimate_level outputs
  // and normal outputs.
  Status CloseCompactionFiles(const Status& curr_status,
                              const CompactionFileOpenFunc& open_file_func,
@@ -216,11 +195,11 @@ class SubcompactionState {
    // CloseOutput() may open new compaction output files.
    Status s = curr_status;
    if (per_key) {
-      s = proximal_level_outputs_.CloseOutput(s, range_del_agg_.get(),
-                                              open_file_func, close_file_func);
+      s = penultimate_level_outputs_.CloseOutput(
+          s, range_del_agg_.get(), open_file_func, close_file_func);
    } else {
-      assert(proximal_level_outputs_.HasBuilder() == false);
-      assert(proximal_level_outputs_.HasOutput() == false);
+      assert(penultimate_level_outputs_.HasBuilder() == false);
+      assert(penultimate_level_outputs_.HasOutput() == false);
    }
    s = compaction_outputs_.CloseOutput(s, range_del_agg_.get(), open_file_func,
                                        close_file_func);
@@ -230,7 +209,7 @@ class SubcompactionState {
 private:
  // State kept for output being generated
  CompactionOutputs compaction_outputs_;
-  CompactionOutputs proximal_level_outputs_;
+  CompactionOutputs penultimate_level_outputs_;
  CompactionOutputs* current_outputs_ = &compaction_outputs_;
  std::unique_ptr<CompactionRangeDelAggregator> range_del_agg_;
 };
@@ -33,12 +33,41 @@ ConfigOptions GetStrictConfigOptions() {
 class TieredCompactionTest : public DBTestBase {
 public:
  TieredCompactionTest()
-      : DBTestBase("tiered_compaction_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("tiered_compaction_test", /*env_do_fsync=*/true),
+        kBasicCompStats(CompactionReason::kUniversalSizeAmplification, 1),
+        kBasicPerKeyPlacementCompStats(
+            CompactionReason::kUniversalSizeAmplification, 1),
+        kBasicFlushStats(CompactionReason::kFlush, 1) {
+    kBasicCompStats.micros = kHasValue;
+    kBasicCompStats.cpu_micros = kHasValue;
+    kBasicCompStats.bytes_read_non_output_levels = kHasValue;
+    kBasicCompStats.num_input_files_in_non_output_levels = kHasValue;
+    kBasicCompStats.num_input_records = kHasValue;
+    kBasicCompStats.num_dropped_records = kHasValue;
+
+    kBasicPerLevelStats.num_output_records = kHasValue;
+    kBasicPerLevelStats.bytes_written = kHasValue;
+    kBasicPerLevelStats.num_output_files = kHasValue;
+
+    kBasicPerKeyPlacementCompStats.micros = kHasValue;
+    kBasicPerKeyPlacementCompStats.cpu_micros = kHasValue;
+    kBasicPerKeyPlacementCompStats.Add(kBasicPerLevelStats);
+
+    kBasicFlushStats.micros = kHasValue;
+    kBasicFlushStats.cpu_micros = kHasValue;
+    kBasicFlushStats.bytes_written = kHasValue;
+    kBasicFlushStats.num_output_files = kHasValue;
+  }

 protected:
-  std::atomic_bool enable_per_key_placement = true;
+  static constexpr uint8_t kHasValue = 1;

-  CompactionJobStats job_stats;
+  InternalStats::CompactionStats kBasicCompStats;
+  InternalStats::CompactionStats kBasicPerKeyPlacementCompStats;
+  InternalStats::CompactionOutputsStats kBasicPerLevelStats;
+  InternalStats::CompactionStats kBasicFlushStats;
+
+  std::atomic_bool enable_per_key_placement = true;

  void SetUp() override {
    SyncPoint::GetInstance()->SetCallBack(
@@ -79,36 +108,21 @@ class TieredCompactionTest : public DBTestBase {

  // Verify the compaction stats, the stats are roughly compared
  void VerifyCompactionStats(
-      const std::vector<InternalStats::CompactionStats>& expected_stats,
-      const InternalStats::CompactionStats& expected_pl_stats,
-      size_t output_level, uint64_t num_input_range_del = 0) {
+      const std::vector<InternalStats::CompactionStats>& expect_stats,
+      const InternalStats::CompactionStats& expect_pl_stats) {
    const std::vector<InternalStats::CompactionStats>& stats =
        GetCompactionStats();
-    const size_t kLevels = expected_stats.size();
+    const size_t kLevels = expect_stats.size();
    ASSERT_EQ(kLevels, stats.size());
-    ASSERT_TRUE(output_level < kLevels);

-    for (size_t level = 0; level < kLevels; level++) {
-      VerifyCompactionStats(stats[level], expected_stats[level]);
+    for (auto it = stats.begin(), expect = expect_stats.begin();
+         it != stats.end(); it++, expect++) {
+      VerifyCompactionStats(*it, *expect);
    }

    const InternalStats::CompactionStats& pl_stats =
        GetPerKeyPlacementCompactionStats();
-    VerifyCompactionStats(pl_stats, expected_pl_stats);
-
-    const auto& output_level_stats = stats[output_level];
-    CompactionJobStats expected_job_stats;
-    expected_job_stats.cpu_micros = output_level_stats.cpu_micros;
-    expected_job_stats.num_input_files =
-        output_level_stats.num_input_files_in_output_level +
-        output_level_stats.num_input_files_in_non_output_levels;
-    expected_job_stats.num_input_records =
-        output_level_stats.num_input_records - num_input_range_del;
-    expected_job_stats.num_output_files =
-        output_level_stats.num_output_files + pl_stats.num_output_files;
-    expected_job_stats.num_output_records =
-        output_level_stats.num_output_records + pl_stats.num_output_records;
-    VerifyCompactionJobStats(job_stats, expected_job_stats);
+    VerifyCompactionStats(pl_stats, expect_pl_stats);
  }

  void ResetAllStats(std::vector<InternalStats::CompactionStats>& stats,
@@ -125,52 +139,42 @@ class TieredCompactionTest : public DBTestBase {
  }

 private:
+  void CompareStats(uint64_t val, uint64_t expect) {
+    if (expect > 0) {
+      ASSERT_TRUE(val > 0);
+    } else {
+      ASSERT_EQ(val, 0);
+    }
+  }
+
  void VerifyCompactionStats(
      const InternalStats::CompactionStats& stats,
      const InternalStats::CompactionStats& expect_stats) {
-    ASSERT_EQ(stats.micros > 0, expect_stats.micros > 0);
-    ASSERT_EQ(stats.cpu_micros > 0, expect_stats.cpu_micros > 0);
-
-    // Hard to get consistent byte sizes of SST files.
-    // Use ASSERT_NEAR for comparison
-    ASSERT_NEAR(stats.bytes_read_non_output_levels * 1.0f,
-                expect_stats.bytes_read_non_output_levels * 1.0f,
-                stats.bytes_read_non_output_levels * 0.5f);
-    ASSERT_NEAR(stats.bytes_read_output_level * 1.0f,
-                expect_stats.bytes_read_output_level * 1.0f,
-                stats.bytes_read_output_level * 0.5f);
-    ASSERT_NEAR(stats.bytes_read_blob * 1.0f,
-                expect_stats.bytes_read_blob * 1.0f,
-                stats.bytes_read_blob * 0.5f);
-    ASSERT_NEAR(stats.bytes_written * 1.0f, expect_stats.bytes_written * 1.0f,
-                stats.bytes_written * 0.5f);
-
-    ASSERT_EQ(stats.bytes_moved, expect_stats.bytes_moved);
-    ASSERT_EQ(stats.num_input_files_in_non_output_levels,
-              expect_stats.num_input_files_in_non_output_levels);
-    ASSERT_EQ(stats.num_input_files_in_output_level,
-              expect_stats.num_input_files_in_output_level);
-    ASSERT_EQ(stats.num_output_files, expect_stats.num_output_files);
-    ASSERT_EQ(stats.num_output_files_blob, expect_stats.num_output_files_blob);
-    ASSERT_EQ(stats.num_input_records, expect_stats.num_input_records);
-    ASSERT_EQ(stats.num_dropped_records, expect_stats.num_dropped_records);
-    ASSERT_EQ(stats.num_output_records, expect_stats.num_output_records);
-
+    CompareStats(stats.micros, expect_stats.micros);
+    CompareStats(stats.cpu_micros, expect_stats.cpu_micros);
+    CompareStats(stats.bytes_read_non_output_levels,
+                 expect_stats.bytes_read_non_output_levels);
+    CompareStats(stats.bytes_read_output_level,
+                 expect_stats.bytes_read_output_level);
+    CompareStats(stats.bytes_read_blob, expect_stats.bytes_read_blob);
+    CompareStats(stats.bytes_written, expect_stats.bytes_written);
+    CompareStats(stats.bytes_moved, expect_stats.bytes_moved);
+    CompareStats(stats.num_input_files_in_non_output_levels,
+                 expect_stats.num_input_files_in_non_output_levels);
+    CompareStats(stats.num_input_files_in_output_level,
+                 expect_stats.num_input_files_in_output_level);
+    CompareStats(stats.num_output_files, expect_stats.num_output_files);
+    CompareStats(stats.num_output_files_blob,
+                 expect_stats.num_output_files_blob);
+    CompareStats(stats.num_input_records, expect_stats.num_input_records);
+    CompareStats(stats.num_dropped_records, expect_stats.num_dropped_records);
+    CompareStats(stats.num_output_records, expect_stats.num_output_records);
    ASSERT_EQ(stats.count, expect_stats.count);
    for (int i = 0; i < static_cast<int>(CompactionReason::kNumOfReasons);
         i++) {
      ASSERT_EQ(stats.counts[i], expect_stats.counts[i]);
    }
  }
-
-  void VerifyCompactionJobStats(const CompactionJobStats& stats,
-                                const CompactionJobStats& expected_stats) {
-    ASSERT_EQ(stats.cpu_micros, expected_stats.cpu_micros);
-    ASSERT_EQ(stats.num_input_files, expected_stats.num_input_files);
-    ASSERT_EQ(stats.num_input_records, expected_stats.num_input_records);
-    ASSERT_EQ(job_stats.num_output_files, expected_stats.num_output_files);
-    ASSERT_EQ(job_stats.num_output_records, expected_stats.num_output_records);
-  }
 };

 TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
@@ -195,39 +199,19 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
      [&](void* arg) {
        *static_cast<SequenceNumber*>(arg) = latest_cold_seq.load();
      });
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Install:AfterUpdateCompactionJobStats", [&](void* arg) {
-        job_stats.Reset();
-        job_stats.Add(*(static_cast<CompactionJobStats*>(arg)));
-      });
  SyncPoint::GetInstance()->EnableProcessing();

  std::vector<InternalStats::CompactionStats> expect_stats(kNumLevels);
+  InternalStats::CompactionStats& last_stats = expect_stats[kLastLevel];
  InternalStats::CompactionStats expect_pl_stats;

-  // Put keys in the following way to create overlaps
-  // First file from 0 ~ 99
-  // Second file from 10 ~ 109
-  // ...
-  size_t bytes_per_file = 1952;
-  uint64_t total_input_key_count = kNumTrigger * kNumKeys;
-  uint64_t total_output_key_count = 130;  // 0 ~ 129
-
  for (int i = 0; i < kNumTrigger; i++) {
    for (int j = 0; j < kNumKeys; j++) {
      ASSERT_OK(Put(Key(i * 10 + j), "value" + std::to_string(i)));
    }
    ASSERT_OK(Flush());
-
    seq_history.emplace_back(dbfull()->GetLatestSequenceNumber());
-    InternalStats::CompactionStats flush_stats(CompactionReason::kFlush, 1);
-    flush_stats.cpu_micros = 1;
-    flush_stats.micros = 1;
-    flush_stats.bytes_written = bytes_per_file;
-    flush_stats.num_output_files = 1;
-    flush_stats.num_input_records = kNumKeys;
-    flush_stats.num_output_records = kNumKeys;
-    expect_stats[0].Add(flush_stats);
+    expect_stats[0].Add(kBasicFlushStats);
  }
  ASSERT_OK(dbfull()->TEST_WaitForCompact());

@@ -237,97 +221,32 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);

-  uint64_t bytes_written_penultimate_level =
-      GetPerKeyPlacementCompactionStats().bytes_written;
+  // basic compaction stats are still counted to the last level
+  expect_stats[kLastLevel].Add(kBasicCompStats);
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);

-  // TODO - Use designated initializer when c++20 support is required
-  {
-    InternalStats::CompactionStats last_level_compaction_stats(
-        CompactionReason::kUniversalSizeAmplification, 1);
-    last_level_compaction_stats.cpu_micros = 1;
-    last_level_compaction_stats.micros = 1;
-    last_level_compaction_stats.bytes_written = 0;
-    last_level_compaction_stats.bytes_read_non_output_levels =
-        bytes_per_file * kNumTrigger;
-    last_level_compaction_stats.num_input_files_in_non_output_levels =
-        kNumTrigger;
-    last_level_compaction_stats.num_input_records = total_input_key_count;
-    last_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    last_level_compaction_stats.num_output_records = 0;
-    last_level_compaction_stats.num_output_files = 0;
-    expect_stats[kLastLevel].Add(last_level_compaction_stats);
-  }
-  {
-    InternalStats::CompactionStats penultimate_level_compaction_stats(
-        CompactionReason::kUniversalSizeAmplification, 1);
-    penultimate_level_compaction_stats.cpu_micros = 1;
-    penultimate_level_compaction_stats.micros = 1;
-    penultimate_level_compaction_stats.bytes_written =
-        bytes_written_penultimate_level;
-    penultimate_level_compaction_stats.num_output_files = 1;
-    penultimate_level_compaction_stats.num_output_records =
-        total_output_key_count;
-    expect_pl_stats.Add(penultimate_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, kLastLevel);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  ResetAllStats(expect_stats, expect_pl_stats);

  // move forward the cold_seq to split the file into 2 levels, so should have
-  // both the last level stats and the penultimate level stats
+  // both the last level stats and the output_to_penultimate_level stats
  latest_cold_seq = seq_history[0];
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());

  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);

-  // Now update the input count to be the total count from the previous
-  total_input_key_count = total_output_key_count;
-  uint64_t moved_to_last_level_key_count = 10;
+  last_stats.Add(kBasicCompStats);
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  last_stats.Add(kBasicPerLevelStats);
+  last_stats.num_dropped_records = 0;
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);
+  expect_pl_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

-  // bytes read in non output = bytes written in penultimate level from previous
-  uint64_t bytes_read_in_non_output_level = bytes_written_penultimate_level;
-  uint64_t bytes_written_output_level =
-      GetCompactionStats()[kLastLevel].bytes_written;
-
-  // Now get the new bytes written in penultimate level
-  bytes_written_penultimate_level =
-      GetPerKeyPlacementCompactionStats().bytes_written;
-  {
-    InternalStats::CompactionStats last_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    last_level_compaction_stats.cpu_micros = 1;
-    last_level_compaction_stats.micros = 1;
-    last_level_compaction_stats.bytes_written = bytes_written_output_level;
-    last_level_compaction_stats.bytes_read_non_output_levels =
-        bytes_read_in_non_output_level;
-    last_level_compaction_stats.num_input_files_in_non_output_levels = 1;
-    last_level_compaction_stats.num_input_records = total_input_key_count;
-    last_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    last_level_compaction_stats.num_output_records =
-        moved_to_last_level_key_count;
-    last_level_compaction_stats.num_output_files = 1;
-    expect_stats[kLastLevel].Add(last_level_compaction_stats);
-  }
-  {
-    InternalStats::CompactionStats penultimate_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    penultimate_level_compaction_stats.cpu_micros = 1;
-    penultimate_level_compaction_stats.micros = 1;
-    penultimate_level_compaction_stats.bytes_written =
-        bytes_written_penultimate_level;
-    penultimate_level_compaction_stats.num_output_files = 1;
-    penultimate_level_compaction_stats.num_output_records =
-        total_output_key_count - moved_to_last_level_key_count;
-    expect_pl_stats.Add(penultimate_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, kLastLevel);
-
-  // delete all cold data, so all data will be on proximal level
+  // delete all cold data, so all data will be on penultimate level
  for (int i = 0; i < 10; i++) {
    ASSERT_OK(Delete(Key(i)));
  }
@@ -336,54 +255,17 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
  ResetAllStats(expect_stats, expect_pl_stats);

  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);

-  // 10 tombstones added
-  total_input_key_count = total_input_key_count + 10;
-  total_output_key_count = total_output_key_count - 10;
-
-  auto last_level_stats = GetCompactionStats()[kLastLevel];
-  bytes_written_penultimate_level =
-      GetPerKeyPlacementCompactionStats().bytes_written;
-
-  ASSERT_LT(bytes_written_penultimate_level,
-            last_level_stats.bytes_read_non_output_levels +
-                last_level_stats.bytes_read_output_level);
-  {
-    InternalStats::CompactionStats last_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    last_level_compaction_stats.cpu_micros = 1;
-    last_level_compaction_stats.micros = 1;
-    last_level_compaction_stats.bytes_written = 0;
-    last_level_compaction_stats.bytes_read_non_output_levels =
-        last_level_stats.bytes_read_non_output_levels;
-    last_level_compaction_stats.bytes_read_output_level =
-        last_level_stats.bytes_read_output_level;
-    last_level_compaction_stats.num_input_files_in_non_output_levels = 2;
-    last_level_compaction_stats.num_input_files_in_output_level = 1;
-    last_level_compaction_stats.num_input_records = total_input_key_count;
-    last_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    last_level_compaction_stats.num_output_records = 0;
-    last_level_compaction_stats.num_output_files = 0;
-    expect_stats[kLastLevel].Add(last_level_compaction_stats);
-  }
-  {
-    InternalStats::CompactionStats penultimate_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    penultimate_level_compaction_stats.cpu_micros = 1;
-    penultimate_level_compaction_stats.micros = 1;
-    penultimate_level_compaction_stats.bytes_written =
-        bytes_written_penultimate_level;
-    penultimate_level_compaction_stats.num_output_files = 1;
-    penultimate_level_compaction_stats.num_output_records =
-        total_output_key_count;
-    expect_pl_stats.Add(penultimate_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, kLastLevel);
+  last_stats.Add(kBasicCompStats);
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  last_stats.bytes_read_output_level = kHasValue;
+  last_stats.num_input_files_in_output_level = kHasValue;
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);
+  expect_pl_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  // move forward the cold_seq again with range delete, take a snapshot to keep
  // the range dels in both cold and hot SSTs
@@ -393,7 +275,6 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
  ASSERT_OK(
      db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end));
  ASSERT_OK(Flush());
-  uint64_t num_input_range_del = 1;

  ResetAllStats(expect_stats, expect_pl_stats);

@@ -402,49 +283,12 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);

-  // Previous output + one delete range
-  total_input_key_count = total_output_key_count + num_input_range_del;
-  moved_to_last_level_key_count = 20;
-
-  last_level_stats = GetCompactionStats()[kLastLevel];
-  bytes_written_penultimate_level =
-      GetPerKeyPlacementCompactionStats().bytes_written;
-  // Expected to write more in last level
-  ASSERT_GT(bytes_written_penultimate_level, last_level_stats.bytes_written);
-  {
-    InternalStats::CompactionStats last_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    last_level_compaction_stats.cpu_micros = 1;
-    last_level_compaction_stats.micros = 1;
-    last_level_compaction_stats.bytes_written = last_level_stats.bytes_written;
-    last_level_compaction_stats.bytes_read_non_output_levels =
-        last_level_stats.bytes_read_non_output_levels;
-    last_level_compaction_stats.bytes_read_output_level = 0;
-    last_level_compaction_stats.num_input_files_in_non_output_levels = 2;
-    last_level_compaction_stats.num_input_files_in_output_level = 0;
-    last_level_compaction_stats.num_input_records = total_input_key_count;
-    last_level_compaction_stats.num_dropped_records =
-        num_input_range_del;  // delete range tombstone
-    last_level_compaction_stats.num_output_records =
-        moved_to_last_level_key_count;
-    last_level_compaction_stats.num_output_files = 1;
-    expect_stats[kLastLevel].Add(last_level_compaction_stats);
-  }
-  {
-    InternalStats::CompactionStats penultimate_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    penultimate_level_compaction_stats.cpu_micros = 1;
-    penultimate_level_compaction_stats.micros = 1;
-    penultimate_level_compaction_stats.bytes_written =
-        bytes_written_penultimate_level;
-    penultimate_level_compaction_stats.num_output_files = 1;
-    penultimate_level_compaction_stats.num_output_records =
-        total_input_key_count - moved_to_last_level_key_count -
-        num_input_range_del;
-    expect_pl_stats.Add(penultimate_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, kLastLevel,
-                        num_input_range_del);
+  last_stats.Add(kBasicCompStats);
+  last_stats.Add(kBasicPerLevelStats);
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);
+  expect_pl_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  // verify data
  std::string value;
@@ -497,11 +341,11 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
 // This test was essentially for a hacked-up version on future functionality.
 // It can be resurrected if/when a form of range-based tiering is properly
 // implemented.
-// TODO - Add stats verification when adding this test back
 TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageUniversal) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kNumKeys = 100;
+  const int kLastLevel = kNumLevels - 1;

  auto options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
@@ -520,13 +364,14 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageUniversal) {
      "CompactionIterator::PrepareOutput.context", [&](void* arg) {
        auto context = static_cast<PerKeyPlacementContext*>(arg);
        MutexLock l(&mutex);
-        context->output_to_proximal_level =
+        context->output_to_penultimate_level =
            cmp->Compare(context->key, hot_start) >= 0 &&
            cmp->Compare(context->key, hot_end) < 0;
      });
  SyncPoint::GetInstance()->EnableProcessing();

  std::vector<InternalStats::CompactionStats> expect_stats(kNumLevels);
+  InternalStats::CompactionStats& last_stats = expect_stats[kLastLevel];
  InternalStats::CompactionStats expect_pl_stats;

  for (int i = 0; i < kNumTrigger; i++) {
@@ -534,15 +379,21 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageUniversal) {
      ASSERT_OK(Put(Key(j), "value" + std::to_string(j)));
    }
    ASSERT_OK(Flush());
+    expect_stats[0].Add(kBasicFlushStats);
  }
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);

+  last_stats.Add(kBasicCompStats);
+  last_stats.Add(kBasicPerLevelStats);
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);
+
  ResetAllStats(expect_stats, expect_pl_stats);

-  // change to all cold, no output_to_proximal_level output
+  // change to all cold, no output_to_penultimate_level output
  {
    MutexLock l(&mutex);
    hot_start = Key(100);
@@ -553,6 +404,14 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageUniversal) {
  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);

+  last_stats.Add(kBasicCompStats);
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  last_stats.Add(kBasicPerLevelStats);
+  last_stats.num_dropped_records = 0;
+  last_stats.bytes_read_output_level = kHasValue;
+  last_stats.num_input_files_in_output_level = kHasValue;
+  VerifyCompactionStats(expect_stats, expect_pl_stats);
+
  // change to all hot, universal compaction support moving data to up level if
  // it's within compaction level range.
  {
@@ -562,7 +421,7 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageUniversal) {
  }

  // No data is moved from cold tier to hot tier because no input files from L5
-  // or higher, it's not safe to move data to output_to_proximal_level level.
+  // or higher, it's not safe to move data to output_to_penultimate_level level.
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());

@@ -708,7 +567,7 @@ TEST_F(TieredCompactionTest, LevelColdRangeDelete) {

  // 20->30 will be marked as cold data, but it cannot be placed to cold tier
  // (bottommost) otherwise, it will be "deleted" by the range del in
-  // output_to_proximal_level level verify that these data will be able to
+  // output_to_penultimate_level level verify that these data will be able to
  // queried
  for (int i = 20; i < 30; i++) {
    ASSERT_OK(Put(Key(i), "value" + std::to_string(i)));
@@ -818,17 +677,17 @@ TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
  std::vector<std::vector<FileMetaData>> level_to_files;
  dbfull()->TEST_GetFilesMetaData(dbfull()->DefaultColumnFamily(),
                                  &level_to_files);
-  // range tombstone is in the proximal level
-  const int proximal_level = kNumLevels - 2;
-  ASSERT_EQ(level_to_files[proximal_level].size(), 1);
-  ASSERT_EQ(level_to_files[proximal_level][0].num_entries, 1);
-  ASSERT_EQ(level_to_files[proximal_level][0].num_deletions, 1);
-  ASSERT_EQ(level_to_files[proximal_level][0].temperature,
+  // range tombstone is in the penultimate level
+  const int penultimate_level = kNumLevels - 2;
+  ASSERT_EQ(level_to_files[penultimate_level].size(), 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].num_entries, 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].num_deletions, 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].temperature,
            Temperature::kUnknown);

  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
  ASSERT_EQ("0,1,10",
-            FilesPerLevel());  // one file is at the proximal level which
+            FilesPerLevel());  // one file is at the penultimate level which
                               // only contains a range delete

  // Add 2 hot keys, each is a new SST, they will be placed in the same level as
@@ -842,7 +701,7 @@ TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {

  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
  ASSERT_EQ("0,2,10",
-            FilesPerLevel());  // one file is at the proximal level
+            FilesPerLevel());  // one file is at the penultimate level
                               // which only contains a range delete
  std::vector<LiveFileMetaData> live_file_meta;
  db_->GetLiveFilesMetaData(&live_file_meta);
@@ -852,7 +711,7 @@ TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
    if (meta.num_deletions > 0) {
      // found SST with del, which has 2 entries, one for data one for range del
      ASSERT_EQ(meta.level,
-                kNumLevels - 2);  // output to proximal level
+                kNumLevels - 2);  // output to penultimate level
      ASSERT_EQ(meta.num_entries, 2);
      ASSERT_EQ(meta.num_deletions, 1);
      found_sst_with_del = true;
@@ -863,7 +722,7 @@ TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {

  // release the first snapshot and compact, which should compact the range del
  // but new inserted key `0` and `6` are still hot data which will be placed on
-  // the proximal level
+  // the penultimate level
  db_->ReleaseSnapshot(snap);
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
  ASSERT_EQ("0,2,7", FilesPerLevel());
@@ -879,7 +738,7 @@ TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
  ASSERT_FALSE(found_sst_with_del);

  // Now make all data cold, key 0 will be moved to the last level, but key 6 is
-  // still in snap2, so it will be kept at the proximal level
+  // still in snap2, so it will be kept at the penultimate level
  latest_cold_seq = dbfull()->GetLatestSequenceNumber();
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
  ASSERT_EQ("0,1,8", FilesPerLevel());
@@ -924,7 +783,7 @@ TEST_F(TieredCompactionTest, UniversalRangeDelete) {
  }
  ASSERT_OK(Flush());

-  // compact to the proximal level with 10 files
+  // compact to the penultimate level with 10 files
  CompactRangeOptions cro;
  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
@@ -951,7 +810,7 @@ TEST_F(TieredCompactionTest, UniversalRangeDelete) {

  ASSERT_EQ("0,0,0,0,0,0,8", FilesPerLevel());

-  // range del with snapshot should be preserved in the proximal level
+  // range del with snapshot should be preserved in the penultimate level
  auto snap = db_->GetSnapshot();

  start = Key(6);
@@ -982,7 +841,7 @@ TEST_F(TieredCompactionTest, UniversalRangeDelete) {
    if (meta.num_deletions > 0) {
      // found SST with del, which has 2 entries, one for data one for range del
      ASSERT_EQ(meta.level,
-                kNumLevels - 2);  // output_to_proximal_level level
+                kNumLevels - 2);  // output_to_penultimate_level level
      ASSERT_EQ(meta.num_entries, 2);
      ASSERT_EQ(meta.num_deletions, 1);
      found_sst_with_del = true;
@@ -1031,8 +890,6 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
  const int kNumKeys = 100;
  const int kLastLevel = kNumLevels - 1;

-  int output_level = 0;
-
  auto options = CurrentOptions();
  SetColdTemperature(options);
  options.level0_file_num_compaction_trigger = kNumTrigger;
@@ -1049,42 +906,18 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
      [&](void* arg) {
        *static_cast<SequenceNumber*>(arg) = latest_cold_seq.load();
      });
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::Install:AfterUpdateCompactionJobStats", [&](void* arg) {
-        job_stats.Reset();
-        job_stats.Add(*(static_cast<CompactionJobStats*>(arg)));
-      });
-  SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
-        auto compaction = static_cast<Compaction*>(arg);
-        output_level = compaction->output_level();
-      });
  SyncPoint::GetInstance()->EnableProcessing();

  std::vector<InternalStats::CompactionStats> expect_stats(kNumLevels);
+  InternalStats::CompactionStats& last_stats = expect_stats[kLastLevel];
  InternalStats::CompactionStats expect_pl_stats;

-  // Put keys in the following way to create overlaps
-  // First file from 0 ~ 99
-  // Second file from 10 ~ 109
-  // ...
-  size_t bytes_per_file = 1952;
-  uint64_t total_input_key_count = kNumTrigger * kNumKeys;
-  uint64_t total_output_key_count = 130;  // 0 ~ 129
-
  for (int i = 0; i < kNumTrigger; i++) {
    for (int j = 0; j < kNumKeys; j++) {
      ASSERT_OK(Put(Key(i * 10 + j), "value" + std::to_string(i)));
    }
    ASSERT_OK(Flush());
-    InternalStats::CompactionStats flush_stats(CompactionReason::kFlush, 1);
-    flush_stats.cpu_micros = 1;
-    flush_stats.micros = 1;
-    flush_stats.bytes_written = bytes_per_file;
-    flush_stats.num_output_files = 1;
-    flush_stats.num_input_records = kNumKeys;
-    flush_stats.num_output_records = kNumKeys;
-    expect_stats[0].Add(flush_stats);
+    expect_stats[0].Add(kBasicFlushStats);
  }
  ASSERT_OK(dbfull()->TEST_WaitForCompact());

@@ -1093,30 +926,10 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);

-  uint64_t bytes_written_output_level =
-      GetCompactionStats()[output_level].bytes_written;
-  ASSERT_GT(bytes_written_output_level, 0);
-
-  {
-    InternalStats::CompactionStats output_level_compaction_stats(
-        CompactionReason::kLevelL0FilesNum, 1);
-    output_level_compaction_stats.cpu_micros = 1;
-    output_level_compaction_stats.micros = 1;
-    output_level_compaction_stats.bytes_written = bytes_written_output_level;
-    output_level_compaction_stats.bytes_read_non_output_levels =
-        bytes_per_file * kNumTrigger;
-    output_level_compaction_stats.bytes_read_output_level = 0;
-    output_level_compaction_stats.num_input_files_in_non_output_levels =
-        kNumTrigger;
-    output_level_compaction_stats.num_input_files_in_output_level = 0;
-    output_level_compaction_stats.num_input_records = total_input_key_count;
-    output_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    output_level_compaction_stats.num_output_records = total_output_key_count;
-    output_level_compaction_stats.num_output_files = 1;
-    expect_stats[output_level].Add(output_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, output_level);
+  expect_stats[1].Add(kBasicCompStats);
+  expect_stats[1].Add(kBasicPerLevelStats);
+  expect_stats[1].ResetCompactionReason(CompactionReason::kLevelL0FilesNum);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  // move all data to the last level
  MoveFilesToLevel(kLastLevel);
@@ -1131,26 +944,15 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);

-  total_input_key_count = total_output_key_count;
-  {
-    InternalStats::CompactionStats output_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    output_level_compaction_stats.cpu_micros = 1;
-    output_level_compaction_stats.micros = 1;
-    output_level_compaction_stats.bytes_written = bytes_written_output_level;
-    output_level_compaction_stats.bytes_read_non_output_levels = 0;
-    output_level_compaction_stats.bytes_read_output_level =
-        bytes_written_output_level;
-    output_level_compaction_stats.num_input_files_in_non_output_levels = 0;
-    output_level_compaction_stats.num_input_files_in_output_level = 1;
-    output_level_compaction_stats.num_input_records = total_input_key_count;
-    output_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    output_level_compaction_stats.num_output_records = total_output_key_count;
-    output_level_compaction_stats.num_output_files = 1;
-    expect_stats[output_level].Add(output_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, output_level);
+  last_stats.Add(kBasicCompStats);
+  last_stats.Add(kBasicPerLevelStats);
+  last_stats.num_dropped_records = 0;
+  last_stats.bytes_read_non_output_levels = 0;
+  last_stats.num_input_files_in_non_output_levels = 0;
+  last_stats.bytes_read_output_level = kHasValue;
+  last_stats.num_input_files_in_output_level = kHasValue;
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  // Add new data, which is all hot and overriding all existing data
  latest_cold_seq = dbfull()->GetLatestSequenceNumber();
@@ -1174,47 +976,17 @@ TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);

-  uint64_t bytes_written_in_proximal_level =
-      GetPerKeyPlacementCompactionStats().bytes_written;
  for (int level = 2; level < kNumLevels - 1; level++) {
-    expect_stats[level].bytes_moved = bytes_written_in_proximal_level;
+    expect_stats[level].bytes_moved = kHasValue;
  }

-  // Another set of 130 keys + from the previous
-  total_input_key_count = total_output_key_count + 130;
-  // Merged into 130
-  total_output_key_count = 130;
-
-  {
-    InternalStats::CompactionStats output_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    output_level_compaction_stats.cpu_micros = 1;
-    output_level_compaction_stats.micros = 1;
-    output_level_compaction_stats.bytes_written = 0;
-    output_level_compaction_stats.bytes_read_non_output_levels =
-        bytes_written_in_proximal_level;
-    output_level_compaction_stats.bytes_read_output_level =
-        bytes_written_output_level;
-    output_level_compaction_stats.num_input_files_in_non_output_levels = 1;
-    output_level_compaction_stats.num_input_files_in_output_level = 1;
-    output_level_compaction_stats.num_input_records = total_input_key_count;
-    output_level_compaction_stats.num_dropped_records =
-        total_input_key_count - total_output_key_count;
-    output_level_compaction_stats.num_output_records = 0;
-    output_level_compaction_stats.num_output_files = 0;
-    expect_stats[output_level].Add(output_level_compaction_stats);
-  }
-  {
-    InternalStats::CompactionStats proximal_level_compaction_stats(
-        CompactionReason::kManualCompaction, 1);
-    expect_pl_stats.cpu_micros = 1;
-    expect_pl_stats.micros = 1;
-    expect_pl_stats.bytes_written = bytes_written_in_proximal_level;
-    expect_pl_stats.num_output_files = 1;
-    expect_pl_stats.num_output_records = total_output_key_count;
-    expect_pl_stats.Add(proximal_level_compaction_stats);
-  }
-  VerifyCompactionStats(expect_stats, expect_pl_stats, output_level);
+  last_stats.Add(kBasicCompStats);
+  last_stats.bytes_read_output_level = kHasValue;
+  last_stats.num_input_files_in_output_level = kHasValue;
+  last_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  expect_pl_stats.Add(kBasicPerKeyPlacementCompStats);
+  expect_pl_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  VerifyCompactionStats(expect_stats, expect_pl_stats);

  // move forward the cold_seq, try to split the data into cold and hot, but in
  // this case it's unsafe to split the data
@@ -1366,7 +1138,7 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageLevel) {
      "CompactionIterator::PrepareOutput.context", [&](void* arg) {
        auto context = static_cast<PerKeyPlacementContext*>(arg);
        MutexLock l(&mutex);
-        context->output_to_proximal_level =
+        context->output_to_penultimate_level =
            cmp->Compare(context->key, hot_start) >= 0 &&
            cmp->Compare(context->key, hot_end) < 0;
      });
@@ -1449,10 +1221,10 @@ TEST_F(TieredCompactionTest, DISABLED_RangeBasedTieredStorageLevel) {
      options.statistics->getTickerCount(COMPACTION_RANGE_DEL_DROP_OBSOLETE),
      1);

-  // Tests that we only compact keys up to proximal level
-  // that are within proximal level input's internal key range.
-  // UPDATE: this functionality has changed. With proximal-enabled
-  // compaction, the expanded potential output range in the proximal
+  // Tests that we only compact keys up to penultimate level
+  // that are within penultimate level input's internal key range.
+  // UPDATE: this functionality has changed. With penultimate-enabled
+  // compaction, the expanded potential output range in the penultimate
  // level is reserved so should be safe to use.
  {
    MutexLock l(&mutex);
@@ -1604,7 +1376,7 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));

-  // all data is moved up to the proximal level
+  // all data is moved up to the penultimate level
  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
@@ -1676,7 +1448,7 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
    ASSERT_OK(dbfull()->TEST_WaitForCompact());
  }

-  // all data is moved up to the proximal level
+  // all data is moved up to the penultimate level
  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
@@ -1717,7 +1489,8 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());

  std::vector<KeyVersion> key_versions;
-  ASSERT_OK(GetAllKeyVersions(db_, {}, {}, std::numeric_limits<size_t>::max(),
+  ASSERT_OK(GetAllKeyVersions(db_, Slice(), Slice(),
+                              std::numeric_limits<size_t>::max(),
                              &key_versions));

  // make sure there're more than 300 keys and first 100 keys are having seqno
@@ -1806,9 +1579,9 @@ TEST_P(PrecludeLastLevelTest, SmallPrecludeTime) {
 }

 TEST_P(PrecludeLastLevelTest, CheckInternalKeyRange) {
-  // When compacting keys from the last level to proximal level,
-  // output to proximal level should be within internal key range
-  // of input files from proximal level.
+  // When compacting keys from the last level to penultimate level,
+  // output to penultimate level should be within internal key range
+  // of input files from penultimate level.
  // Set up:
  // L5:
  //  File 1: DeleteRange[1, 3)@4, File 2: [3@5, 100@6]
@@ -1946,8 +1719,8 @@ TEST_P(PrecludeWithCompactStyleTest, RangeTombstoneSnapshotMigrateFromLast) {

  ApplyConfigChange(&options, {{"preclude_last_level_data_seconds", "10000"}});

-  // To exercise the WithinProximalLevelOutputRange feature, we want files
-  // around the middle file to be compacted on the proximal level
+  // To exercise the WithinPenultimateLevelOutputRange feature, we want files
+  // around the middle file to be compacted on the penultimate level
  ASSERT_OK(Put(Key(0), "val0"));
  ASSERT_OK(Flush());
  ASSERT_OK(Put(Key(3), "val3"));
@@ -2004,9 +1777,9 @@ TEST_P(PrecludeWithCompactStyleTest, RangeTombstoneSnapshotMigrateFromLast) {
  EXPECT_EQ("0,0,0,0,0,3,1", FilesPerLevel());
  VerifyLogicalState(__LINE__);

-  // Compact everything, but some data still goes to both proximal and last
+  // Compact everything, but some data still goes to both penultimate and last
  // levels. A full-range compaction should be safe to "migrate" data from the
-  // last level to proximal (because of preclude setting change).
+  // last level to penultimate (because of preclude setting change).
  ASSERT_OK(CompactRange({}, {}, {}));
  EXPECT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
  VerifyLogicalState(__LINE__);
@@ -2125,7 +1898,7 @@ TEST_P(TimedPutPrecludeLastLevelTest, InterleavedTimedPutAndPut) {
  Close();
 }

-TEST_P(TimedPutPrecludeLastLevelTest, PreserveTimedPutOnProximalLevel) {
+TEST_P(TimedPutPrecludeLastLevelTest, PreserveTimedPutOnPenultimateLevel) {
  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.disable_auto_compactions = true;
@@ -2151,14 +1924,14 @@ TEST_P(TimedPutPrecludeLastLevelTest, PreserveTimedPutOnProximalLevel) {
  ASSERT_OK(TimedPut(0, Key(2), "v2", kMockStartTime - 1 * 24 * 60 * 60, wo));
  ASSERT_OK(Flush());

-  // Should still be in proximal level.
+  // Should still be in penultimate level.
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
  ASSERT_GT(GetSstSizeHelper(Temperature::kHot), 0);
  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);

  // Wait one more day and release snapshot. Data's preferred seqno should be
-  // swapped in, but data should still stay in proximal level. SST file's
+  // swapped in, but data should still stay in penultimate level. SST file's
  // seqno to time mapping should continue to cover preferred seqno after
  // compaction.
  db_->ReleaseSnapshot(snap1);
@@ -2306,7 +2079,8 @@ TEST_P(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);

  std::vector<KeyVersion> key_versions;
-  ASSERT_OK(GetAllKeyVersions(db_, {}, {}, std::numeric_limits<size_t>::max(),
+  ASSERT_OK(GetAllKeyVersions(db_, Slice(), Slice(),
+                              std::numeric_limits<size_t>::max(),
                              &key_versions));

  // make sure there're more than 300 keys and first 100 keys are having seqno
@@ -2479,13 +2253,13 @@ TEST_P(PrecludeLastLevelOptionalTest, LastLevelOnlyCompactionNoPreclude) {
  Close();
 }

-TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToProximalLevel) {
+TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToPenultimateLevel) {
  // Test the last level only periodic compaction should also be blocked by an
-  // ongoing compaction in proximal level if tiered compaction is enabled
+  // ongoing compaction in penultimate level if tiered compaction is enabled
  // otherwise, the periodic compaction should just run for the last level.
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
-  const int kProximalLevel = kNumLevels - 2;
+  const int kPenultimateLevel = kNumLevels - 2;
  const int kKeyPerSec = 1;
  const int kNumKeys = 100;

@@ -2527,13 +2301,13 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToProximalLevel) {
  SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
        auto compaction = static_cast<Compaction*>(arg);
-        if (compaction->output_level() == kProximalLevel) {
+        if (compaction->output_level() == kPenultimateLevel) {
          is_size_ratio_compaction_running = true;
          TEST_SYNC_POINT(
-              "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+              "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
              "SizeRatioCompaction1");
          TEST_SYNC_POINT(
-              "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+              "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
              "SizeRatioCompaction2");
          is_size_ratio_compaction_running = false;
        }
@@ -2555,17 +2329,17 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToProximalLevel) {
          verified_last_level_compaction = true;
        }
        TEST_SYNC_POINT(
-            "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+            "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
            "AutoCompactionPicked");
      });

  SyncPoint::GetInstance()->LoadDependency({
-      {"PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+      {"PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
       "SizeRatioCompaction1",
-       "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:DoneWrite"},
-      {"PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+       "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:DoneWrite"},
+      {"PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
       "AutoCompactionPicked",
-       "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:"
+       "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
       "SizeRatioCompaction2"},
  });

@@ -2582,11 +2356,11 @@ TEST_P(PrecludeLastLevelOptionalTest, PeriodicCompactionToProximalLevel) {
  }

  TEST_SYNC_POINT(
-      "PrecludeLastLevelTest::PeriodicCompactionToProximalLevel:DoneWrite");
+      "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:DoneWrite");

  // wait for periodic compaction time and flush to trigger the periodic
  // compaction, which should be blocked by ongoing compaction in the
-  // proximal level
+  // penultimate level
  mock_clock_->MockSleepForSeconds(10000);
  for (int i = 0; i < 3 * kNumKeys; i++) {
    ASSERT_OK(Put(Key(i), rnd.RandomString(10)));
@@ -2649,7 +2423,7 @@ class ThreeRangesPartitionerFactory : public SstPartitionerFactory {
  }
 };

-TEST_P(PrecludeLastLevelTest, PartialProximalLevelCompaction) {
+TEST_P(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  const int kNumTrigger = 4;
  const int kNumLevels = 7;
  const int kKeyPerSec = 10;
@@ -2819,8 +2593,8 @@ TEST_P(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {
      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
        auto compaction = static_cast<Compaction*>(arg);
        if (compaction->SupportsPerKeyPlacement()) {
-          ASSERT_EQ(compaction->GetProximalOutputRangeType(),
-                    Compaction::ProximalOutputRangeType::kNonLastRange);
+          ASSERT_EQ(compaction->GetPenultimateOutputRangeType(),
+                    Compaction::PenultimateOutputRangeType::kNonLastRange);
          per_key_comp_num++;
        }
      });
@@ -2876,7 +2650,7 @@ TEST_P(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {
  ASSERT_EQ(3, per_key_comp_num);
  verify_db();

-  // Finish off the proximal level.
+  // Finish off the penultimate level.
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
  ASSERT_EQ("0,0,0,0,0,0,3", FilesPerLevel());
  verify_db();
@@ -26,17 +26,6 @@ Status DeleteFilesInRange(DB* db, ColumnFamilyHandle* column_family,

 Status DeleteFilesInRanges(DB* db, ColumnFamilyHandle* column_family,
                           const RangePtr* ranges, size_t n, bool include_end) {
-  std::vector<RangeOpt> range_opts(n);
-  for (size_t i = 0; i < n; ++i) {
-    range_opts[i] = {OptSlice::CopyFromPtr(ranges[i].start),
-                     OptSlice::CopyFromPtr(ranges[i].limit)};
-  }
-  return DeleteFilesInRanges(db, column_family, range_opts.data(), n,
-                             include_end);
-}
-
-Status DeleteFilesInRanges(DB* db, ColumnFamilyHandle* column_family,
-                           const RangeOpt* ranges, size_t n, bool include_end) {
  return (static_cast_with_check<DBImpl>(db->GetRootDB()))
      ->DeleteFilesInRanges(column_family, ranges, n, include_end);
 }
@@ -93,10 +82,9 @@ Status VerifySstFileChecksumInternal(const Options& options,
          nullptr /* file_read_hist */, ioptions.rate_limiter.get()));
  const bool kImmortal = true;
  auto reader_options = TableReaderOptions(
-      ioptions, options.prefix_extractor, options.compression_manager.get(),
-      env_options, internal_comparator, options.block_protection_bytes_per_key,
-      false /* skip_filters */, !kImmortal, false /* force_direct_prefetch */,
-      -1 /* level */);
+      ioptions, options.prefix_extractor, env_options, internal_comparator,
+      options.block_protection_bytes_per_key, false /* skip_filters */,
+      !kImmortal, false /* force_direct_prefetch */, -1 /* level */);
  reader_options.largest_seqno = largest_seqno;
  s = options.table_factory->NewTableReader(
      read_options, reader_options, std::move(file_reader), file_size,
@@ -556,74 +556,6 @@ TEST_F(CorruptionTest, TableFileFooterNotMagic) {
  ASSERT_TRUE(s.ToString().find(".sst") != std::string::npos);
 }

-TEST_F(CorruptionTest, DBOpenWithWrongFileSize) {
-  // Validate that when paranoid flag is true, DB::Open() fails if one of the
-  // file corrupted. Validate that when paranoid flag is false, DB::Open()
-  // succeed if one of the file corrupted, and the healthy file is readable.
-  CloseDb();
-
-  const std::string test_cf_name = "test_cf";
-  std::vector<ColumnFamilyDescriptor> cf_descs;
-  cf_descs.emplace_back(kDefaultColumnFamilyName, ColumnFamilyOptions());
-  cf_descs.emplace_back(test_cf_name, ColumnFamilyOptions());
-
-  {
-    options_.create_missing_column_families = true;
-    std::vector<ColumnFamilyHandle*> cfhs;
-    ASSERT_OK(DB::Open(options_, dbname_, cf_descs, &cfhs, &db_));
-    assert(db_ != nullptr);  // suppress false clang-analyze report
-
-    ASSERT_OK(db_->Put(WriteOptions(), cfhs[0], "k", "v"));
-    ASSERT_OK(db_->Put(WriteOptions(), cfhs[1], "k1", "v1"));
-    ASSERT_OK(db_->Put(WriteOptions(), cfhs[0], "k2", "v2"));
-    for (auto* cfh : cfhs) {
-      delete cfh;
-    }
-    DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-    ASSERT_OK(dbi->TEST_FlushMemTable());
-
-    // ********************************************
-    // Corrupt the file by making the file bigger
-    std::vector<LiveFileMetaData> metadata;
-    db_->GetLiveFilesMetaData(&metadata);
-    std::string filename = dbname_ + metadata[0].name;
-    const auto& fs = options_.env->GetFileSystem();
-    {
-      std::unique_ptr<FSWritableFile> f;
-      ASSERT_OK(fs->ReopenWritableFile(filename, FileOptions(), &f, nullptr));
-      ASSERT_OK(f->Append("blahblah", IOOptions(), nullptr));
-      ASSERT_OK(f->Close(IOOptions(), nullptr));
-    }
-    CloseDb();
-  }
-
-  // DB failed to open due to one of the file is corrupted, as paranoid flag is
-  // true
-  options_.paranoid_checks = true;
-  std::vector<ColumnFamilyHandle*> cfhs;
-  auto s = DB::Open(options_, dbname_, cf_descs, &cfhs, &db_);
-  ASSERT_TRUE(s.IsCorruption());
-  ASSERT_TRUE(s.ToString().find("file size mismatch") != std::string::npos);
-
-  // DB opened successfully, as paranoid flag is false, validate the one that is
-  // healthy is still accessible
-  options_.paranoid_checks = false;
-  ASSERT_OK(DB::Open(options_, dbname_, cf_descs, &cfhs, &db_));
-  assert(db_ != nullptr);  // suppress false clang-analyze report
-
-  std::string v;
-  ASSERT_OK(db_->Get(ReadOptions(), cfhs[1], "k1", &v));
-  ASSERT_EQ(v, "v1");
-
-  // Validate the default column family is corrupted
-  Check(0, 0);
-  s = db_->Get(ReadOptions(), cfhs[0], "k1", &v);
-  ASSERT_TRUE(s.IsCorruption());
-
-  delete cfhs[1];
-  delete cfhs[0];
-}
-
 TEST_F(CorruptionTest, TableFileWrongSize) {
  Build(100);
  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
@@ -647,16 +579,13 @@ TEST_F(CorruptionTest, TableFileWrongSize) {
  // DB actually accepts this without paranoid checks, relying on size
  // recorded in manifest to locate the SST footer.
  options_.paranoid_checks = false;
+  options_.skip_checking_sst_file_sizes_on_db_open = false;
  Reopen();
-  // As footer could not be extraced, file is completely unreadable
-  Check(0, 0);
-  std::string v;
-  auto s = db_->Get(ReadOptions(), "k1", &v);
-  ASSERT_TRUE(s.IsCorruption());
+  Check(100, 100);

  // But reports the issue with paranoid checks
  options_.paranoid_checks = true;
-  s = TryReopen();
+  Status s = TryReopen();
  ASSERT_TRUE(s.IsCorruption());
  ASSERT_TRUE(s.ToString().find("file size mismatch") != std::string::npos);

@@ -934,6 +863,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
    ASSERT_OK(DB::Open(options, dbname_, &db_));
    assert(db_ != nullptr);  // suppress false clang-analyze report
    Build(100, 2);
+    // ASSERT_OK(db_->Flush(FlushOptions()));
    DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
    ASSERT_OK(dbi->TEST_FlushMemTable());
    mock->SetCorruptionMode(mode);
@@ -161,7 +161,6 @@ TEST_F(DBBasicTest, UniqueSession) {

  ASSERT_EQ(sid2, sid3);

-  DestroyAndReopen(options);
  CreateAndReopenWithCF({"goku"}, options);
  ASSERT_OK(db_->GetDbSessionId(sid1));
  ASSERT_OK(Put("bar", "e1"));
@@ -180,7 +179,6 @@ TEST_F(DBBasicTest, UniqueSession) {
 TEST_F(DBBasicTest, ReadOnlyDB) {
  ASSERT_OK(Put("foo", "v1"));
  ASSERT_OK(Put("bar", "v2"));
-  ASSERT_OK(Flush());
  ASSERT_OK(Put("foo", "v3"));
  Close();

@@ -210,11 +208,10 @@ TEST_F(DBBasicTest, ReadOnlyDB) {

  auto options = CurrentOptions();
  assert(options.env == env_);
-  ASSERT_OK(EnforcedReadOnlyReopen(options));
+  ASSERT_OK(ReadOnlyReopen(options));
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
  verify_all_iters();
-  ASSERT_EQ(Flush().code(), Status::Code::kNotSupported);
  Close();

  // Reopen and flush memtable.
@@ -222,38 +219,26 @@ TEST_F(DBBasicTest, ReadOnlyDB) {
  ASSERT_OK(Flush());
  Close();
  // Now check keys in read only mode.
-  ASSERT_OK(EnforcedReadOnlyReopen(options));
+  ASSERT_OK(ReadOnlyReopen(options));
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
  verify_all_iters();
-  ASSERT_EQ(db_->SyncWAL().code(), Status::Code::kNotSupported);
-
-  // More ops that should fail
-  std::vector<ColumnFamilyHandle*> cfhs{{}};
-  ASSERT_EQ(db_->CreateColumnFamily(options, "blah", &cfhs[0]).code(),
-            Status::Code::kNotSupported);
-
-  ASSERT_EQ(db_->CreateColumnFamilies(options, {"blah"}, &cfhs).code(),
-            Status::Code::kNotSupported);
-
-  std::vector<ColumnFamilyDescriptor> cfds;
-  cfds.push_back({"blah", options});
-  ASSERT_EQ(db_->CreateColumnFamilies(cfds, &cfhs).code(),
-            Status::Code::kNotSupported);
+  ASSERT_TRUE(db_->SyncWAL().IsNotSupported());
 }

-TEST_F(DBBasicTest, ReadOnlyDBWithWriteDBIdToManifestSet) {
-  auto options = CurrentOptions();
-  options.write_dbid_to_manifest = false;
-  DestroyAndReopen(options);
+// TODO akanksha: Update the test to check that combination
+// does not actually write to FS (use open read-only with
+// CompositeEnvWrapper+ReadOnlyFileSystem).
+TEST_F(DBBasicTest, DISABLED_ReadOnlyDBWithWriteDBIdToManifestSet) {
  ASSERT_OK(Put("foo", "v1"));
  ASSERT_OK(Put("bar", "v2"));
  ASSERT_OK(Put("foo", "v3"));
  Close();

+  auto options = CurrentOptions();
  options.write_dbid_to_manifest = true;
  assert(options.env == env_);
-  ASSERT_OK(EnforcedReadOnlyReopen(options));
+  ASSERT_OK(ReadOnlyReopen(options));
  std::string db_id1;
  ASSERT_OK(db_->GetDbIdentity(db_id1));
  ASSERT_EQ("v3", Get("foo"));
@@ -273,7 +258,7 @@ TEST_F(DBBasicTest, ReadOnlyDBWithWriteDBIdToManifestSet) {
  ASSERT_OK(Flush());
  Close();
  // Now check keys in read only mode.
-  ASSERT_OK(EnforcedReadOnlyReopen(options));
+  ASSERT_OK(ReadOnlyReopen(options));
  ASSERT_EQ("v3", Get("foo"));
  ASSERT_EQ("v2", Get("bar"));
  ASSERT_TRUE(db_->SyncWAL().IsNotSupported());
@@ -3288,7 +3273,8 @@ TEST_F(DBBasicTest, GetAllKeyVersions) {
    ASSERT_OK(Delete(std::to_string(i)));
  }
  std::vector<KeyVersion> key_versions;
-  ASSERT_OK(GetAllKeyVersions(db_, {}, {}, std::numeric_limits<size_t>::max(),
+  ASSERT_OK(GetAllKeyVersions(db_, Slice(), Slice(),
+                              std::numeric_limits<size_t>::max(),
                              &key_versions));
  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates, key_versions.size());
  for (size_t i = 0; i < kNumInserts + kNumDeletes + kNumUpdates; i++) {
@@ -3298,7 +3284,7 @@ TEST_F(DBBasicTest, GetAllKeyVersions) {
      ASSERT_EQ(key_versions[i].GetTypeName(), "TypeValue");
    }
  }
-  ASSERT_OK(GetAllKeyVersions(db_, handles_[0], {}, {},
+  ASSERT_OK(GetAllKeyVersions(db_, handles_[0], Slice(), Slice(),
                              std::numeric_limits<size_t>::max(),
                              &key_versions));
  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates, key_versions.size());
@@ -3313,17 +3299,10 @@ TEST_F(DBBasicTest, GetAllKeyVersions) {
  for (size_t i = 0; i + 1 != kNumDeletes; ++i) {
    ASSERT_OK(Delete(1, std::to_string(i)));
  }
-  ASSERT_OK(GetAllKeyVersions(db_, handles_[1], {}, {},
-                              std::numeric_limits<size_t>::max(),
-                              &key_versions));
-  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates - 3, key_versions.size());
-
-  // Change from historical behavior: empty key is now interpreted literally as
-  // a legal key (rather than as a "not present" key)
  ASSERT_OK(GetAllKeyVersions(db_, handles_[1], Slice(), Slice(),
                              std::numeric_limits<size_t>::max(),
                              &key_versions));
-  ASSERT_EQ(key_versions.size(), 0);
+  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates - 3, key_versions.size());
 }

 TEST_F(DBBasicTest, ValueTypeString) {
@@ -3375,69 +3354,6 @@ TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
                     keys.data(), values.data(), statuses.data(), true);
 }

-TEST_F(DBBasicTest, MultiGetWithSnapshotsAndPersistedTier) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.atomic_flush = true;
-  DestroyAndReopen(options);
-  CreateAndReopenWithCF({"cf1", "cf2"}, options);
-
-  // Insert initial data
-  ASSERT_OK(Put(0, "key1", "value1_cf0"));
-  ASSERT_OK(Put(1, "key1", "value1_cf1"));
-  ASSERT_OK(Put(2, "key1", "value1_cf2"));
-  ASSERT_OK(Flush({0, 1, 2}));
-  for (auto cf : {0, 1, 2}) {
-    ASSERT_EQ(1, NumTableFilesAtLevel(0, cf));
-  }
-
-  ASSERT_OK(Put(0, "key1", "value2_cf0"));
-  ASSERT_OK(Put(1, "key1", "value2_cf1"));
-  ASSERT_OK(Put(2, "key1", "value2_cf2"));
-
-  // Prepare for concurrent atomic flush
-  std::atomic<bool> flush_done(false);
-  std::thread flush_thread([&]() {
-    ASSERT_OK(Flush({0, 1, 2}));
-    flush_done.store(true);
-  });
-
-  // Perform MultiGet with snapshot and read_tier = kPersistentTier
-  ReadOptions ro;
-  const Snapshot* snapshot = db_->GetSnapshot();
-  ro.snapshot = snapshot;
-  ro.read_tier = kPersistedTier;
-
-  std::string k = "key1";
-  std::vector<Slice> keys(3, Slice(k));
-  std::vector<Status> statuses(keys.size());
-  std::vector<ColumnFamilyHandle*> cfs(keys.size());
-  std::vector<Slice> new_keys(keys.size());
-  std::vector<PinnableSlice> pin_values(keys.size());
-  for (size_t i = 0; i < keys.size(); ++i) {
-    cfs[i] = handles_[i];
-  }
-  db_->MultiGet(ro, cfs.size(), cfs.data(), keys.data(), pin_values.data(),
-                statuses.data());
-  for (const auto& s : statuses) {
-    ASSERT_OK(s);
-  }
-
-  if (pin_values[0] == "value1_cf0") {
-    // Check if the first value matches expected value
-    ASSERT_EQ(pin_values[1], "value1_cf1");
-    ASSERT_EQ(pin_values[2], "value1_cf2");
-  } else {
-    // If first value doesn't match, check if we got the updated values
-    ASSERT_EQ(pin_values[0], "value2_cf0");
-    ASSERT_EQ(pin_values[1], "value2_cf1");
-    ASSERT_EQ(pin_values[2], "value2_cf2");
-  }
-
-  flush_thread.join();
-  db_->ReleaseSnapshot(snapshot);
-}
-
 TEST_F(DBBasicTest, IncrementalRecoveryNoCorrupt) {
  Options options = CurrentOptions();
  DestroyAndReopen(options);
@@ -5086,7 +5002,6 @@ TEST_F(DBBasicTest, DisallowMemtableWrite) {
  options_allow.create_if_missing = true;
  Options options_disallow = options_allow;
  options_disallow.disallow_memtable_writes = true;
-  options_disallow.paranoid_memory_checks = true;

  DestroyAndReopen(options_allow);
  // CFs allowing and disallowing memtable write
@@ -5126,11 +5041,6 @@ TEST_F(DBBasicTest, DisallowMemtableWrite) {
  EXPECT_EQ(Get(2, "b2"), "2");
  EXPECT_EQ(Get(3, "b3"), "NOT_FOUND");

-  std::unique_ptr<Iterator> iter(
-      dbfull()->NewIterator(ReadOptions(), handles_[3]));
-  iter->Seek("a3");
-  ASSERT_OK(iter->status());
-  iter.reset();
  // When the DB is re-opened with WAL entries for a CF that is newly setting
  // disallow_memtable_writes, we detect that and fail the open gracefully.
  ASSERT_EQ(TryReopenWithColumnFamilies(
@@ -506,8 +506,6 @@ TEST_P(DBBlockCacheTest1, WarmCacheWithBlocksDuringFlush) {
  table_options.prepopulate_block_cache =
      BlockBasedTableOptions::PrepopulateBlockCache::kFlushOnly;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  // Include a compression dictionary block
-  options.compression_opts.max_dict_bytes = 123;
  DestroyAndReopen(options);

  std::string value(kValueSize, 'a');
@@ -539,9 +537,6 @@ TEST_P(DBBlockCacheTest1, WarmCacheWithBlocksDuringFlush) {
                options.statistics->getTickerCount(BLOCK_CACHE_FILTER_HIT));
    }
    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_FILTER_MISS));
-
-    // Including compression dict
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_MISS));
  }

  // Verify compaction not counted
@@ -829,78 +824,68 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
  const int kNumEntriesPerFile = 128;
  const int kNumBytesPerEntry = 1024;

-  std::vector<CompressionType> dict_compressions =
-      GetSupportedDictCompressions();
+  // Try all the available libraries that support dictionary compression
+  std::vector<CompressionType> compression_types;
+  if (Zlib_Supported()) {
+    compression_types.push_back(kZlibCompression);
+  }
+  if (LZ4_Supported()) {
+    compression_types.push_back(kLZ4Compression);
+    compression_types.push_back(kLZ4HCCompression);
+  }
+  if (ZSTD_Supported()) {
+    compression_types.push_back(kZSTD);
+  }
  Random rnd(301);
-  // Format version before and after compression handling changes
-  for (int format_version : {6, 7}) {
-    // Test all supported compression types because (at least historically)
-    // dictionary compression could be enabled and a dictionary block saved
-    // but ignored by some compression types. Ensure we at least don't crash
-    // or return corruption for those.
-    for (auto compression_type : GetSupportedCompressions()) {
-      // Extra handling checks only for types actually supporting dictionary
-      // compression.
-      bool dict_supported =
-          std::count(dict_compressions.begin(), dict_compressions.end(),
-                     compression_type) > 0;
+  for (auto compression_type : compression_types) {
+    Options options = CurrentOptions();
+    options.bottommost_compression = compression_type;
+    options.bottommost_compression_opts.max_dict_bytes = 4096;
+    options.bottommost_compression_opts.enabled = true;
+    options.create_if_missing = true;
+    options.num_levels = 2;
+    options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+    options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
+    BlockBasedTableOptions table_options;
+    table_options.cache_index_and_filter_blocks = true;
+    table_options.block_cache.reset(new MockCache());
+    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    DestroyAndReopen(options);

-      Options options = CurrentOptions();
-      options.bottommost_compression = compression_type;
-      options.bottommost_compression_opts.max_dict_bytes = 4096;
-      options.bottommost_compression_opts.enabled = true;
-      options.create_if_missing = true;
-      options.num_levels = 2;
-      options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-      options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
-      BlockBasedTableOptions table_options;
-      table_options.cache_index_and_filter_blocks = true;
-      table_options.block_cache.reset(new MockCache());
-      table_options.format_version = format_version;
-      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-      DestroyAndReopen(options);
+    RecordCacheCountersForCompressionDict(options);

-      RecordCacheCountersForCompressionDict(options);
-
-      for (int i = 0; i < kNumFiles; ++i) {
-        ASSERT_EQ(i, NumTableFilesAtLevel(0, 0));
-        for (int j = 0; j < kNumEntriesPerFile; ++j) {
-          std::string value = rnd.RandomString(kNumBytesPerEntry);
-          ASSERT_OK(Put(Key(j * kNumFiles + i), value.c_str()));
-        }
-        ASSERT_OK(Flush());
-      }
-      ASSERT_OK(dbfull()->TEST_WaitForCompact());
-      ASSERT_EQ(0, NumTableFilesAtLevel(0));
-      ASSERT_EQ(kNumFiles, NumTableFilesAtLevel(1));
-
-      if (dict_supported) {
-        // Compression dictionary blocks are preloaded.
-        CheckCacheCountersForCompressionDict(
-            options, kNumFiles /* expected_compression_dict_misses */,
-            0 /* expected_compression_dict_hits */,
-            kNumFiles /* expected_compression_dict_inserts */);
-      }
-
-      // Seek to a key in a file. It should cause the SST's dictionary
-      // meta-block to be read.
-      RecordCacheCounters(options);
-      RecordCacheCountersForCompressionDict(options);
-      ReadOptions read_options;
-      ASSERT_NE("NOT_FOUND", Get(Key(kNumFiles * kNumEntriesPerFile - 1)));
-
-      if (dict_supported) {
-        // Two block hits: index and dictionary since they are prefetched
-        // One block missed/added: data block
-        CheckCacheCounters(options, 1 /* expected_misses */,
-                           2 /* expected_hits */, 1 /* expected_inserts */,
-                           0 /* expected_failures */);
-        CheckCacheCountersForCompressionDict(
-            options, 0 /* expected_compression_dict_misses */,
-            1 /* expected_compression_dict_hits */,
-            0 /* expected_compression_dict_inserts */);
+    for (int i = 0; i < kNumFiles; ++i) {
+      ASSERT_EQ(i, NumTableFilesAtLevel(0, 0));
+      for (int j = 0; j < kNumEntriesPerFile; ++j) {
+        std::string value = rnd.RandomString(kNumBytesPerEntry);
+        ASSERT_OK(Put(Key(j * kNumFiles + i), value.c_str()));
      }
+      ASSERT_OK(Flush());
    }
+    ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    ASSERT_EQ(0, NumTableFilesAtLevel(0));
+    ASSERT_EQ(kNumFiles, NumTableFilesAtLevel(1));
+
+    // Compression dictionary blocks are preloaded.
+    CheckCacheCountersForCompressionDict(
+        options, kNumFiles /* expected_compression_dict_misses */,
+        0 /* expected_compression_dict_hits */,
+        kNumFiles /* expected_compression_dict_inserts */);
+
+    // Seek to a key in a file. It should cause the SST's dictionary meta-block
+    // to be read.
+    RecordCacheCounters(options);
+    RecordCacheCountersForCompressionDict(options);
+    ReadOptions read_options;
+    ASSERT_NE("NOT_FOUND", Get(Key(kNumFiles * kNumEntriesPerFile - 1)));
+    // Two block hits: index and dictionary since they are prefetched
+    // One block missed/added: data block
+    CheckCacheCounters(options, 1 /* expected_misses */, 2 /* expected_hits */,
+                       1 /* expected_inserts */, 0 /* expected_failures */);
+    CheckCacheCountersForCompressionDict(
+        options, 0 /* expected_compression_dict_misses */,
+        1 /* expected_compression_dict_hits */,
+        0 /* expected_compression_dict_inserts */);
  }
 }

@@ -17,10 +17,9 @@ class DBEncryptionTest : public DBTestBase {
 public:
  DBEncryptionTest()
      : DBTestBase("db_encryption_test", /*env_do_fsync=*/true) {}
-  Env* GetNonEncryptedEnv() {
+  Env* GetTargetEnv() {
    if (encrypted_env_ != nullptr) {
-      return (static_cast_with_check<CompositeEnvWrapper>(encrypted_env_))
-          ->env_target();
+      return (static_cast<EnvWrapper*>(encrypted_env_))->target();
    } else {
      return env_;
    }
@@ -39,7 +38,7 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
  auto status = env_->GetChildren(dbname_, &fileNames);
  ASSERT_OK(status);

-  Env* target = GetNonEncryptedEnv();
+  Env* target = GetTargetEnv();
  int hits = 0;
  for (auto it = fileNames.begin(); it != fileNames.end(); ++it) {
    if (*it == "LOCK") {
@@ -90,7 +89,7 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
 }

 TEST_F(DBEncryptionTest, ReadEmptyFile) {
-  auto defaultEnv = GetNonEncryptedEnv();
+  auto defaultEnv = GetTargetEnv();

  // create empty file for reading it back in later
  auto envOptions = EnvOptions(CurrentOptions());
@@ -117,40 +116,6 @@ TEST_F(DBEncryptionTest, ReadEmptyFile) {
  ASSERT_TRUE(data.empty());
 }

-TEST_F(DBEncryptionTest, NotSupportedGetFileSize) {
-  // Validate envrypted env does not support GetFileSize.
-  // The goal of the test is to validate the encrypted env/fs does not support
-  // GetFileSize API on FSRandomAccessFile interface.
-  // This test combined with the rest of the integration tests validate that
-  // the new API GetFileSize on FSRandomAccessFile interface is not required to
-  // be supported for database to work properly.
-  // The GetFileSize API is used in ReadFooterFromFile() API to get the file
-  // size. When GetFileSize API is not supported, the ReadFooterFromFile() API
-  // will use FileSystem GetFileSize API as fallback. Refer to the
-  // EncryptedRandomAccessFile class definition for more details.
-  if (!encrypted_env_) {
-    return;
-  }
-
-  auto fs = encrypted_env_->GetFileSystem();
-
-  // create empty file for reading it back in later
-  auto filePath = dbname_ + "/empty.empty";
-
-  // Create empty file
-  CreateFile(fs.get(), filePath, "", false);
-
-  // Open it for reading footer
-  std::unique_ptr<FSRandomAccessFile> randomAccessFile;
-  auto status = fs->NewRandomAccessFile(filePath, FileOptions(),
-                                        &randomAccessFile, nullptr);
-  ASSERT_OK(status);
-
-  uint64_t fileSize;
-  status = randomAccessFile->GetFileSize(&fileSize);
-  ASSERT_TRUE(status.IsNotSupported());
-}
-
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -75,9 +75,11 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,

  ret.emplace_back(CurrentFileName(""));
  ret.emplace_back(DescriptorFileName("", versions_->manifest_file_number()));
-  // In read-only mode the OPTIONS file number is zero when no OPTIONS file
-  // exist at all. In this cases we do not record any OPTIONS file in the live
-  // file list.
+  // The OPTIONS file number is zero in read-write mode when OPTIONS file
+  // writing failed and the DB was configured with
+  // `fail_if_options_file_error == false`. In read-only mode the OPTIONS file
+  // number is zero when no OPTIONS file exist at all. In those cases we do not
+  // record any OPTIONS file in the live file list.
  if (versions_->options_file_number() != 0) {
    ret.emplace_back(OptionsFileName("", versions_->options_file_number()));
  }
@@ -183,14 +185,14 @@ Status DBImpl::GetSortedWalFilesImpl(VectorWalPtr& files, bool need_seqnos) {
  return s;
 }

-Status DBImpl::GetCurrentWalFile(std::unique_ptr<WalFile>* current_wal_file) {
+Status DBImpl::GetCurrentWalFile(std::unique_ptr<WalFile>* current_log_file) {
  uint64_t current_logfile_number;
  {
    InstrumentedMutexLock l(&mutex_);
-    current_logfile_number = cur_wal_number_;
+    current_logfile_number = logfile_number_;
  }

-  return wal_manager_.GetLiveWalFile(current_logfile_number, current_wal_file);
+  return wal_manager_.GetLiveWalFile(current_logfile_number, current_log_file);
 }

 Status DBImpl::GetLiveFilesStorageInfo(
@@ -330,7 +332,7 @@ Status DBImpl::GetLiveFilesStorageInfo(
  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 = cur_wal_number_;
+  const uint64_t max_log_num = logfile_number_;

  mutex_.Unlock();

@@ -367,9 +369,11 @@ Status DBImpl::GetLiveFilesStorageInfo(
    }
  }

-  // In read-only mode the OPTIONS file number is zero when no OPTIONS file
-  // exist at all. In this cases we do not record any OPTIONS file in the live
-  // file list.
+  // The OPTIONS file number is zero in read-write mode when OPTIONS file
+  // writing failed and the DB was configured with
+  // `fail_if_options_file_error == false`. In read-only mode the OPTIONS file
+  // number is zero when no OPTIONS file exist at all. In those cases we do not
+  // record any OPTIONS file in the live file list.
  if (options_number != 0) {
    results.emplace_back();
    LiveFileStorageInfo& info = results.back();
@@ -3504,63 +3504,6 @@ TEST_F(DBFlushTest, DBStuckAfterAtomicFlushError) {
  ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
  ASSERT_EQ(1, NumTableFilesAtLevel(0));
 }
-
-TEST_F(DBFlushTest, VerifyOutputRecordCount) {
-  for (bool use_plain_table : {false, true}) {
-    Options options = CurrentOptions();
-    options.flush_verify_memtable_count = true;
-    options.merge_operator = MergeOperators::CreateStringAppendOperator();
-    DestroyAndReopen(options);
-    // Verify flush output record count verification in different table
-    // formats
-    if (use_plain_table) {
-      options.table_factory.reset(NewPlainTableFactory());
-    }
-
-    // Verify that flush output record count verification does not produce false
-    // positives.
-    ASSERT_OK(Merge("k0", "v1"));
-    ASSERT_OK(Put("k1", "v1"));
-    ASSERT_OK(Put("k2", "v1"));
-    ASSERT_OK(SingleDelete("k2"));
-    ASSERT_OK(Delete("k2"));
-    ASSERT_OK(Delete("k3"));
-    ASSERT_OK(db_->DeleteRange(WriteOptions(), "k1", "k3"));
-    ASSERT_OK(Flush());
-
-    // Verify that flush output record count verification catch corruption
-    DestroyAndReopen(options);
-    if (use_plain_table) {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PlainTableBuilder::Add::skip",
-          [&](void* skip) { *(bool*)skip = true; });
-
-    } else {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "BlockBasedTableBuilder::Add::skip",
-          [&](void* skip) { *(bool*)skip = true; });
-    }
-    SyncPoint::GetInstance()->EnableProcessing();
-    const char* expect =
-        "Number of keys in flush output SST files does not match";
-
-    // 1. During DB open flush
-    ASSERT_OK(Put("k1", "v1"));
-    ASSERT_OK(Put("k2", "v1"));
-    Status s = TryReopen(options);
-    ASSERT_TRUE(s.IsCorruption());
-    ASSERT_TRUE(std::strstr(s.getState(), expect));
-
-    // 2. During regular flush
-    DestroyAndReopen(options);
-    ASSERT_OK(Put("k1", "v1"));
-    ASSERT_OK(Put("k2", "v1"));
-    s = Flush();
-    ASSERT_TRUE(s.IsCorruption());
-    ASSERT_TRUE(std::strstr(s.getState(), expect));
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  }
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -173,10 +173,10 @@ struct DBOpenLogRecordReadReporter : public log::Reader::Reporter {

  void OldLogRecord(size_t bytes) override;

-  uint64_t GetCorruptedLogNumber() const { return corrupted_wal_number_; }
+  uint64_t GetCorruptedLogNumber() const { return corrupted_log_number_; }

 private:
-  uint64_t corrupted_wal_number_ = kMaxSequenceNumber;
+  uint64_t corrupted_log_number_ = kMaxSequenceNumber;
 };

 // While DB is the public interface of RocksDB, and DBImpl is the actual
@@ -256,10 +256,6 @@ class DBImpl : public DB {
  Status WriteWithCallback(const WriteOptions& options, WriteBatch* updates,
                           UserWriteCallback* user_write_cb) override;

-  Status IngestWriteBatchWithIndex(
-      const WriteOptions& options,
-      std::shared_ptr<WriteBatchWithIndex> wbwi) override;
-
  using DB::Get;
  Status Get(const ReadOptions& _read_options,
             ColumnFamilyHandle* column_family, const Slice& key,
@@ -383,11 +379,6 @@ class DBImpl : public DB {
                      const std::vector<ColumnFamilyHandle*>& column_families,
                      std::vector<Iterator*>* iterators) override;

-  using DB::NewMultiScan;
-  std::unique_ptr<MultiScan> NewMultiScan(
-      const ReadOptions& _read_options, ColumnFamilyHandle* column_family,
-      const std::vector<ScanOptions>& scan_opts) override;
-
  const Snapshot* GetSnapshot() override;
  void ReleaseSnapshot(const Snapshot* snapshot) override;

@@ -506,9 +497,6 @@ class DBImpl : public DB {
  Status GetFullHistoryTsLow(ColumnFamilyHandle* column_family,
                             std::string* ts_low) override;

-  Status GetNewestUserDefinedTimestamp(ColumnFamilyHandle* column_family,
-                                       std::string* newest_timestamp) override;
-
  Status GetDbIdentity(std::string& identity) const override;

  virtual Status GetDbIdentityFromIdentityFile(const IOOptions& opts,
@@ -542,11 +530,11 @@ class DBImpl : public DB {

  // Get the known flushed sizes of WALs that might still be written to
  // or have pending sync.
-  // NOTE: unlike alive_wal_files_, this function includes WALs that might
+  // 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_wal_file) override;
+  Status GetCurrentWalFile(std::unique_ptr<WalFile>* current_log_file) override;
  Status GetCreationTimeOfOldestFile(uint64_t* creation_time) override;

  Status GetUpdatesSince(
@@ -554,7 +542,7 @@ class DBImpl : public DB {
      const TransactionLogIterator::ReadOptions& read_options =
          TransactionLogIterator::ReadOptions()) override;
  Status DeleteFilesInRanges(ColumnFamilyHandle* column_family,
-                             const RangeOpt* ranges, size_t n,
+                             const RangePtr* ranges, size_t n,
                             bool include_end = true);

  void GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata) override;
@@ -663,11 +651,6 @@ class DBImpl : public DB {
      ColumnFamilyHandle* column_family, const Range* range, std::size_t n,
      TablePropertiesCollection* props) override;

-  Status GetPropertiesOfTablesByLevel(
-      ColumnFamilyHandle* column_family,
-      std::vector<std::unique_ptr<TablePropertiesCollection>>* props_by_level)
-      override;
-
  // ---- End of implementations of the DB interface ----
  SystemClock* GetSystemClock() const;

@@ -804,6 +787,10 @@ class DBImpl : public DB {
  // being detected.
  const Snapshot* GetSnapshotForWriteConflictBoundary();

+  // checks if all live files exist on file system and that their file sizes
+  // match to our in-memory records
+  virtual Status CheckConsistency();
+
  // max_file_num_to_ignore allows bottom level compaction to filter out newly
  // compacted SST files. Setting max_file_num_to_ignore to kMaxUint64 will
  // disable the filtering
@@ -1076,7 +1063,7 @@ class DBImpl : public DB {

  void AddToLogsToFreeQueue(log::Writer* log_writer) {
    mutex_.AssertHeld();
-    wals_to_free_queue_.push_back(log_writer);
+    logs_to_free_queue_.push_back(log_writer);
  }

  void AddSuperVersionsToFreeQueue(SuperVersion* sv) {
@@ -1086,7 +1073,10 @@ class DBImpl : public DB {
  void SetSnapshotChecker(SnapshotChecker* snapshot_checker);

  // Fill JobContext with snapshot information needed by flush and compaction.
-  void InitSnapshotContext(JobContext* job_context);
+  void GetSnapshotContext(JobContext* job_context,
+                          std::vector<SequenceNumber>* snapshot_seqs,
+                          SequenceNumber* earliest_write_conflict_snapshot,
+                          SnapshotChecker** snapshot_checker);

  // Not thread-safe.
  void SetRecoverableStatePreReleaseCallback(PreReleaseCallback* callback);
@@ -1138,7 +1128,7 @@ class DBImpl : public DB {
  bool TEST_UnableToReleaseOldestLog() { return unable_to_release_oldest_log_; }

  bool TEST_IsLogGettingFlushed() {
-    return alive_wal_files_.begin()->getting_flushed;
+    return alive_log_files_.begin()->getting_flushed;
  }

  Status TEST_SwitchMemtable(ColumnFamilyData* cfd = nullptr);
@@ -1218,9 +1208,7 @@ class DBImpl : public DB {

  uint64_t TEST_LogfileNumber();

-  uint64_t TEST_wals_total_size() const {
-    return wals_total_size_.LoadRelaxed();
-  }
+  uint64_t TEST_total_log_size() const { return total_log_size_; }

  void TEST_GetAllBlockCaches(std::unordered_set<const Cache*>* cache_set);

@@ -1279,24 +1267,27 @@ class DBImpl : public DB {
  // flush LOG out of application buffer
  void FlushInfoLog();

-  // For the background timer job
-  void RecordSeqnoToTimeMapping();
+  // record current sequence number to time mapping. If
+  // populate_historical_seconds > 0 then pre-populate all the
+  // sequence numbers from [1, last] to map to [now minus
+  // populate_historical_seconds, now].
+  void RecordSeqnoToTimeMapping(uint64_t populate_historical_seconds);

-  // Compactions rely on an event triggers like flush/compaction/SetOptions.
-  // We need to trigger periodic compactions even when there is no such trigger.
-  // This function checks and schedules available compactions and will run
-  // periodically.
-  void TriggerPeriodicCompaction();
-
-  // REQUIRES: DB mutex held
-  std::pair<SequenceNumber, uint64_t> GetSeqnoToTimeSample() const;
-
-  // REQUIRES: DB mutex held or during open
-  void EnsureSeqnoToTimeMapping(const MinAndMaxPreserveSeconds& preserve_secs);
-
-  // Only called during open
-  void PrepopulateSeqnoToTimeMapping(
-      const MinAndMaxPreserveSeconds& preserve_secs);
+  // Everytime DB's seqno to time mapping changed (which already hold the db
+  // mutex), we install a new SuperVersion in each column family with a shared
+  // copy of the new mapping while holding the db mutex.
+  // This is done for all column families even though the column family does not
+  // explicitly enabled the
+  // `preclude_last_level_data_seconds` or `preserve_internal_time_seconds`
+  // features.
+  // This mapping supports iterators to fulfill the
+  // "rocksdb.iterator.write-time" iterator property for entries in memtables.
+  //
+  // Since this new SuperVersion doesn't involve an LSM tree shape change, we
+  // don't schedule work after installing this SuperVersion. It returns the used
+  // `SuperVersionContext` for clean up after release mutex.
+  void InstallSeqnoToTimeMappingInSV(
+      std::vector<SuperVersionContext>* sv_contexts);

  // Interface to block and signal the DB in case of stalling writes by
  // WriteBufferManager. Each DBImpl object contains ptr to WBMStallInterface.
@@ -1384,16 +1375,16 @@ class DBImpl : public DB {

  // State below is protected by mutex_
  // With two_write_queues enabled, some of the variables that accessed during
-  // WriteToWAL need different synchronization: wal_empty_, alive_wal_files_,
-  // logs_, cur_wal_number_. Refer to the definition of each variable below for
+  // WriteToWAL need different synchronization: log_empty_, alive_log_files_,
+  // logs_, logfile_number_. Refer to the definition of each variable below for
  // more description.
  //
  // `mutex_` can be a hot lock in some workloads, so it deserves dedicated
  // cachelines.
  mutable CacheAlignedInstrumentedMutex mutex_;

-  ColumnFamilyHandleImpl* default_cf_handle_ = nullptr;
-  InternalStats* default_cf_internal_stats_ = nullptr;
+  ColumnFamilyHandleImpl* default_cf_handle_;
+  InternalStats* default_cf_internal_stats_;

  // table_cache_ provides its own synchronization
  std::shared_ptr<Cache> table_cache_;
@@ -1405,7 +1396,7 @@ class DBImpl : public DB {

  // only used for dynamically adjusting max_total_wal_size. it is a sum of
  // [write_buffer_size * max_write_buffer_number] over all column families
-  std::atomic<uint64_t> max_total_in_memory_state_ = 0;
+  std::atomic<uint64_t> max_total_in_memory_state_;

  // The options to access storage files
  const FileOptions file_options_;
@@ -1432,14 +1423,14 @@ class DBImpl : public DB {

  // Each flush or compaction gets its own job id. this counter makes sure
  // they're unique
-  std::atomic<int> next_job_id_ = 1;
+  std::atomic<int> next_job_id_;

-  std::atomic<bool> shutting_down_ = false;
+  std::atomic<bool> shutting_down_;

  // No new background jobs can be queued if true. This is used to prevent new
  // background jobs from being queued after WaitForCompact() completes waiting
  // all background jobs then attempts to close when close_db_ option is true.
-  bool reject_new_background_jobs_ = false;
+  bool reject_new_background_jobs_;

  // RecoveryContext struct stores the context about version edits along
  // with corresponding column_family_data and column_family_options.
@@ -1537,11 +1528,11 @@ class DBImpl : public DB {
  // ingests `wbwi` is done.
  // @param memtable_updated Whether the same write that ingests wbwi has
  // updated memtable. This is useful for determining whether to set bg
-  // error when IngestWBWIAsMemtable fails.
-  Status IngestWBWIAsMemtable(std::shared_ptr<WriteBatchWithIndex> wbwi,
-                              const WBWIMemTable::SeqnoRange& assigned_seqno,
-                              uint64_t min_prep_log, SequenceNumber last_seqno,
-                              bool memtable_updated, bool ignore_missing_cf);
+  // error when IngestWBWI fails.
+  Status IngestWBWI(std::shared_ptr<WriteBatchWithIndex> wbwi,
+                    const WBWIMemTable::SeqnoRange& assigned_seqno,
+                    uint64_t min_prep_log, SequenceNumber last_seqno,
+                    bool memtable_updated, bool ignore_missing_cf);

  // If disable_memtable is set the application logic must guarantee that the
  // batch will still be skipped from memtable during the recovery. An excption
@@ -1571,17 +1562,18 @@ class DBImpl : public DB {
  Status WriteImpl(const WriteOptions& options, WriteBatch* updates,
                   WriteCallback* callback = nullptr,
                   UserWriteCallback* user_write_cb = nullptr,
-                   uint64_t* wal_used = nullptr, uint64_t log_ref = 0,
+                   uint64_t* log_used = nullptr, uint64_t log_ref = 0,
                   bool disable_memtable = false, uint64_t* seq_used = nullptr,
                   size_t batch_cnt = 0,
                   PreReleaseCallback* pre_release_callback = nullptr,
                   PostMemTableCallback* post_memtable_callback = nullptr,
-                   std::shared_ptr<WriteBatchWithIndex> wbwi = nullptr);
+                   std::shared_ptr<WriteBatchWithIndex> wbwi = nullptr,
+                   uint64_t min_prep_log = 0);

  Status PipelinedWriteImpl(const WriteOptions& options, WriteBatch* updates,
                            WriteCallback* callback = nullptr,
                            UserWriteCallback* user_write_cb = nullptr,
-                            uint64_t* wal_used = nullptr, uint64_t log_ref = 0,
+                            uint64_t* log_used = nullptr, uint64_t log_ref = 0,
                            bool disable_memtable = false,
                            uint64_t* seq_used = nullptr);

@@ -1608,7 +1600,7 @@ class DBImpl : public DB {
  Status WriteImplWALOnly(
      WriteThread* write_thread, const WriteOptions& options,
      WriteBatch* updates, WriteCallback* callback,
-      UserWriteCallback* user_write_cb, uint64_t* wal_used,
+      UserWriteCallback* user_write_cb, 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);
@@ -1769,9 +1761,9 @@ class DBImpl : public DB {
    }
  };

-  struct WalFileNumberSize {
-    explicit WalFileNumberSize(uint64_t _number) : number(_number) {}
-    WalFileNumberSize() {}
+  struct LogFileNumberSize {
+    explicit LogFileNumberSize(uint64_t _number) : number(_number) {}
+    LogFileNumberSize() {}
    void AddSize(uint64_t new_size) { size += new_size; }
    uint64_t number;
    uint64_t size = 0;
@@ -1793,13 +1785,6 @@ class DBImpl : public DB {
      if (writer->file()) {
        // TODO: plumb Env::IOActivity, Env::IOPriority
        s = writer->WriteBuffer(WriteOptions());
-        if (attempt_truncate_size < SIZE_MAX &&
-            attempt_truncate_size < writer->file()->GetFileSize()) {
-          Status s2 = writer->file()->writable_file()->Truncate(
-              attempt_truncate_size, IOOptions{}, nullptr);
-          // This is just a best effort attempt
-          s2.PermitUncheckedError();
-        }
      }
      delete writer;
      writer = nullptr;
@@ -1832,11 +1817,6 @@ class DBImpl : public DB {
      getting_synced = false;
    }

-    void SetAttemptTruncateSize(uint64_t size) {
-      assert(attempt_truncate_size == SIZE_MAX);
-      attempt_truncate_size = size;
-    }
-
    uint64_t number;
    // Visual Studio doesn't support deque's member to be noncopyable because
    // of a std::unique_ptr as a member.
@@ -1849,20 +1829,15 @@ class DBImpl : public DB {
    // to be persisted even if appends happen during sync so it can be used for
    // tracking the synced size in MANIFEST.
    uint64_t pre_sync_size = 0;
-    // When < SIZE_MAX, attempt to truncate the WAL to this size on close,
-    // because a bad entry was written to it beyond that point and it likely
-    // won't be recoverable with the bad entry.
-    uint64_t attempt_truncate_size = SIZE_MAX;
  };

-  struct WalContext {
-    explicit WalContext(bool need_sync = false)
-        : need_wal_sync(need_sync), need_wal_dir_sync(need_sync) {}
-    bool need_wal_sync = false;
-    bool need_wal_dir_sync = false;
+  struct LogContext {
+    explicit LogContext(bool need_sync = false)
+        : need_log_sync(need_sync), need_log_dir_sync(need_sync) {}
+    bool need_log_sync = false;
+    bool need_log_dir_sync = false;
    log::Writer* writer = nullptr;
-    WalFileNumberSize* wal_file_number_size = nullptr;
-    uint64_t prev_size = SIZE_MAX;
+    LogFileNumberSize* log_file_number_size = nullptr;
  };

  // PurgeFileInfo is a structure to hold information of files to be deleted in
@@ -1954,19 +1929,12 @@ class DBImpl : public DB {
  };
  struct PrepickedCompaction {
    // background compaction takes ownership of `compaction`.
-    // TODO(hx235): consider using std::shared_ptr for easier ownership
-    // management
    Compaction* compaction;
    // caller retains ownership of `manual_compaction_state` as it is reused
    // across background compactions.
    ManualCompactionState* manual_compaction_state;  // nullptr if non-manual
    // task limiter token is requested during compaction picking.
    std::unique_ptr<TaskLimiterToken> task_token;
-    // If true, `compaction` is picked temporarily to express compaction intent
-    // and will be released before re-picking a real compaction based on the
-    // updated LSM shape when thread associated with `compaction` is ready to
-    // run
-    bool need_repick;
  };

  struct CompactionArg {
@@ -2011,7 +1979,7 @@ class DBImpl : public DB {

  // Follow-up work to user creating a column family or (families)
  Status WrapUpCreateColumnFamilies(
-      const WriteOptions& write_options,
+      const ReadOptions& read_options, const WriteOptions& write_options,
      const std::vector<const ColumnFamilyOptions*>& cf_options);

  Status DropColumnFamilyImpl(ColumnFamilyHandle* column_family);
@@ -2057,13 +2025,14 @@ class DBImpl : public DB {
  // Flush the in-memory write buffer to storage.  Switches to a new
  // log-file/memtable and writes a new descriptor iff successful. Then
  // installs a new super version for the column family.
-  Status FlushMemTableToOutputFile(ColumnFamilyData* cfd,
-                                   const MutableCFOptions& mutable_cf_options,
-                                   bool* madeProgress, JobContext* job_context,
-                                   FlushReason flush_reason,
-                                   SuperVersionContext* superversion_context,
-                                   LogBuffer* log_buffer,
-                                   Env::Priority thread_pri);
+  Status FlushMemTableToOutputFile(
+      ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
+      bool* madeProgress, JobContext* job_context, FlushReason flush_reason,
+      SuperVersionContext* superversion_context,
+      std::vector<SequenceNumber>& snapshot_seqs,
+      SequenceNumber earliest_write_conflict_snapshot,
+      SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
+      Env::Priority thread_pri);

  // Flush the memtables of (multiple) column families to multiple files on
  // persistent storage.
@@ -2076,10 +2045,10 @@ class DBImpl : public DB {
      JobContext* job_context, LogBuffer* log_buffer, Env::Priority thread_pri);

  // REQUIRES: log_numbers are sorted in ascending order
-  // corrupted_wal_found is set to true if we recover from a corrupted log file.
+  // corrupted_log_found is set to true if we recover from a corrupted log file.
  Status RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
                         SequenceNumber* next_sequence, bool read_only,
-                         bool is_retry, bool* corrupted_wal_found,
+                         bool is_retry, bool* corrupted_log_found,
                         RecoveryContext* recovery_ctx);

  void SetupLogFilesRecovery(
@@ -2169,11 +2138,6 @@ class DBImpl : public DB {
      bool flushed, std::unordered_map<int, VersionEdit>* version_edits,
      RecoveryContext* recovery_ctx);

-  // Check that DB sequence number is not set back during recovery between
-  // replaying of WAL files and between replaying of WriteBatches.
-  Status CheckSeqnoNotSetBackDuringRecovery(SequenceNumber prev_next_seqno,
-                                            SequenceNumber current_next_seqno);
-
  void FinishLogFilesRecovery(int job_id, const Status& status);
  // The following two methods are used to flush a memtable to
  // storage. The first one is used at database RecoveryTime (when the
@@ -2187,12 +2151,12 @@ class DBImpl : public DB {
  // log file to its actual size, thereby freeing preallocated space.
  // Return success even if truncate fails
  Status GetLogSizeAndMaybeTruncate(uint64_t wal_number, bool truncate,
-                                    WalFileNumberSize* log);
+                                    LogFileNumberSize* log);

-  // Restore alive_wal_files_ and wals_total_size_ after recovery.
+  // Restore alive_log_files_ and total_log_size_ after recovery.
  // It needs to run only when there's no flush during recovery
  // (e.g. avoid_flush_during_recovery=true). May also trigger flush
-  // in case wals_total_size > max_total_wal_size.
+  // in case total_log_size > max_total_wal_size.
  Status RestoreAliveLogFiles(const std::vector<uint64_t>& log_numbers);

  // num_bytes: for slowdown case, delay time is calculated based on
@@ -2341,7 +2305,7 @@ class DBImpl : public DB {

  // REQUIRES: mutex locked
  Status PreprocessWrite(const WriteOptions& write_options,
-                         WalContext* log_context, WriteContext* write_context);
+                         LogContext* log_context, WriteContext* write_context);

  // Merge write batches in the write group into merged_batch.
  // Returns OK if merge is successful.
@@ -2352,21 +2316,20 @@ class DBImpl : public DB {

  IOStatus WriteToWAL(const WriteBatch& merged_batch,
                      const WriteOptions& write_options,
-                      log::Writer* log_writer, uint64_t* wal_used,
+                      log::Writer* log_writer, uint64_t* log_used,
                      uint64_t* log_size,
-                      WalFileNumberSize& wal_file_number_size,
+                      LogFileNumberSize& log_file_number_size,
                      SequenceNumber sequence);

-  IOStatus WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
-                           log::Writer* log_writer, uint64_t* wal_used,
-                           bool need_wal_sync, bool need_wal_dir_sync,
-                           SequenceNumber sequence,
-                           WalFileNumberSize& wal_file_number_size);
+  IOStatus WriteToWAL(const WriteThread::WriteGroup& write_group,
+                      log::Writer* log_writer, uint64_t* log_used,
+                      bool need_log_sync, bool need_log_dir_sync,
+                      SequenceNumber sequence,
+                      LogFileNumberSize& log_file_number_size);

-  IOStatus ConcurrentWriteGroupToWAL(const WriteThread::WriteGroup& write_group,
-                                     uint64_t* wal_used,
-                                     SequenceNumber* last_sequence,
-                                     size_t seq_inc);
+  IOStatus ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
+                                uint64_t* log_used,
+                                SequenceNumber* last_sequence, size_t seq_inc);

  // Used by WriteImpl to update bg_error_ if paranoid check is enabled.
  // Caller must hold mutex_.
@@ -2380,7 +2343,7 @@ class DBImpl : public DB {
  void WALIOStatusCheck(const IOStatus& status);

  // Used by WriteImpl to update bg_error_ in case of memtable insert error.
-  void HandleMemTableInsertFailure(const Status& nonok_memtable_insert_status);
+  void MemTableInsertStatusCheck(const Status& memtable_insert_status);

  Status CompactFilesImpl(const CompactionOptions& compact_options,
                          ColumnFamilyData* cfd, Version* version,
@@ -2465,8 +2428,6 @@ class DBImpl : public DB {
                         bool* flush_rescheduled_to_retain_udt,
                         Env::Priority thread_pri);

-  Compaction* CreateIntendedCompactionForwardedToBottomPriorityPool(
-      Compaction* c);
  bool EnoughRoomForCompaction(ColumnFamilyData* cfd,
                               const std::vector<CompactionInputFiles>& inputs,
                               bool* sfm_bookkeeping, LogBuffer* log_buffer);
@@ -2489,7 +2450,9 @@ class DBImpl : public DB {
  // Cancel scheduled periodic tasks
  Status CancelPeriodicTaskScheduler();

-  Status RegisterRecordSeqnoTimeWorker();
+  Status RegisterRecordSeqnoTimeWorker(const ReadOptions& read_options,
+                                       const WriteOptions& write_options,
+                                       bool is_new_db);

  void PrintStatistics();

@@ -2555,21 +2518,12 @@ class DBImpl : public DB {

  // Background threads call this function, which is just a wrapper around
  // the InstallSuperVersion() function. Background threads carry
-  // sv_context to allow allocation of SuperVersion object outside of holding
-  // the DB mutex.
+  // sv_context which can have new_superversion already
+  // allocated.
  // All ColumnFamily state changes go through this function. Here we analyze
  // the new state and we schedule background work if we detect that the new
  // state needs flush or compaction.
-  // See also InstallSuperVersionForConfigChange().
-  void InstallSuperVersionAndScheduleWork(
-      ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-      std::optional<std::shared_ptr<SeqnoToTimeMapping>>
-          new_seqno_to_time_mapping = {});
-
-  // A variant of InstallSuperVersionAndScheduleWork() that must be used for
-  // new CFs or for changes to mutable_cf_options. This is so that it can
-  // update seqno_to_time_mapping cached for the new SuperVersion as relevant.
-  void InstallSuperVersionForConfigChange(ColumnFamilyData* cfd,
+  void InstallSuperVersionAndScheduleWork(ColumnFamilyData* cfd,
                                          SuperVersionContext* sv_context);

  bool GetIntPropertyInternal(ColumnFamilyData* cfd,
@@ -2584,7 +2538,7 @@ class DBImpl : public DB {
  bool ShouldntRunManualCompaction(ManualCompactionState* m);
  bool HaveManualCompaction(ColumnFamilyData* cfd);
  bool MCOverlap(ManualCompactionState* m, ManualCompactionState* m1);
-  void UpdateFIFOCompactionStatus(const std::unique_ptr<Compaction>& c);
+  void UpdateDeletionCompactionStats(const std::unique_ptr<Compaction>& c);

  // May open and read table files for table property.
  // Should not be called while holding mutex_.
@@ -2734,13 +2688,8 @@ class DBImpl : public DB {
      const std::vector<ColumnFamilyHandle*>& column_families,
      ErrorIteratorFuncType error_iterator_func);

-  bool ShouldPickCompaction(bool is_prepicked,
-                            const PrepickedCompaction* prepicked_compaction);
-
-  void ResetBottomPriCompactionIntent(ColumnFamilyData* cfd,
-                                      std::unique_ptr<Compaction>& c);
  // Lock over the persistent DB state.  Non-nullptr iff successfully acquired.
-  FileLock* db_lock_ = nullptr;
+  FileLock* db_lock_;

  // Guards changes to DB and CF options to ensure consistency between
  // * In-memory options objects
@@ -2754,20 +2703,20 @@ class DBImpl : public DB {
  // Guards reads and writes to in-memory stats_history_.
  InstrumentedMutex stats_history_mutex_;

-  // In addition to mutex_, wal_write_mutex_ protects writes to logs_ and
-  // cur_wal_number_. With two_write_queues it also protects alive_wal_files_,
-  // and wal_empty_. Refer to the definition of each variable below for more
+  // In addition to mutex_, log_write_mutex_ protects writes to logs_ and
+  // logfile_number_. With two_write_queues it also protects alive_log_files_,
+  // and log_empty_. Refer to the definition of each variable below for more
  // details.
-  // Note: to avoid deadlock, if needed to acquire both wal_write_mutex_ and
-  // mutex_, the order should be first mutex_ and then wal_write_mutex_.
-  InstrumentedMutex wal_write_mutex_;
+  // Note: to avoid deadlock, if needed to acquire both log_write_mutex_ and
+  // mutex_, the order should be first mutex_ and then log_write_mutex_.
+  InstrumentedMutex log_write_mutex_;

  // If zero, manual compactions are allowed to proceed. If non-zero, manual
  // compactions may still be running, but will quickly fail with
  // `Status::Incomplete`. The value indicates how many threads have paused
  // manual compactions. It is accessed in read mode outside the DB mutex in
  // compaction code paths.
-  std::atomic<int> manual_compaction_paused_ = false;
+  std::atomic<int> manual_compaction_paused_;

  // This condition variable is signaled on these conditions:
  // * whenever bg_compaction_scheduled_ goes down to 0
@@ -2783,114 +2732,106 @@ class DBImpl : public DB {
  // * whenever SetOptions successfully updates options.
  // * whenever a column family is dropped.
  InstrumentedCondVar bg_cv_;
-
-  ColumnFamilyHandleImpl* persist_stats_cf_handle_ = nullptr;
-
-  bool persistent_stats_cfd_exists_ = true;
-
-  // Writes are protected by locking both mutex_ and wal_write_mutex_, and reads
-  // must be under either mutex_ or wal_write_mutex_. Since after ::Open,
-  // cur_wal_number_ is currently updated only in write_thread_, it can be read
+  // Writes are protected by locking both mutex_ and log_write_mutex_, and reads
+  // must be under either mutex_ or log_write_mutex_. Since after ::Open,
+  // logfile_number_ is currently updated only in write_thread_, it can be read
  // from the same write_thread_ without any locks.
-  uint64_t cur_wal_number_ = 0;
-
+  uint64_t logfile_number_;
  // Log files that we can recycle. Must be protected by db mutex_.
-  std::deque<uint64_t> wal_recycle_files_;
-
+  std::deque<uint64_t> log_recycle_files_;
  // The minimum log file number taht can be recycled, if log recycling is
  // enabled. This is used to ensure that log files created by previous
  // instances of the database are not recycled, as we cannot be sure they
  // were created in the recyclable format.
-  uint64_t min_wal_number_to_recycle_ = 0;
-
-  // Protected by wal_write_mutex_.
-  bool wal_dir_synced_ = false;
-
-  // Without two_write_queues, read and writes to wal_empty_ are protected by
+  uint64_t min_log_number_to_recycle_;
+  // Protected by log_write_mutex_.
+  bool log_dir_synced_;
+  // Without two_write_queues, read and writes to log_empty_ are protected by
  // mutex_. Since it is currently updated/read only in write_thread_, it can be
  // accessed from the same write_thread_ without any locks. With
  // two_write_queues writes, where it can be updated in different threads,
-  // read and writes are protected by wal_write_mutex_ instead. This is to avoid
-  // expensive mutex_ lock during WAL write, which update wal_empty_.
-  bool wal_empty_ = true;
+  // read and writes are protected by log_write_mutex_ instead. This is to avoid
+  // expensive mutex_ lock during WAL write, which update log_empty_.
+  bool log_empty_;
+
+  ColumnFamilyHandleImpl* persist_stats_cf_handle_;
+
+  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_wal_files_
-  // is protected by mutex_ and wal_write_mutex_ with details as follows:
+  // 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:
  // 1. read by FindObsoleteFiles() which can be called in either application
-  //    thread or RocksDB bg threads, both mutex_ and wal_write_mutex_ are
+  //    thread or RocksDB bg threads, both mutex_ and log_write_mutex_ are
  //    held.
-  // 2. pop_front() by FindObsoleteFiles(), both mutex_ and wal_write_mutex_
+  // 2. pop_front() by FindObsoleteFiles(), both mutex_ and log_write_mutex_
  //    are held.
  // 3. push_back() by DBImpl::Open() and DBImpl::RestoreAliveLogFiles()
  //    (actually called by Open()), only mutex_ is held because at this point,
  //    the DB::Open() call has not returned success to application, and the
  //    only other thread(s) that can conflict are bg threads calling
-  //    FindObsoleteFiles() which ensure that both mutex_ and wal_write_mutex_
-  //    are held when accessing alive_wal_files_.
+  //    FindObsoleteFiles() which ensure that both mutex_ and log_write_mutex_
+  //    are held when accessing alive_log_files_.
  // 4. read by DBImpl::Open() is protected by mutex_.
-  // 5. push_back() by SwitchMemtable(). Both mutex_ and wal_write_mutex_ are
+  // 5. push_back() by SwitchMemtable(). Both mutex_ and log_write_mutex_ are
  //    held. This is done by the write group leader. Note that in the case of
  //    two-write-queues, another WAL-only write thread can be writing to the
  //    WAL concurrently. See 9.
-  // 6. read by SwitchWAL() with both mutex_ and wal_write_mutex_ held. This is
+  // 6. read by SwitchWAL() with both mutex_ and log_write_mutex_ held. This is
  //    done by write group leader.
  // 7. read by ConcurrentWriteToWAL() by the write group leader in the case of
-  //    two-write-queues. Only wal_write_mutex_ is held to protect concurrent
+  //    two-write-queues. Only log_write_mutex_ is held to protect concurrent
  //    pop_front() by FindObsoleteFiles().
-  // 8. read by PreprocessWrite() by the write group leader. wal_write_mutex_
+  // 8. read by PreprocessWrite() by the write group leader. log_write_mutex_
  //    is held to protect the data structure from concurrent pop_front() by
  //    FindObsoleteFiles().
  // 9. read by ConcurrentWriteToWAL() by a WAL-only write thread in the case
-  //    of two-write-queues. Only wal_write_mutex_ is held. This suffices to
+  //    of two-write-queues. Only log_write_mutex_ is held. This suffices to
  //    protect the data structure from concurrent push_back() by current
  //    write group leader as well as pop_front() by FindObsoleteFiles().
-  std::deque<WalFileNumberSize> alive_wal_files_;
-
-  // Total size of all "alive" WALs (for easy access without synchronization)
-  RelaxedAtomic<uint64_t> wals_total_size_{0};
+  std::deque<LogFileNumberSize> alive_log_files_;

  // Log files that aren't fully synced, and the current log file.
  // Synchronization:
  // 1. read by FindObsoleteFiles() which can be called either in application
-  //    thread or RocksDB bg threads. wal_write_mutex_ is always held, while
+  //    thread or RocksDB bg threads. log_write_mutex_ is always held, while
  //    some reads are performed without mutex_.
-  // 2. pop_front() by FindObsoleteFiles() with only wal_write_mutex_ held.
-  // 3. read by DBImpl::Open() with both mutex_ and wal_write_mutex_.
-  // 4. emplace_back() by DBImpl::Open() with both mutex_ and wal_write_mutex.
+  // 2. pop_front() by FindObsoleteFiles() with only log_write_mutex_ held.
+  // 3. read by DBImpl::Open() with both mutex_ and log_write_mutex_.
+  // 4. emplace_back() by DBImpl::Open() with both mutex_ and log_write_mutex.
  //    Note that at this point, DB::Open() has not returned success to
  //    application, thus the only other thread(s) that can conflict are bg
  //    threads calling FindObsoleteFiles(). See 1.
-  // 5. iteration and clear() from CloseHelper() always hold wal_write_mutex
+  // 5. iteration and clear() from CloseHelper() always hold log_write_mutex
  //    and mutex_.
  // 6. back() called by APIs FlushWAL() and LockWAL() are protected by only
-  //    wal_write_mutex_. These two can be called by application threads after
+  //    log_write_mutex_. These two can be called by application threads after
  //    DB::Open() returns success to applications.
-  // 7. read by SyncWAL(), another API, protected by only wal_write_mutex_.
+  // 7. read by SyncWAL(), another API, protected by only log_write_mutex_.
  // 8. read by MarkLogsNotSynced() and MarkLogsSynced() are protected by
-  //    wal_write_mutex_.
-  // 9. erase() by MarkLogsSynced() protected by wal_write_mutex_.
-  // 10. read by SyncClosedWals() protected by only wal_write_mutex_. This can
+  //    log_write_mutex_.
+  // 9. erase() by MarkLogsSynced() protected by log_write_mutex_.
+  // 10. read by SyncClosedWals() 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()
-  //     holds only the wal_write_mutex_. This is done by the write group
+  //     holds only the log_write_mutex_. This is done by the write group
  //     leader. A bg thread calling FindObsoleteFiles() or MarkLogsSynced()
-  //     can happen concurrently. This is fine because wal_write_mutex_ is used
+  //     can happen concurrently. This is fine because log_write_mutex_ is used
  //     by all parties. See 2, 5, 9.
  // 12. reads, empty(), back() called by SwitchMemtable() hold both mutex_ and
-  //     wal_write_mutex_. This happens in the write group leader.
+  //     log_write_mutex_. This happens in the write group leader.
  // 13. emplace_back() by SwitchMemtable() hold both mutex_ and
-  //     wal_write_mutex_. This happens in the write group leader. Can conflict
+  //     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
  //     FlushWAL(), SyncWAL(), LockWAL(). This is fine because all parties
-  //     require at least wal_write_mutex_.
+  //     require at least log_write_mutex_.
  // 14. iteration called in WriteToWAL(write_group) protected by
-  //     wal_write_mutex_. This is done by write group leader when
+  //     log_write_mutex_. This is done by write group leader when
  //     two-write-queues is disabled and write needs to sync logs.
-  // 15. back() called in ConcurrentWriteToWAL() protected by wal_write_mutex_.
+  // 15. back() called in ConcurrentWriteToWAL() protected by log_write_mutex_.
  //     This can be done by the write group leader if two-write-queues is
  //     enabled. It can also be done by another WAL-only write thread.
  //
@@ -2907,22 +2848,23 @@ class DBImpl : public DB {
  std::deque<LogWriterNumber> logs_;

  // Signaled when getting_synced becomes false for some of the logs_.
-  InstrumentedCondVar wal_sync_cv_;
+  InstrumentedCondVar log_sync_cv_;
  // This is the app-level state that is written to the WAL but will be used
  // only during recovery. Using this feature enables not writing the state to
  // memtable on normal writes and hence improving the throughput. Each new
  // write of the state will replace the previous state entirely even if the
  // keys in the two consecutive states do not overlap.
-  // It is protected by wal_write_mutex_ when two_write_queues_ is enabled.
+  // It is protected by log_write_mutex_ when two_write_queues_ is enabled.
  // Otherwise only the heaad of write_thread_ can access it.
  WriteBatch cached_recoverable_state_;
  std::atomic<bool> cached_recoverable_state_empty_ = {true};
+  std::atomic<uint64_t> total_log_size_;

  // If this is non-empty, we need to delete these log files in background
-  // threads. Protected by wal_write_mutex_.
-  autovector<log::Writer*> wals_to_free_;
+  // threads. Protected by log_write_mutex_.
+  autovector<log::Writer*> logs_to_free_;

-  bool is_snapshot_supported_ = true;
+  bool is_snapshot_supported_;

  std::map<uint64_t, std::map<std::string, uint64_t>> stats_history_;

@@ -2946,7 +2888,7 @@ class DBImpl : public DB {
  // sleep if it uses up the quota.
  // Note: This is to protect memtable and compaction. If the batch only writes
  // to the WAL its size need not to be included in this.
-  uint64_t last_batch_group_size_ = 0;
+  uint64_t last_batch_group_size_;

  FlushScheduler flush_scheduler_;

@@ -3005,32 +2947,32 @@ class DBImpl : public DB {
  std::unordered_set<uint64_t> files_grabbed_for_purge_;

  // A queue to store log writers to close. Protected by db mutex_.
-  std::deque<log::Writer*> wals_to_free_queue_;
+  std::deque<log::Writer*> logs_to_free_queue_;

  std::deque<SuperVersion*> superversions_to_free_queue_;

-  int unscheduled_flushes_ = 0;
+  int unscheduled_flushes_;

-  int unscheduled_compactions_ = 0;
+  int unscheduled_compactions_;

  // count how many background compactions are running or have been scheduled in
  // the BOTTOM pool
-  int bg_bottom_compaction_scheduled_ = 0;
+  int bg_bottom_compaction_scheduled_;

  // count how many background compactions are running or have been scheduled
-  int bg_compaction_scheduled_ = 0;
+  int bg_compaction_scheduled_;

  // stores the number of compactions are currently running
-  int num_running_compactions_ = 0;
+  int num_running_compactions_;

  // number of background memtable flush jobs, submitted to the HIGH pool
-  int bg_flush_scheduled_ = 0;
+  int bg_flush_scheduled_;

  // stores the number of flushes are currently running
-  int num_running_flushes_ = 0;
+  int num_running_flushes_;

  // number of background obsolete file purge jobs, submitted to the HIGH pool
-  int bg_purge_scheduled_ = 0;
+  int bg_purge_scheduled_;

  std::deque<ManualCompactionState*> manual_compaction_dequeue_;

@@ -3040,11 +2982,11 @@ class DBImpl : public DB {
  // This enables two different threads to call
  // EnableFileDeletions() and DisableFileDeletions()
  // without any synchronization
-  int disable_delete_obsolete_files_ = 0;
+  int disable_delete_obsolete_files_;

  // Number of times FindObsoleteFiles has found deletable files and the
  // corresponding call to PurgeObsoleteFiles has not yet finished.
-  int pending_purge_obsolete_files_ = 0;
+  int pending_purge_obsolete_files_;

  // last time when DeleteObsoleteFiles with full scan was executed. Originally
  // initialized with startup time.
@@ -3056,12 +2998,12 @@ class DBImpl : public DB {
  // The mutex used by switch_cv_. mutex_ should be acquired beforehand.
  std::mutex switch_mutex_;
  // Number of threads intending to write to memtable
-  std::atomic<size_t> pending_memtable_writes_{0};
+  std::atomic<size_t> pending_memtable_writes_ = {};

  // A flag indicating whether the current rocksdb database has any
  // data that is not yet persisted into either WAL or SST file.
  // Used when disableWAL is true.
-  std::atomic<bool> has_unpersisted_data_{false};
+  std::atomic<bool> has_unpersisted_data_;

  // if an attempt was made to flush all column families that
  // the oldest log depends on but uncommitted data in the oldest
@@ -3069,26 +3011,26 @@ class DBImpl : public DB {
  // We must attempt to free the dependent memtables again
  // at a later time after the transaction in the oldest
  // log is fully commited.
-  bool unable_to_release_oldest_log_{false};
+  bool unable_to_release_oldest_log_;

  // Number of running IngestExternalFile() or CreateColumnFamilyWithImport()
  // calls.
  // REQUIRES: mutex held
-  int num_running_ingest_file_ = 0;
+  int num_running_ingest_file_;

  WalManager wal_manager_;

  // A value of > 0 temporarily disables scheduling of background work
-  int bg_work_paused_ = 0;
+  int bg_work_paused_;

  // A value of > 0 temporarily disables scheduling of background compaction
-  int bg_compaction_paused_ = 0;
+  int bg_compaction_paused_;

  // Guard against multiple concurrent refitting
-  bool refitting_level_ = false;
+  bool refitting_level_;

  // Indicate DB was opened successfully
-  bool opened_successfully_ = false;
+  bool opened_successfully_;

  // The min threshold to triggere bottommost compaction for removing
  // garbages, among all column families.
@@ -3134,13 +3076,13 @@ class DBImpl : public DB {
  // error recovery from going on in parallel. The latter, shutting_down_,
  // is set a little later during the shutdown after scheduling memtable
  // flushes
-  std::atomic<bool> shutdown_initiated_{false};
+  std::atomic<bool> shutdown_initiated_;
  // Flag to indicate whether sst_file_manager object was allocated in
  // DB::Open() or passed to us
  bool own_sfm_;

  // Flag to check whether Close() has been called on this DB
-  bool closed_ = false;
+  bool closed_;
  // save the closing status, for re-calling the close()
  Status closing_status_;
  // mutex for DB::Close()
@@ -3176,7 +3118,7 @@ class DBImpl : public DB {

  // The number of LockWAL called without matching UnlockWAL call.
  // See also lock_wal_write_token_
-  uint32_t lock_wal_count_ = 0;
+  uint32_t lock_wal_count_;
 };

 class GetWithTimestampReadCallback : public ReadCallback {
@@ -13,14 +13,12 @@
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/event_helpers.h"
-#include "file/file_util.h"
 #include "file/sst_file_manager_impl.h"
 #include "logging/logging.h"
 #include "monitoring/iostats_context_imp.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/thread_status_updater.h"
 #include "monitoring/thread_status_util.h"
-#include "options/options_helper.h"
 #include "rocksdb/file_system.h"
 #include "rocksdb/io_status.h"
 #include "rocksdb/options.h"
@@ -145,7 +143,10 @@ IOStatus DBImpl::SyncClosedWals(const WriteOptions& write_options,
 Status DBImpl::FlushMemTableToOutputFile(
    ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options,
    bool* made_progress, JobContext* job_context, FlushReason flush_reason,
-    SuperVersionContext* superversion_context, LogBuffer* log_buffer,
+    SuperVersionContext* superversion_context,
+    std::vector<SequenceNumber>& snapshot_seqs,
+    SequenceNumber earliest_write_conflict_snapshot,
+    SnapshotChecker* snapshot_checker, LogBuffer* log_buffer,
    Env::Priority thread_pri) {
  mutex_.AssertHeld();
  assert(cfd);
@@ -167,7 +168,7 @@ Status DBImpl::FlushMemTableToOutputFile(
  // 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 =
-      cur_wal_number_ > 0 &&
+      logfile_number_ > 0 &&
      (versions_->GetColumnFamilySet()->NumberOfColumnFamilies() > 1 ||
       allow_2pc());

@@ -209,6 +210,7 @@ Status DBImpl::FlushMemTableToOutputFile(
  FlushJob flush_job(
      dbname_, cfd, immutable_db_options_, mutable_cf_options, max_memtable_id,
      file_options_for_compaction_, versions_.get(), &mutex_, &shutting_down_,
+      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
      job_context, flush_reason, log_buffer, directories_.GetDbDir(),
      GetDataDir(cfd, 0U),
      GetCompressionFlush(cfd->ioptions(), mutable_cf_options), stats_,
@@ -222,7 +224,7 @@ 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 wal_write_mutex multiple
+    // SyncClosedWals() may unlock and re-lock the log_write_mutex multiple
    // times.
    VersionEdit synced_wals;
    bool error_recovery_in_prog = error_handler_.IsRecoveryInProgress();
@@ -393,8 +395,11 @@ Status DBImpl::FlushMemTablesToOutputFiles(
        bg_flush_args, made_progress, job_context, log_buffer, thread_pri);
  }
  assert(bg_flush_args.size() == 1);
-  InitSnapshotContext(job_context);
-
+  std::vector<SequenceNumber> snapshot_seqs;
+  SequenceNumber earliest_write_conflict_snapshot;
+  SnapshotChecker* snapshot_checker;
+  GetSnapshotContext(job_context, &snapshot_seqs,
+                     &earliest_write_conflict_snapshot, &snapshot_checker);
  const auto& bg_flush_arg = bg_flush_args[0];
  ColumnFamilyData* cfd = bg_flush_arg.cfd_;
  // intentional infrequent copy for each flush
@@ -405,7 +410,8 @@ Status DBImpl::FlushMemTablesToOutputFiles(
  FlushReason flush_reason = bg_flush_arg.flush_reason_;
  Status s = FlushMemTableToOutputFile(
      cfd, mutable_cf_options_copy, made_progress, job_context, flush_reason,
-      superversion_context, log_buffer, thread_pri);
+      superversion_context, snapshot_seqs, earliest_write_conflict_snapshot,
+      snapshot_checker, log_buffer, thread_pri);
  return s;
 }

@@ -440,7 +446,12 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
  }
 #endif /* !NDEBUG */

-  InitSnapshotContext(job_context);
+  std::vector<SequenceNumber> snapshot_seqs;
+  SequenceNumber earliest_write_conflict_snapshot;
+  SnapshotChecker* snapshot_checker;
+  GetSnapshotContext(job_context, &snapshot_seqs,
+                     &earliest_write_conflict_snapshot, &snapshot_checker);
+
  autovector<FSDirectory*> distinct_output_dirs;
  autovector<std::string> distinct_output_dir_paths;
  std::vector<std::unique_ptr<FlushJob>> jobs;
@@ -474,7 +485,8 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
    jobs.emplace_back(new FlushJob(
        dbname_, cfd, immutable_db_options_, mutable_cf_options,
        max_memtable_id, file_options_for_compaction_, versions_.get(), &mutex_,
-        &shutting_down_, job_context, flush_reason, log_buffer,
+        &shutting_down_, snapshot_seqs, earliest_write_conflict_snapshot,
+        snapshot_checker, job_context, flush_reason, log_buffer,
        directories_.GetDbDir(), data_dir,
        GetCompressionFlush(cfd->ioptions(), mutable_cf_options), stats_,
        &event_logger_, mutable_cf_options.report_bg_io_stats,
@@ -500,7 +512,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
                       job_context->job_id, flush_reason);
  }

-  if (cur_wal_number_ > 0) {
+  if (logfile_number_ > 0) {
    // TODO (yanqin) investigate whether we should sync the closed logs for
    // single column family case.
    VersionEdit synced_wals;
@@ -516,7 +528,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(

    if (!log_io_s.ok() && !log_io_s.IsShutdownInProgress() &&
        !log_io_s.IsColumnFamilyDropped()) {
-      if (wals_total_size_.LoadRelaxed() > 0) {
+      if (total_log_size_ > 0) {
        error_handler_.SetBGError(log_io_s, BackgroundErrorReason::kFlush);
      } else {
        // If the WAL is empty, we use different error reason
@@ -969,8 +981,7 @@ Status DBImpl::CompactRange(const CompactRangeOptions& options,

  std::string begin_str, end_str;
  auto [begin, end] =
-      MaybeAddTimestampsToRange(OptSlice::CopyFromPtr(begin_without_ts),
-                                OptSlice::CopyFromPtr(end_without_ts), ts_sz,
+      MaybeAddTimestampsToRange(begin_without_ts, end_without_ts, ts_sz,
                                &begin_str, &end_str, false /*exclusive_end*/);

  return CompactRangeInternal(
@@ -1381,9 +1392,6 @@ Status DBImpl::CompactFiles(const CompactionOptions& compact_options,
  TEST_SYNC_POINT_CALLBACK("TestCompactFiles:PausingManualCompaction:3",
                           static_cast<void*>(const_cast<std::atomic<int>*>(
                               &manual_compaction_paused_)));
-  TEST_SYNC_POINT_CALLBACK("TestCancelCompactFiles:SuccessfulCompaction",
-                           static_cast<void*>(const_cast<std::atomic<int>*>(
-                               &manual_compaction_paused_)));
  {
    InstrumentedMutexLock l(&mutex_);
    auto* current = cfd->current();
@@ -1436,12 +1444,7 @@ Status DBImpl::CompactFilesImpl(
  if (shutting_down_.load(std::memory_order_acquire)) {
    return Status::ShutdownInProgress();
  }
-
-  // triggered by DisableManualCompactions or by user-set canceled flag in
-  // CompactionOptions
-  if (manual_compaction_paused_.load(std::memory_order_acquire) > 0 ||
-      (compact_options.canceled &&
-       compact_options.canceled->load(std::memory_order_acquire))) {
+  if (manual_compaction_paused_.load(std::memory_order_acquire) > 0) {
    return Status::Incomplete(Status::SubCode::kManualCompactionPaused);
  }

@@ -1512,7 +1515,11 @@ Status DBImpl::CompactFilesImpl(
  // deletion compaction currently not allowed in CompactFiles.
  assert(!c->deletion_compaction());

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

  std::unique_ptr<std::list<uint64_t>::iterator> pending_outputs_inserted_elem(
      new std::list<uint64_t>::iterator(
@@ -1526,6 +1533,7 @@ Status DBImpl::CompactFilesImpl(
      log_buffer, directories_.GetDbDir(),
      GetDataDir(c->column_family_data(), c->output_path_id()),
      GetDataDir(c->column_family_data(), 0), stats_, &mutex_, &error_handler_,
+      snapshot_seqs, earliest_write_conflict_snapshot, snapshot_checker,
      job_context, table_cache_, &event_logger_,
      c->mutable_cf_options().paranoid_file_checks,
      c->mutable_cf_options().report_bg_io_stats, dbname_,
@@ -1687,13 +1695,11 @@ void DBImpl::NotifyOnCompactionBegin(ColumnFamilyData* cfd, Compaction* c,
  }

  c->SetNotifyOnCompactionCompleted();
-  int num_l0_files = c->input_version()->storage_info()->NumLevelFiles(0);
  // release lock while notifying events
  mutex_.Unlock();
  TEST_SYNC_POINT("DBImpl::NotifyOnCompactionBegin::UnlockMutex");
  {
    CompactionJobInfo info{};
-    info.num_l0_files = num_l0_files;
    BuildCompactionJobInfo(cfd, c, st, job_stats, job_id, &info);
    for (const auto& listener : immutable_db_options_.listeners) {
      listener->OnCompactionBegin(this, info);
@@ -1718,13 +1724,11 @@ void DBImpl::NotifyOnCompactionCompleted(
    return;
  }

-  int num_l0_files = cfd->current()->storage_info()->NumLevelFiles(0);
  // release lock while notifying events
  mutex_.Unlock();
  TEST_SYNC_POINT("DBImpl::NotifyOnCompactionCompleted::UnlockMutex");
  {
    CompactionJobInfo info{};
-    info.num_l0_files = num_l0_files;
    BuildCompactionJobInfo(cfd, c, st, compaction_job_stats, job_id, &info);
    for (const auto& listener : immutable_db_options_.listeners) {
      listener->OnCompactionCompleted(this, info);
@@ -1849,9 +1853,10 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
        0 /* max_subcompactions, not applicable */,
        {} /* grandparents, not applicable */,
        std::nullopt /* earliest_snapshot */, nullptr /* snapshot_checker */,
-        CompactionReason::kRefitLevel, "" /* trim_ts */,
-        -1 /* score, not applicable */,
-        false /* l0_files_might_overlap, not applicable */));
+        false /* is manual */, "" /* trim_ts */, -1 /* score, not applicable */,
+        false /* is deletion compaction, not applicable */,
+        false /* l0_files_might_overlap, not applicable */,
+        CompactionReason::kRefitLevel));
    cfd->compaction_picker()->RegisterCompaction(c.get());
    TEST_SYNC_POINT("DBImpl::ReFitLevel:PostRegisterCompaction");
    VersionEdit edit;
@@ -2177,7 +2182,6 @@ Status DBImpl::RunManualCompaction(
        // Don't throttle manual compaction, only count outstanding tasks.
        assert(false);
      }
-      ca->prepicked_compaction->need_repick = false;
      manual.incomplete = false;
      if (compaction->bottommost_level() &&
          env_->GetBackgroundThreads(Env::Priority::BOTTOM) > 0) {
@@ -2707,10 +2711,6 @@ Status DBImpl::WaitUntilFlushWouldNotStallWrites(ColumnFamilyData* cfd,
 // Finish waiting when ALL column families finish flushing memtables.
 // resuming_from_bg_err indicates whether the caller is trying to resume from
 // background error or in normal processing.
-// Note that the wait finishes when the flush result is installed to column
-// families' Versions and persisted in MANIFEST. It doesn't wait until
-// SuperVersion to reflect the flush result, except for the case when
-// flush_reason is `kExternalFileIngestion`.
 Status DBImpl::WaitForFlushMemTables(
    const autovector<ColumnFamilyData*>& cfds,
    const autovector<const uint64_t*>& flush_memtable_ids,
@@ -3404,10 +3404,6 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
  bool made_progress = false;
  JobContext job_context(next_job_id_.fetch_add(1), true);
  TEST_SYNC_POINT("BackgroundCallCompaction:0");
-  if (bg_thread_pri == Env::Priority::BOTTOM) {
-    TEST_SYNC_POINT("BackgroundCallCompaction:0:BottomPri");
-  }
-
  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL,
                       immutable_db_options_.info_log.get());
  {
@@ -3643,54 +3639,34 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                 : m->manual_end->DebugString(true).c_str()));
      }
    }
-  } else if (ShouldPickCompaction(is_prepicked, prepicked_compaction)) {
-    bool need_repick = is_prepicked && prepicked_compaction->need_repick;
+  } else if (!is_prepicked && !compaction_queue_.empty()) {
    if (HasExclusiveManualCompaction()) {
+      // Can't compact right now, but try again later
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction()::Conflict");

-      // TODO(hx235): Resolve conflict between intended
-      // bottom-priority compaction (requiring repick, i.e., need_repick = true)
-      // and exclusive manual compaction by releasing the intended
-      // bottom-priority compaction.
-      if (!need_repick) {
-        // Can't compact right now, but try again later
-        //
-        // Increase `unscheduled_compactions_` directly so we
-        // don't need to
-        // dequeue and enqueue the CFD again in the compaction queue and thus
-        // keep the CFD's position in the queue
-        unscheduled_compactions_++;
+      // Stay in the compaction queue.
+      unscheduled_compactions_++;

-        return Status::OK();
-      }
+      return Status::OK();
    }

-    ColumnFamilyData* cfd = nullptr;
+    auto cfd = PickCompactionFromQueue(&task_token, log_buffer);
+    if (cfd == nullptr) {
+      // Can't find any executable task from the compaction queue.
+      // All tasks have been throttled by compaction thread limiter.
+      ++unscheduled_compactions_;
+      return Status::Busy();
+    }

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

    // Pick up latest mutable CF Options and use it throughout the
@@ -3704,24 +3680,21 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
      // compaction is not necessary. Need to make sure mutex is held
      // until we make a copy in the following code
      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():BeforePickCompaction");
+      SnapshotChecker* snapshot_checker = nullptr;
+      std::vector<SequenceNumber> snapshot_seqs;
      // This info is not useful for other scenarios, so save querying existing
      // snapshots for those cases.
      if (cfd->ioptions().compaction_style == kCompactionStyleUniversal &&
          cfd->user_comparator()->timestamp_size() == 0) {
-        InitSnapshotContext(job_context);
+        SequenceNumber earliest_write_conflict_snapshot;
+        GetSnapshotContext(job_context, &snapshot_seqs,
+                           &earliest_write_conflict_snapshot,
+                           &snapshot_checker);
        assert(is_snapshot_supported_ || snapshots_.empty());
      }
-      c.reset(cfd->PickCompaction(
-          mutable_cf_options, mutable_db_options_, job_context->snapshot_seqs,
-          job_context->snapshot_checker, log_buffer,
-          thread_pri == Env::Priority::BOTTOM /* require_max_output_level */));
-      if (thread_pri == Env::Priority::LOW) {
-        TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");
-      } else if (thread_pri == Env::Priority::BOTTOM) {
-        TEST_SYNC_POINT_CALLBACK(
-            "DBImpl::BackgroundCompaction():AfterPickCompactionBottomPri",
-            c.get());
-      }
+      c.reset(cfd->PickCompaction(mutable_cf_options, mutable_db_options_,
+                                  snapshot_seqs, snapshot_checker, log_buffer));
+      TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");

      if (c != nullptr) {
        bool enough_room = EnoughRoomForCompaction(
@@ -3735,7 +3708,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
              ->storage_info()
              ->ComputeCompactionScore(c->immutable_options(),
                                       c->mutable_cf_options());
-          EnqueuePendingCompaction(cfd);
+          AddToCompactionQueue(cfd);

          c.reset();
          // Don't need to sleep here, because BackgroundCallCompaction
@@ -3757,21 +3730,16 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
          // options take effect.
          // 3) When we Pick a new compaction, we "remove" those files being
          // compacted from the calculation, which then influences compaction
-          // score. Inside EnqueuePendingCompaction(),  we check if we need
-          // the new compaction even without the files that are currently being
-          // compacted. If we need another compaction, we might be able to
-          // execute it in parallel, so we add it to the queue and schedule a
-          // new thread.
-          EnqueuePendingCompaction(cfd);
-          MaybeScheduleFlushOrCompaction();
+          // score. Here we check if we need the new compaction even without the
+          // files that are currently being compacted. If we need another
+          // compaction, we might be able to execute it in parallel, so we add
+          // it to the queue and schedule a new thread.
+          if (cfd->NeedsCompaction()) {
+            // Yes, we need more compactions!
+            AddToCompactionQueue(cfd);
+            MaybeScheduleFlushOrCompaction();
+          }
        }
-      } else if (is_prepicked) {
-        ROCKS_LOG_BUFFER(
-            log_buffer,
-            "[%s] Pre-picked compaction repicked files for compaction as "
-            "required, "
-            "but upon re-evaluation, no compaction was found necessary \n",
-            cfd->GetName().c_str());
      }
    }
  }
@@ -3813,251 +3781,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                     c->column_family_data()->GetName().c_str(),
                     c->num_input_files(0));
    if (status.ok() && io_s.ok()) {
-      UpdateFIFOCompactionStatus(c);
+      UpdateDeletionCompactionStats(c);
    }
    *made_progress = true;
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:AfterCompaction",
                             c->column_family_data());
-  } else if (c->is_trivial_copy_compaction()) {
-    TEST_SYNC_POINT_CALLBACK(
-        "DBImpl::BackgroundCompaction:TriviaCopyBeforeCompaction",
-        c->column_family_data());
-    assert(c->num_input_files(1) == 0);
-    assert(c->column_family_data()->ioptions().compaction_style ==
-           kCompactionStyleFIFO);
-    assert(c->compaction_reason() == CompactionReason::kChangeTemperature);
-
-    compaction_job_stats.num_input_files = c->num_input_files(0);
-
-    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
-                            compaction_job_stats, job_context->job_id);
-
-    std::vector<FileMetaData> out_files;
-    for (const auto& in_file : *c->inputs(0)) {
-      const uint64_t out_file_number = versions_->NewFileNumber();
-      const std::string in_fname =
-          TableFileName(c->immutable_options().cf_paths,
-                        in_file->fd.GetNumber(), in_file->fd.GetPathId());
-      const std::string out_fname =
-          TableFileName(c->immutable_options().cf_paths, out_file_number,
-                        c->output_path_id());
-
-      // TODO (mikechuang): Currently skip calling
-      // EventHelpers::NotifyTableFileCreationStarted for the trivial copy.
-      // Since it's a trivial copy we should ideally use the exact
-      // TableProperties from the input file but that will break some existing
-      // stress tests. For now skip the listener call for the FIFO
-      // kChangeTemperature trivial copy move.
-
-      int64_t tmp_current_time = 0;
-      auto get_time_status =
-          immutable_db_options_.clock->GetCurrentTime(&tmp_current_time);
-      if (!get_time_status.ok()) {
-        ROCKS_LOG_BUFFER(log_buffer,
-                         "[%s] WARNING: Failed to get current time %s "
-                         "status=%s",
-                         c->column_family_data()->GetName().c_str(),
-                         get_time_status.ToString().c_str());
-      }
-      uint64_t out_file_creation_time = static_cast<uint64_t>(tmp_current_time);
-
-      FileOptions copied_file_options = file_options_;
-      copied_file_options.temperature = c->output_temperature();
-      std::unique_ptr<WritableFileWriter> dest_writer;
-      {
-        std::unique_ptr<FSWritableFile> dest_file;
-        IOStatus writable_file_io_status =
-            immutable_db_options_.fs.get()->NewWritableFile(
-                out_fname, copied_file_options, &dest_file, nullptr /* dbg */);
-        TEST_SYNC_POINT_CALLBACK(
-            "NewWritableFile::FileOptions.temperature",
-            const_cast<Temperature*>(&copied_file_options.temperature));
-        if (!writable_file_io_status.ok()) {
-          io_s = writable_file_io_status;
-          ROCKS_LOG_BUFFER(
-              log_buffer,
-              "[%s] Error: Abort trivial copy compaction, failed to open "
-              "NewWritableFile %s\n"
-              " out_fname=%s, temperature=%s, io_status=%s",
-              c->column_family_data()->GetName().c_str(), out_fname.c_str(),
-              temperature_to_string[c->output_temperature()].c_str(),
-              io_s.ToString().c_str());
-          break;
-        }
-
-        FileTypeSet tmp_set = immutable_db_options_.checksum_handoff_file_types;
-        dest_writer.reset(new WritableFileWriter(
-            std::move(dest_file), out_fname, copied_file_options,
-            immutable_db_options_.clock, io_tracer_,
-            immutable_db_options_.stats, Histograms::SST_WRITE_MICROS,
-            c->immutable_options().listeners,
-            immutable_db_options_.file_checksum_gen_factory.get(),
-            tmp_set.Contains(FileType::kTableFile), false));
-      }
-
-      ROCKS_LOG_BUFFER(
-          log_buffer,
-          "[%s] Started copying from: %s\n"
-          " temperature=%s, to: %s, temperature=%s, buffer_size=%" PRIu64,
-          c->column_family_data()->GetName().c_str(), in_fname.c_str(),
-          temperature_to_string[in_file->temperature].c_str(),
-          out_fname.c_str(),
-          temperature_to_string[c->output_temperature()].c_str(),
-          c->mutable_cf_options()
-              .compaction_options_fifo.trivial_copy_buffer_size);
-      // Add IO_LOW HINT for compaction
-      IOOptions copy_files_compaction_io_options;
-      copy_files_compaction_io_options.rate_limiter_priority =
-          Env::IOPriority::IO_LOW;
-      copy_files_compaction_io_options.type = IOType::kData;
-      copy_files_compaction_io_options.io_activity =
-          Env::IOActivity::kCompaction;
-
-      IOStatus copy_file_io_status = CopyFile(
-          immutable_db_options_.fs.get() /* fileSystem */,
-          in_fname /* source */, in_file->temperature /* src_temp_hint */,
-          dest_writer /* dest_writer */, 0 /* size */, true /* use_fsync */,
-          io_tracer_ /* io_tracer*/,
-          c->mutable_cf_options()
-              .compaction_options_fifo
-              .trivial_copy_buffer_size /* max_read_buffer_size
-                                         */
-          ,
-          copy_files_compaction_io_options /* readIOOptions */,
-          copy_files_compaction_io_options /* writeIOOptions */);
-      if (dest_writer) {
-        IOOptions close_files_compaction_io_options;
-        close_files_compaction_io_options.rate_limiter_priority =
-            Env::IOPriority::IO_LOW;
-        close_files_compaction_io_options.type = IOType::kData;
-        close_files_compaction_io_options.io_activity =
-            Env::IOActivity::kCompaction;
-        // Close the dest_write
-        io_s = dest_writer->Close(close_files_compaction_io_options);
-        if (!io_s.ok()) {
-          ROCKS_LOG_BUFFER(
-              log_buffer,
-              "[%s] Failed to close the writer. Failed to copy from: %s\n"
-              " temperature=%s, to=%s, temperature=%s, io_status=%s",
-              c->column_family_data()->GetName().c_str(), in_fname.c_str(),
-              temperature_to_string[in_file->temperature].c_str(),
-              out_fname.c_str(),
-              temperature_to_string[c->output_temperature()].c_str(),
-              io_s.ToString().c_str());
-          break;
-        }
-      }
-
-      io_s = copy_file_io_status;
-
-      if (!io_s.ok()) {
-        ROCKS_LOG_BUFFER(log_buffer,
-                         "[%s] Failed to copy from: %s\n"
-                         " temperature=%s, to=%s, temperature=%s, io_status=%s",
-                         c->column_family_data()->GetName().c_str(),
-                         in_fname.c_str(),
-                         temperature_to_string[in_file->temperature].c_str(),
-                         out_fname.c_str(),
-                         temperature_to_string[c->output_temperature()].c_str(),
-                         io_s.ToString().c_str());
-        break;
-      }
-      ROCKS_LOG_BUFFER(log_buffer,
-                       "[%s] Successfully copying from: %s\n"
-                       " temperature=%s, to=%s, temperature=%s, io_status=%s",
-                       c->column_family_data()->GetName().c_str(),
-                       in_fname.c_str(),
-                       temperature_to_string[in_file->temperature].c_str(),
-                       out_fname.c_str(),
-                       temperature_to_string[c->output_temperature()].c_str(),
-                       io_s.ToString().c_str());
-
-      FileMetaData out_file_metadata{
-          out_file_number,
-          c->output_path_id(),
-          in_file->fd.GetFileSize(),
-          in_file->smallest,
-          in_file->largest,
-          in_file->fd.smallest_seqno,
-          in_file->fd.largest_seqno,
-          false /* marked_for_compact */,
-          c->output_temperature() /* temperature */,
-          in_file->oldest_blob_file_number,
-          in_file->oldest_ancester_time,
-          out_file_creation_time,
-          c->MinInputFileEpochNumber(),
-          dest_writer->GetFileChecksum(),
-          dest_writer->GetFileChecksumFuncName(),
-          in_file->unique_id,
-          in_file->compensated_range_deletion_size,
-          in_file->tail_size,
-          in_file->user_defined_timestamps_persisted};
-
-      out_files.push_back(std::move(out_file_metadata));
-    }
-
-    // Update version set
-    if (status.ok() && io_s.ok()) {
-      // NOTE: ChangeTemperature should only copy one file at one file
-      // hence *c->inputs(0) == out_files.size() == 1 if copy succeeded
-      assert(c->inputs(0)->size() == 1);
-      assert(out_files.size() == 1);
-
-      auto out_file_metadata_it = out_files.begin();
-      for (const auto& in_file : *c->inputs(0)) {
-        if (out_file_metadata_it == out_files.end()) {
-          break;
-        }
-
-        c->edit()->DeleteFile(c->level(), in_file->fd.GetNumber());
-        c->edit()->AddFile(c->level(), *out_file_metadata_it);
-        ++out_file_metadata_it;
-      }
-
-      status = versions_->LogAndApply(
-          c->column_family_data(), read_options, write_options, c->edit(),
-          &mutex_, directories_.GetDbDir(),
-          /*new_descriptor_log=*/false, /*column_family_options=*/nullptr,
-          [&c, &compaction_released](const Status& s) {
-            c->ReleaseCompactionFiles(s);
-            compaction_released = true;
-          });
-    }
-
-    // TODO (mikechuang): Currently skip calling
-    // EventHelper::LogAndNotifyTableFileCreationFinished for the trivial copy.
-    // Since it's a trivial copy we should ideally use the exact TableProperties
-    // from the input file but that will break some existing stress tests. For
-    // now skip the listener call for the FIFO kChangeTemperature trivial copy
-    // move.
-
-    if (io_s.ok()) {
-      io_s = versions_->io_status();
-    }
-
-    InstallSuperVersionAndScheduleWork(
-        c->column_family_data(), job_context->superversion_contexts.data());
-    if (status.ok() && io_s.ok()) {
-      UpdateFIFOCompactionStatus(c);
-    } else {
-      for (const auto& in_file : *c->inputs(0)) {
-        const std::string in_fname =
-            TableFileName(c->immutable_options().cf_paths,
-                          in_file->fd.GetNumber(), in_file->fd.GetPathId());
-        ROCKS_LOG_BUFFER(
-            log_buffer,
-            "[%s] Failed to do trvial copy compaction: %s"
-            " temperature=%s, to temperature=%s, status=%s, io_status=%s",
-            c->column_family_data()->GetName().c_str(), in_fname.c_str(),
-            temperature_to_string[in_file->temperature].c_str(),
-            temperature_to_string[c->output_temperature()].c_str(),
-            status.ToString().c_str(), io_s.ToString().c_str());
-      }
-    }
-    *made_progress = true;
-    TEST_SYNC_POINT_CALLBACK(
-        "DBImpl::BackgroundCompaction:TriviaCopyAfterCompaction",
-        c->column_family_data());
  } else if (!trivial_move_disallowed && c->IsTrivialMove()) {
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:TrivialMove");
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:BeforeCompaction",
@@ -4070,8 +3798,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    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;
-    compaction_job_stats.num_input_files_trivially_moved =
-        compaction_job_stats.num_input_files;

    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                            compaction_job_stats, job_context->job_id);
@@ -4148,16 +3874,14 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    ThreadStatusUtil::ResetThreadStatus();
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:AfterCompaction",
                             c->column_family_data());
-  } else if (!is_prepicked &&
-             Compaction::OutputToNonZeroMaxOutputLevel(
-                 c->output_level(),
+  } else if (!is_prepicked && c->output_level() > 0 &&
+             c->output_level() ==
                 c->column_family_data()
                     ->current()
                     ->storage_info()
                     ->MaxOutputLevel(
-                         immutable_db_options_.allow_ingest_behind)) &&
+                         immutable_db_options_.allow_ingest_behind) &&
             env_->GetBackgroundThreads(Env::Priority::BOTTOM) > 0) {
-    assert(thread_pri == Env::Priority::LOW);
    // Forward compactions involving last level to the bottom pool if it exists,
    // such that compactions unlikely to contribute to write stalls can be
    // delayed or deprioritized.
@@ -4166,23 +3890,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    ca->db = this;
    ca->compaction_pri_ = Env::Priority::BOTTOM;
    ca->prepicked_compaction = new PrepickedCompaction;
-
-    // If `universal_reduce_file_locking` is true, we only lock a limited set of
-    // input files by creating an intended compaction to forward to bottom
-    // priority pool and repicking files when bottom priority thread
-    // gets to execute this intended compaction
-    const bool need_repick =
-        c->mutable_cf_options()
-            .compaction_options_universal.reduce_file_locking;
-    if (need_repick) {
-      ca->prepicked_compaction->compaction =
-          CreateIntendedCompactionForwardedToBottomPriorityPool(c.get());
-      c.reset();
-      ca->prepicked_compaction->need_repick = true;
-    } else {
-      ca->prepicked_compaction->compaction = c.release();
-      ca->prepicked_compaction->need_repick = false;
-    }
+    ca->prepicked_compaction->compaction = c.release();
    ca->prepicked_compaction->manual_compaction_state = nullptr;
    // Transfer requested token, so it doesn't need to do it again.
    ca->prepicked_compaction->task_token = std::move(task_token);
@@ -4197,7 +3905,11 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    output_level = c->output_level();
    TEST_SYNC_POINT_CALLBACK("DBImpl::BackgroundCompaction:NonTrivial",
                             &output_level);
-    InitSnapshotContext(job_context);
+    std::vector<SequenceNumber> snapshot_seqs;
+    SequenceNumber earliest_write_conflict_snapshot;
+    SnapshotChecker* snapshot_checker;
+    GetSnapshotContext(job_context, &snapshot_seqs,
+                       &earliest_write_conflict_snapshot, &snapshot_checker);
    assert(is_snapshot_supported_ || snapshots_.empty());

    CompactionJob compaction_job(
@@ -4206,7 +3918,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
        &shutting_down_, log_buffer, directories_.GetDbDir(),
        GetDataDir(c->column_family_data(), c->output_path_id()),
        GetDataDir(c->column_family_data(), 0), stats_, &mutex_,
-        &error_handler_, job_context, table_cache_, &event_logger_,
+        &error_handler_, snapshot_seqs, earliest_write_conflict_snapshot,
+        snapshot_checker, job_context, table_cache_, &event_logger_,
        c->mutable_cf_options().paranoid_file_checks,
        c->mutable_cf_options().report_bg_io_stats, dbname_,
        &compaction_job_stats, thread_pri, io_tracer_,
@@ -4226,15 +3939,8 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
    NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
                            compaction_job_stats, job_context->job_id);
    mutex_.Unlock();
-    if (thread_pri == Env::Priority::LOW) {
-      TEST_SYNC_POINT_CALLBACK(
-          "DBImpl::BackgroundCompaction:NonTrivial:BeforeRun", nullptr);
-    } else {
-      assert(thread_pri == Env::Priority::BOTTOM);
-      TEST_SYNC_POINT(
-          "DBImpl::BackgroundCompaction:NonTrivial:BeforeRunBottomPri");
-    }
-
+    TEST_SYNC_POINT_CALLBACK(
+        "DBImpl::BackgroundCompaction:NonTrivial:BeforeRun", nullptr);
    // Should handle error?
    compaction_job.Run().PermitUncheckedError();
    TEST_SYNC_POINT("DBImpl::BackgroundCompaction:NonTrivial:AfterRun");
@@ -4328,7 +4034,9 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
          ->storage_info()
          ->ComputeCompactionScore(c->immutable_options(),
                                   c->mutable_cf_options());
-      EnqueuePendingCompaction(cfd);
+      if (!cfd->queued_for_compaction()) {
+        AddToCompactionQueue(cfd);
+      }
    }
  }
  // this will unref its input_version and column_family_data
@@ -4373,72 +4081,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
  return status;
 }

-// Create an intended compaction to forward based on the original picked
-// compaction. It serves two purposes while it is waiting
-// for a bottom-priority thread becomes available to run:
-// - Prevent the last input file (or sorted run if non-L0) from
-// being included in compaction score calculations unnecessarily since the
-// intended compaction is already scheduled to compact it
-// - Allow other input files to be picked by low-priority compactions that can
-// run right away
-//
-// Once a bottom-priority available to run this intended compaction, it will
-// repick files to consider the LSM updates that occurred during the waiting
-// period.
-Compaction* DBImpl::CreateIntendedCompactionForwardedToBottomPriorityPool(
-    Compaction* c) {
-  auto* cfd = c->column_family_data();
-  const auto& io = c->immutable_options();
-  const auto& mo = c->mutable_cf_options();
-  auto* vstorage = c->input_version()->storage_info();
-
-  std::vector<CompactionInputFiles> inputs(1);
-
-  const std::vector<FileMetaData*>* max_intput_level_files = nullptr;
-  int max_intput_level = 0;
-
-  for (size_t i = c->num_input_levels(); i >= 1; --i) {
-    size_t level = i - 1;
-    if (c->num_input_files(level) > 0) {
-      max_intput_level = static_cast<int>(level);
-      max_intput_level_files = c->inputs(level);
-      break;
-    }
-  }
-
-  assert(max_intput_level_files);
-  assert(!max_intput_level_files->empty());
-  inputs[0].level = max_intput_level;
-
-  if (max_intput_level == 0) {
-    // The last input file
-    inputs[0].files.push_back(
-        (*max_intput_level_files)[max_intput_level_files->size() - 1]);
-  } else {
-    // The last input sorted run
-    for (FileMetaData* f : (*max_intput_level_files)) {
-      inputs[0].files.push_back(f);
-    }
-  }
-
-  c->ReleaseCompactionFiles(Status::OK());
-
-  Compaction* intended_compaction =
-      new Compaction(vstorage, io, mo, mutable_db_options_, std::move(inputs),
-                     c->output_level(), c->target_output_file_size(),
-                     c->max_compaction_bytes(), c->output_path_id(),
-                     c->output_compression(), c->output_compression_opts(),
-                     c->output_temperature(), c->max_subcompactions(),
-                     c->grandparents(), std::nullopt /* earliest_snapshot */,
-                     nullptr /* snapshot_checker */, c->compaction_reason());
-
-  cfd->compaction_picker()->RegisterCompaction(intended_compaction);
-  vstorage->ComputeCompactionScore(io, mo);
-  intended_compaction->FinalizeInputInfo(cfd->current());
-
-  return intended_compaction;
-}
-
 bool DBImpl::HasPendingManualCompaction() {
  return (!manual_compaction_dequeue_.empty());
 }
@@ -4527,7 +4169,8 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {
  return false;
 }

-void DBImpl::UpdateFIFOCompactionStatus(const std::unique_ptr<Compaction>& c) {
+void DBImpl::UpdateDeletionCompactionStats(
+    const std::unique_ptr<Compaction>& c) {
  if (c == nullptr) {
    return;
  }
@@ -4541,9 +4184,6 @@ void DBImpl::UpdateFIFOCompactionStatus(const std::unique_ptr<Compaction>& c) {
    case CompactionReason::kFIFOTtl:
      RecordTick(stats_, FIFO_TTL_COMPACTIONS);
      break;
-    case CompactionReason::kChangeTemperature:
-      RecordTick(stats_, FIFO_CHANGE_TEMPERATURE_COMPACTIONS);
-      break;
    default:
      assert(false);
      break;
@@ -4633,10 +4273,9 @@ void DBImpl::BuildCompactionJobInfo(
 // for superversion_to_free

 void DBImpl::InstallSuperVersionAndScheduleWork(
-    ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-    std::optional<std::shared_ptr<SeqnoToTimeMapping>>
-        new_seqno_to_time_mapping) {
+    ColumnFamilyData* cfd, SuperVersionContext* sv_context) {
  mutex_.AssertHeld();
+  const auto& mutable_cf_options = cfd->GetLatestMutableCFOptions();

  // Update max_total_in_memory_state_
  size_t old_memtable_size = 0;
@@ -4650,8 +4289,7 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
  if (UNLIKELY(sv_context->new_superversion == nullptr)) {
    sv_context->NewSuperVersion();
  }
-  cfd->InstallSuperVersion(sv_context, &mutex_,
-                           std::move(new_seqno_to_time_mapping));
+  cfd->InstallSuperVersion(sv_context, mutable_cf_options);

  // There may be a small data race here. The snapshot tricking bottommost
  // compaction may already be released here. But assuming there will always be
@@ -4678,10 +4316,9 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
  MaybeScheduleFlushOrCompaction();

  // Update max_total_in_memory_state_
-  max_total_in_memory_state_ =
-      max_total_in_memory_state_ - old_memtable_size +
-      cfd->GetLatestMutableCFOptions().write_buffer_size *
-          cfd->GetLatestMutableCFOptions().max_write_buffer_number;
+  max_total_in_memory_state_ = max_total_in_memory_state_ - old_memtable_size +
+                               mutable_cf_options.write_buffer_size *
+                                   mutable_cf_options.max_write_buffer_number;
 }

 // ShouldPurge is called by FindObsoleteFiles when doing a full scan,
@@ -4710,33 +4347,31 @@ void DBImpl::SetSnapshotChecker(SnapshotChecker* snapshot_checker) {
  snapshot_checker_.reset(snapshot_checker);
 }

-void DBImpl::InitSnapshotContext(JobContext* job_context) {
+void DBImpl::GetSnapshotContext(
+    JobContext* job_context, std::vector<SequenceNumber>* snapshot_seqs,
+    SequenceNumber* earliest_write_conflict_snapshot,
+    SnapshotChecker** snapshot_checker_ptr) {
  mutex_.AssertHeld();
  assert(job_context != nullptr);
-  if (job_context->snapshot_context_initialized) {
-    return;
+  assert(snapshot_seqs != nullptr);
+  assert(earliest_write_conflict_snapshot != nullptr);
+  assert(snapshot_checker_ptr != nullptr);
+
+  *snapshot_checker_ptr = snapshot_checker_.get();
+  if (use_custom_gc_ && *snapshot_checker_ptr == nullptr) {
+    *snapshot_checker_ptr = DisableGCSnapshotChecker::Instance();
  }
-  SnapshotChecker* snapshot_checker = snapshot_checker_.get();
-  if (use_custom_gc_ && !snapshot_checker) {
-    snapshot_checker = DisableGCSnapshotChecker::Instance();
-  }
-  std::unique_ptr<ManagedSnapshot> managed_snapshot = nullptr;
-  if (snapshot_checker) {
+  if (*snapshot_checker_ptr != nullptr) {
    // If snapshot_checker is used, that means the flush/compaction may
    // contain values not visible to snapshot taken after
    // flush/compaction job starts. Take a snapshot and it will appear
    // in snapshot_seqs and force compaction iterator to consider such
    // snapshots.
-    const Snapshot* snapshot =
-        GetSnapshotImpl(/*is_write_conflict_boundary=*/false, /*lock=*/false);
-    managed_snapshot.reset(new ManagedSnapshot(this, snapshot));
+    const Snapshot* job_snapshot =
+        GetSnapshotImpl(false /*write_conflict_boundary*/, false /*lock*/);
+    job_context->job_snapshot.reset(new ManagedSnapshot(this, job_snapshot));
  }
-  SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber;
-  std::vector<SequenceNumber> snapshot_seqs =
-      snapshots_.GetAll(&earliest_write_conflict_snapshot);
-  job_context->InitSnapshotContext(
-      snapshot_checker, std::move(managed_snapshot),
-      earliest_write_conflict_snapshot, std::move(snapshot_seqs));
+  *snapshot_seqs = snapshots_.GetAll(earliest_write_conflict_snapshot);
 }

 Status DBImpl::WaitForCompact(
@@ -4795,18 +4430,4 @@ Status DBImpl::WaitForCompact(
  }
 }

-bool DBImpl::ShouldPickCompaction(
-    bool is_prepicked, const PrepickedCompaction* prepicked_compaction) {
-  return (!is_prepicked && !compaction_queue_.empty()) ||
-         (is_prepicked && prepicked_compaction->need_repick);
-}
-
-void DBImpl::ResetBottomPriCompactionIntent(ColumnFamilyData* cfd,
-                                            std::unique_ptr<Compaction>& c) {
-  c->ReleaseCompactionFiles(Status::OK());
-  cfd->current()->storage_info()->ComputeCompactionScore(
-      c->immutable_options(), c->mutable_cf_options());
-  c.reset();
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -84,7 +84,6 @@ void DBImpl::TEST_GetFilesMetaData(
 }

 uint64_t DBImpl::TEST_Current_Manifest_FileNo() {
-  InstrumentedMutexLock l(&mutex_);
  return versions_->manifest_file_number();
 }

@@ -225,13 +224,13 @@ void DBImpl::TEST_EndWrite(void* w) {
 }

 size_t DBImpl::TEST_LogsToFreeSize() {
-  InstrumentedMutexLock l(&wal_write_mutex_);
-  return wals_to_free_.size();
+  InstrumentedMutexLock l(&log_write_mutex_);
+  return logs_to_free_.size();
 }

 uint64_t DBImpl::TEST_LogfileNumber() {
  InstrumentedMutexLock l(&mutex_);
-  return cur_wal_number_;
+  return logfile_number_;
 }

 void DBImpl::TEST_GetAllBlockCaches(
@@ -380,13 +379,10 @@ void DBImpl::TEST_VerifyNoObsoleteFilesCached(
    uint64_t file_number;
    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
    // Assert file is in live/quarantined set
-    bool cached_file_is_live_or_quar =
-        live_and_quar_files.find(file_number) != live_and_quar_files.end();
-    if (!cached_file_is_live_or_quar) {
-      // Fail with useful info
+    if (live_and_quar_files.find(file_number) == live_and_quar_files.end()) {
      std::cerr << "File " << file_number << " is not live nor quarantined"
                << std::endl;
-      assert(cached_file_is_live_or_quar);
+      assert(false);
    }
  };
  table_cache_->ApplyToAllEntries(fn, {});
@@ -28,7 +28,7 @@ uint64_t DBImpl::MinLogNumberToKeep() {
  return versions_->min_log_number_to_keep();
 }

-uint64_t DBImpl::MinLogNumberToRecycle() { return min_wal_number_to_recycle_; }
+uint64_t DBImpl::MinLogNumberToRecycle() { return min_log_number_to_recycle_; }

 uint64_t DBImpl::MinObsoleteSstNumberToKeep() {
  mutex_.AssertHeld();
@@ -272,77 +272,77 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,

  // logs_ is empty when called during recovery, in which case there can't yet
  // be any tracked obsolete logs
-  wal_write_mutex_.Lock();
+  log_write_mutex_.Lock();

-  if (alive_wal_files_.empty() || logs_.empty()) {
+  if (alive_log_files_.empty() || logs_.empty()) {
    mutex_.AssertHeld();
    // We may reach here if the db is DBImplSecondary
-    wal_write_mutex_.Unlock();
+    log_write_mutex_.Unlock();
    return;
  }

  bool mutex_unlocked = false;
-  if (!alive_wal_files_.empty() && !logs_.empty()) {
+  if (!alive_log_files_.empty() && !logs_.empty()) {
    uint64_t min_log_number = job_context->log_number;
-    size_t num_alive_wal_files = alive_wal_files_.size();
+    size_t num_alive_log_files = alive_log_files_.size();
    // find newly obsoleted log files
-    while (alive_wal_files_.begin()->number < min_log_number) {
-      auto& earliest = *alive_wal_files_.begin();
+    while (alive_log_files_.begin()->number < min_log_number) {
+      auto& earliest = *alive_log_files_.begin();
      if (immutable_db_options_.recycle_log_file_num >
-              wal_recycle_files_.size() &&
+              log_recycle_files_.size() &&
          earliest.number >= MinLogNumberToRecycle()) {
        ROCKS_LOG_INFO(immutable_db_options_.info_log,
                       "adding log %" PRIu64 " to recycle list\n",
                       earliest.number);
-        wal_recycle_files_.push_back(earliest.number);
+        log_recycle_files_.push_back(earliest.number);
      } else {
        job_context->log_delete_files.push_back(earliest.number);
      }
      if (job_context->size_log_to_delete == 0) {
-        job_context->prev_wals_total_size = wals_total_size_.LoadRelaxed();
-        job_context->num_alive_wal_files = num_alive_wal_files;
+        job_context->prev_total_log_size = total_log_size_;
+        job_context->num_alive_log_files = num_alive_log_files;
      }
      job_context->size_log_to_delete += earliest.size;
-      wals_total_size_.FetchSubRelaxed(earliest.size);
-      alive_wal_files_.pop_front();
+      total_log_size_ -= earliest.size;
+      alive_log_files_.pop_front();

      // Current log should always stay alive since it can't have
      // number < MinLogNumber().
-      assert(alive_wal_files_.size());
+      assert(alive_log_files_.size());
    }
-    wal_write_mutex_.Unlock();
+    log_write_mutex_.Unlock();
    mutex_.Unlock();
    mutex_unlocked = true;
    TEST_SYNC_POINT_CALLBACK("FindObsoleteFiles::PostMutexUnlock", nullptr);
-    wal_write_mutex_.Lock();
+    log_write_mutex_.Lock();
    while (!logs_.empty() && logs_.front().number < min_log_number) {
      auto& log = logs_.front();
      if (log.IsSyncing()) {
-        wal_sync_cv_.Wait();
+        log_sync_cv_.Wait();
        // 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 wal_write_mutex_.
+      // 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();
-        wal_write_mutex_.Unlock();
+        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();
-        wal_write_mutex_.Lock();
+        log_write_mutex_.Lock();
        log.writer->PublishIfClosed();
        assert(&log == &logs_.front());
        log.FinishSync();
-        wal_sync_cv_.SignalAll();
+        log_sync_cv_.SignalAll();
      }
-      wals_to_free_.push_back(log.ReleaseWriter());
+      logs_to_free_.push_back(log.ReleaseWriter());
      logs_.pop_front();
    }
    // Current log cannot be obsolete.
@@ -350,16 +350,16 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
  }

  // We're just cleaning up for DB::Write().
-  assert(job_context->wals_to_free.empty());
-  job_context->wals_to_free = wals_to_free_;
+  assert(job_context->logs_to_free.empty());
+  job_context->logs_to_free = logs_to_free_;

-  wals_to_free_.clear();
-  wal_write_mutex_.Unlock();
+  logs_to_free_.clear();
+  log_write_mutex_.Unlock();
  if (mutex_unlocked) {
    mutex_.Lock();
  }
-  job_context->log_recycle_files.assign(wal_recycle_files_.begin(),
-                                        wal_recycle_files_.end());
+  job_context->log_recycle_files.assign(log_recycle_files_.begin(),
+                                        log_recycle_files_.end());
 }

 // Delete obsolete files and log status and information of file deletion
@@ -368,7 +368,6 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
                                    FileType type, uint64_t number) {
  TEST_SYNC_POINT_CALLBACK("DBImpl::DeleteObsoleteFileImpl::BeforeDeletion",
                           const_cast<std::string*>(&fname));
-  IGNORE_STATUS_IF_ERROR(Status::IOError());

  Status file_deletion_status;
  if (type == kTableFile || type == kBlobFile || type == kWalFile) {
@@ -424,14 +423,12 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
  // FindObsoleteFiles() should've populated this so nonzero
  assert(state.manifest_file_number != 0);

-  IGNORE_STATUS_IF_ERROR(Status::IOError());
-
  // Now, convert lists to unordered sets, WITHOUT mutex held; set is slow.
  std::unordered_set<uint64_t> sst_live_set(state.sst_live.begin(),
                                            state.sst_live.end());
  std::unordered_set<uint64_t> blob_live_set(state.blob_live.begin(),
                                             state.blob_live.end());
-  std::unordered_set<uint64_t> wal_recycle_files_set(
+  std::unordered_set<uint64_t> log_recycle_files_set(
      state.log_recycle_files.begin(), state.log_recycle_files.end());
  std::unordered_set<uint64_t> quarantine_files_set(
      state.files_to_quarantine.begin(), state.files_to_quarantine.end());
@@ -491,13 +488,13 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      std::unique(candidate_files.begin(), candidate_files.end()),
      candidate_files.end());

-  if (state.prev_wals_total_size > 0) {
+  if (state.prev_total_log_size > 0) {
    ROCKS_LOG_INFO(immutable_db_options_.info_log,
                   "[JOB %d] Try to delete WAL files size %" PRIu64
                   ", prev total WAL file size %" PRIu64
                   ", number of live WAL files %" ROCKSDB_PRIszt ".\n",
                   state.job_id, state.size_log_to_delete,
-                   state.prev_wals_total_size, state.num_alive_wal_files);
+                   state.prev_total_log_size, state.num_alive_log_files);
  }

  std::vector<std::string> old_info_log_files;
@@ -532,7 +529,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
  optsfile_num2 = std::min(optsfile_num2, state.min_options_file_number);

  // Close WALs before trying to delete them.
-  for (const auto w : state.wals_to_free) {
+  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({});
@@ -559,8 +556,8 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      case kWalFile:
        keep = ((number >= state.log_number) ||
                (number == state.prev_log_number) ||
-                (wal_recycle_files_set.find(number) !=
-                 wal_recycle_files_set.end()));
+                (log_recycle_files_set.find(number) !=
+                 log_recycle_files_set.end()));
        break;
      case kDescriptorFile:
        // Keep my manifest file, and any newer incarnations'
@@ -70,6 +70,9 @@ Status DBImplFollower::Recover(
    }
    return s;
  }
+  if (immutable_db_options_.paranoid_checks && s.ok()) {
+    s = CheckConsistency();
+  }
  if (s.ok()) {
    default_cf_handle_ = new ColumnFamilyHandleImpl(
        versions_->GetColumnFamilySet()->GetDefault(), this, &mutex_);
@@ -35,8 +35,8 @@ Options SanitizeOptions(const std::string& dbname, const Options& src,
  auto db_options =
      SanitizeOptions(dbname, DBOptions(src), read_only, logger_creation_s);
  ImmutableDBOptions immutable_db_options(db_options);
-  auto cf_options = SanitizeCfOptions(immutable_db_options, read_only,
-                                      ColumnFamilyOptions(src));
+  auto cf_options =
+      SanitizeOptions(immutable_db_options, ColumnFamilyOptions(src));
  return Options(db_options, cf_options);
 }

@@ -191,6 +191,12 @@ DBOptions SanitizeOptions(const std::string& dbname, const DBOptions& src,
                   "wal_compression is disabled since only zstd is supported");
  }

+  if (!result.paranoid_checks) {
+    result.skip_checking_sst_file_sizes_on_db_open = true;
+    ROCKS_LOG_INFO(result.info_log,
+                   "file size check will be skipped during open.");
+  }
+
  return result;
 }

@@ -688,6 +694,9 @@ Status DBImpl::Recover(
    s = MaybeUpdateNextFileNumber(recovery_ctx);
  }

+  if (immutable_db_options_.paranoid_checks && s.ok()) {
+    s = CheckConsistency();
+  }
  if (s.ok() && !read_only) {
    // TODO: share file descriptors (FSDirectory) with SetDirectories above
    std::map<std::string, std::shared_ptr<FSDirectory>> created_dirs;
@@ -1110,7 +1119,7 @@ void DBOpenLogRecordReadReporter::Corruption(size_t bytes, const Status& s,
                 static_cast<int>(bytes), s.ToString().c_str());
  if (status != nullptr && status->ok()) {
    *status = s;
-    corrupted_wal_number_ = log_number;
+    corrupted_log_number_ = log_number;
  }
 }

@@ -1194,13 +1203,6 @@ Status DBImpl::ProcessLogFiles(
  PredecessorWALInfo predecessor_wal_info;

  for (auto wal_number : wal_numbers) {
-    // Detecting early break on the next iteration after `wal_number` has been
-    // advanced since this `wal_number` doesn't affect follow-up handling after
-    // breaking out of the for loop.
-    if (!status.ok()) {
-      break;
-    }
-    SequenceNumber prev_next_sequence = *next_sequence;
    if (status.ok()) {
      status = ProcessLogFile(
          wal_number, min_wal_number, is_retry, read_only, job_id,
@@ -1208,10 +1210,6 @@ Status DBImpl::ProcessLogFiles(
          &stop_replay_by_wal_filter, &corrupted_wal_number,
          corrupted_wal_found, version_edits, &flushed, predecessor_wal_info);
    }
-    if (status.ok()) {
-      status = CheckSeqnoNotSetBackDuringRecovery(prev_next_sequence,
-                                                  *next_sequence);
-    }
  }

  if (status.ok()) {
@@ -1319,7 +1317,6 @@ Status DBImpl::ProcessLogFile(
    }

    // FIXME(hx235): consolidate `process_status` and `status`
-    SequenceNumber prev_next_sequence = *next_sequence;
    Status process_status = ProcessLogRecord(
        record, reader, running_ts_sz, wal_number, fname, read_only, job_id,
        logFileDropped, &reporter, &record_checksum, &last_seqno_observed,
@@ -1328,12 +1325,6 @@ Status DBImpl::ProcessLogFile(

    if (!process_status.ok()) {
      return process_status;
-    } else if (Status seqno_check_status = CheckSeqnoNotSetBackDuringRecovery(
-                   prev_next_sequence, *next_sequence);
-               !seqno_check_status.ok()) {
-      // Sequence number being set back indicates a serious software bug, the DB
-      // should not be opened in this case.
-      return seqno_check_status;
    } else if (*stop_replay_for_corruption) {
      break;
    }
@@ -1872,20 +1863,6 @@ Status DBImpl::MaybeFlushFinalMemtableOrRestoreActiveLogFiles(
  return status;
 }

-Status DBImpl::CheckSeqnoNotSetBackDuringRecovery(
-    SequenceNumber prev_next_seqno, SequenceNumber current_next_seqno) {
-  if (prev_next_seqno == kMaxSequenceNumber ||
-      prev_next_seqno <= current_next_seqno) {
-    return Status::OK();
-  }
-  std::string msg =
-      "Sequence number is being set backwards during recovery, this is likely "
-      "a software bug or a data corruption. Prev next seqno: " +
-      std::to_string(prev_next_seqno) +
-      " , current next seqno: " + std::to_string(current_next_seqno);
-  return Status::Corruption(msg);
-}
-
 void DBImpl::FinishLogFilesRecovery(int job_id, const Status& status) {
  event_logger_.Log() << "job" << job_id << "event"
                      << (status.ok() ? "recovery_finished" : "recovery_failed")
@@ -1893,8 +1870,8 @@ void DBImpl::FinishLogFilesRecovery(int job_id, const Status& status) {
 }

 Status DBImpl::GetLogSizeAndMaybeTruncate(uint64_t wal_number, bool truncate,
-                                          WalFileNumberSize* log_ptr) {
-  WalFileNumberSize log(wal_number);
+                                          LogFileNumberSize* log_ptr) {
+  LogFileNumberSize log(wal_number);
  std::string fname =
      LogFileName(immutable_db_options_.GetWalDir(), wal_number);
  Status s;
@@ -1937,27 +1914,27 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
  assert(immutable_db_options_.avoid_flush_during_recovery);
  // Mark these as alive so they'll be considered for deletion later by
  // FindObsoleteFiles()
-  wals_total_size_.StoreRelaxed(0);
-  wal_empty_ = false;
+  total_log_size_ = 0;
+  log_empty_ = false;
  uint64_t min_wal_with_unflushed_data =
      versions_->MinLogNumberWithUnflushedData();
  for (auto wal_number : wal_numbers) {
    if (!allow_2pc() && wal_number < min_wal_with_unflushed_data) {
      // In non-2pc mode, the WAL files not backing unflushed data are not
-      // alive, thus should not be added to the alive_wal_files_.
+      // alive, thus should not be added to the alive_log_files_.
      continue;
    }
    // We preallocate space for wals, but then after a crash and restart, those
    // preallocated space are not needed anymore. It is likely only the last
    // log has such preallocated space, so we only truncate for the last log.
-    WalFileNumberSize log;
+    LogFileNumberSize log;
    s = GetLogSizeAndMaybeTruncate(
        wal_number, /*truncate=*/(wal_number == wal_numbers.back()), &log);
    if (!s.ok()) {
      break;
    }
-    wals_total_size_.FetchAddRelaxed(log.size);
-    alive_wal_files_.push_back(log);
+    total_log_size_ += log.size;
+    alive_log_files_.push_back(log);
  }
  return s;
 }
@@ -1991,9 +1968,6 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
  const size_t ts_sz = ucmp->timestamp_size();
  const bool logical_strip_timestamp =
      ts_sz > 0 && !cfd->ioptions().persist_user_defined_timestamps;
-  // Note that here we treat flush as level 0 compaction in internal stats
-  InternalStats::CompactionStats flush_stats(CompactionReason::kFlush,
-                                             1 /* count */);
  {
    ScopedArenaPtr<InternalIterator> iter(
        logical_strip_timestamp
@@ -2021,9 +1995,8 @@ 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,
-          immutable_db_options_.calculate_sst_write_lifetime_hint_set);
+      auto write_hint =
+          cfd->current()->storage_info()->CalculateSSTWriteHint(/*level=*/0);
      mutex_.Unlock();

      SequenceNumber earliest_write_conflict_snapshot;
@@ -2066,20 +2039,19 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
          kMaxSequenceNumber);
      Version* version = cfd->current();
      version->Ref();
-      TableProperties temp_table_proerties;
-      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,
-          &temp_table_proerties /* table_properties */, write_hint,
-          nullptr /*full_history_ts_low*/, &blob_callback_, version,
-          nullptr /* memtable_payload_bytes */,
-          nullptr /* memtable_garbage_bytes */, &flush_stats);
+      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);
      version->Unref();
      LogFlush(immutable_db_options_.info_log);
      ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
@@ -2095,31 +2067,10 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
      }

      uint64_t total_num_entries = mem->NumEntries();
-      if (s.ok() && total_num_entries != flush_stats.num_input_records) {
+      if (s.ok() && total_num_entries != num_input_entries) {
        std::string msg = "Expected " + std::to_string(total_num_entries) +
                          " entries in memtable, but read " +
-                          std::to_string(flush_stats.num_input_records);
-        ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                       "[%s] [JOB %d] Level-0 flush during recover: %s",
-                       cfd->GetName().c_str(), job_id, msg.c_str());
-        if (immutable_db_options_.flush_verify_memtable_count) {
-          s = Status::Corruption(msg);
-        }
-      }
-      // Only verify on table with format collects table properties
-      const auto& mutable_cf_options = cfd->GetLatestMutableCFOptions();
-      if (s.ok() &&
-          (mutable_cf_options.table_factory->IsInstanceOf(
-               TableFactory::kBlockBasedTableName()) ||
-           mutable_cf_options.table_factory->IsInstanceOf(
-               TableFactory::kPlainTableName())) &&
-          flush_stats.num_output_records != temp_table_proerties.num_entries) {
-        std::string msg =
-            "Number of keys in flush output SST files does not match "
-            "number of keys added to the table. Expected " +
-            std::to_string(flush_stats.num_output_records) + " but there are " +
-            std::to_string(temp_table_proerties.num_entries) +
-            " in output SST files";
+                          std::to_string(num_input_entries);
        ROCKS_LOG_WARN(immutable_db_options_.info_log,
                       "[%s] [JOB %d] Level-0 flush during recover: %s",
                       cfd->GetName().c_str(), job_id, msg.c_str());
@@ -2167,25 +2118,25 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
    }
  }

-  flush_stats.micros = immutable_db_options_.clock->NowMicros() - start_micros;
+  InternalStats::CompactionStats stats(CompactionReason::kFlush, 1);
+  stats.micros = immutable_db_options_.clock->NowMicros() - start_micros;

  if (has_output) {
-    flush_stats.bytes_written = meta.fd.GetFileSize();
-    flush_stats.num_output_files = 1;
+    stats.bytes_written = meta.fd.GetFileSize();
+    stats.num_output_files = 1;
  }

  const auto& blobs = edit->GetBlobFileAdditions();
  for (const auto& blob : blobs) {
-    flush_stats.bytes_written_blob += blob.GetTotalBlobBytes();
+    stats.bytes_written_blob += blob.GetTotalBlobBytes();
  }

-  flush_stats.num_output_files_blob = static_cast<int>(blobs.size());
+  stats.num_output_files_blob = static_cast<int>(blobs.size());

-  cfd->internal_stats()->AddCompactionStats(level, Env::Priority::USER,
-                                            flush_stats);
+  cfd->internal_stats()->AddCompactionStats(level, Env::Priority::USER, stats);
  cfd->internal_stats()->AddCFStats(
      InternalStats::BYTES_FLUSHED,
-      flush_stats.bytes_written + flush_stats.bytes_written_blob);
+      stats.bytes_written + stats.bytes_written_blob);
  RecordTick(stats_, COMPACT_WRITE_BYTES, meta.fd.GetFileSize());
  return s;
 }
@@ -2313,7 +2264,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);
-  opt_file_options.write_hint = CalculateWALWriteHint();
  // 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;
@@ -2335,9 +2285,7 @@ IOStatus DBImpl::CreateWAL(const WriteOptions& write_options,
  }

  if (io_s.ok()) {
-    // Subsequent attempts to override the hint via SetWriteLifeTimeHint
-    // with the very same value will be ignored by the fs.
-    lfile->SetWriteLifeTimeHint(opt_file_options.write_hint);
+    lfile->SetWriteLifeTimeHint(CalculateWALWriteHint());
    lfile->SetPreallocationBlockSize(preallocate_block_size);

    const auto& listeners = immutable_db_options_.listeners;
@@ -2392,11 +2340,9 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
  handles->clear();

  size_t max_write_buffer_size = 0;
-  MinAndMaxPreserveSeconds preserve_info;
  for (const auto& cf : column_families) {
    max_write_buffer_size =
        std::max(max_write_buffer_size, cf.options.write_buffer_size);
-    preserve_info.Combine(cf.options);
  }

  auto impl = std::make_unique<DBImpl>(db_options, dbname, seq_per_batch,
@@ -2465,18 +2411,18 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    if (s.ok()) {
      // Prevent log files created by previous instance from being recycled.
      // They might be in alive_log_file_, and might get recycled otherwise.
-      impl->min_wal_number_to_recycle_ = new_log_number;
+      impl->min_log_number_to_recycle_ = new_log_number;
    }
    if (s.ok()) {
-      InstrumentedMutexLock wl(&impl->wal_write_mutex_);
-      impl->cur_wal_number_ = new_log_number;
+      InstrumentedMutexLock wl(&impl->log_write_mutex_);
+      impl->logfile_number_ = new_log_number;
      assert(new_log != nullptr);
      assert(impl->logs_.empty());
      impl->logs_.emplace_back(new_log_number, new_log);
    }

    if (s.ok()) {
-      impl->alive_wal_files_.emplace_back(impl->cur_wal_number_);
+      impl->alive_log_files_.emplace_back(impl->logfile_number_);
      // In WritePrepared there could be gap in sequence numbers. This breaks
      // the trick we use in kPointInTimeRecovery which assumes the first seq in
      // the log right after the corrupted log is one larger than the last seq
@@ -2489,14 +2435,14 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
      if (recovered_seq != kMaxSequenceNumber) {
        WriteBatch empty_batch;
        WriteBatchInternal::SetSequence(&empty_batch, recovered_seq);
-        uint64_t wal_used, log_size;
+        uint64_t log_used, log_size;
        log::Writer* log_writer = impl->logs_.back().writer;
-        WalFileNumberSize& wal_file_number_size = impl->alive_wal_files_.back();
+        LogFileNumberSize& log_file_number_size = impl->alive_log_files_.back();

-        assert(log_writer->get_log_number() == wal_file_number_size.number);
+        assert(log_writer->get_log_number() == log_file_number_size.number);
        impl->mutex_.AssertHeld();
-        s = impl->WriteToWAL(empty_batch, write_options, log_writer, &wal_used,
-                             &log_size, wal_file_number_size, recovered_seq);
+        s = impl->WriteToWAL(empty_batch, write_options, log_writer, &log_used,
+                             &log_size, log_file_number_size, recovered_seq);
        if (s.ok()) {
          // Need to fsync, otherwise it might get lost after a power reset.
          s = impl->FlushWAL(write_options, false);
@@ -2529,12 +2475,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    s = impl->InitPersistStatsColumnFamily();
  }

-  // After reaching the post-recovery seqno but before creating SuperVersions
-  // ensure seqno to time mapping is pre-populated as needed.
-  if (s.ok() && recovery_ctx.is_new_db_ && preserve_info.IsEnabled()) {
-    impl->PrepopulateSeqnoToTimeMapping(preserve_info);
-  }
-
  if (s.ok()) {
    // set column family handles
    for (const auto& cf : column_families) {
@@ -2544,9 +2484,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
        handles->push_back(
            new ColumnFamilyHandleImpl(cfd, impl.get(), &impl->mutex_));
        impl->NewThreadStatusCfInfo(cfd);
-        SuperVersionContext sv_context(/* create_superversion */ true);
-        impl->InstallSuperVersionForConfigChange(cfd, &sv_context);
-        sv_context.Clean();
      } else {
        if (db_options.create_missing_column_families) {
          // missing column family, create it
@@ -2554,7 +2491,6 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
          impl->mutex_.Unlock();
          // NOTE: the work normally done in WrapUpCreateColumnFamilies will
          // be done separately below.
-          // This includes InstallSuperVersionForConfigChange.
          s = impl->CreateColumnFamilyImpl(read_options, write_options,
                                           cf.options, cf.name, &handle);
          impl->mutex_.Lock();
@@ -2571,14 +2507,15 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    }
  }

-  if (s.ok() && impl->immutable_db_options_.persist_stats_to_disk) {
-    // Install SuperVersion for hidden column family
-    assert(impl->persist_stats_cf_handle_);
-    assert(impl->persist_stats_cf_handle_->cfd());
+  if (s.ok()) {
    SuperVersionContext sv_context(/* create_superversion */ true);
-    impl->InstallSuperVersionForConfigChange(
-        impl->persist_stats_cf_handle_->cfd(), &sv_context);
+    for (auto cfd : *impl->versions_->GetColumnFamilySet()) {
+      impl->InstallSuperVersionAndScheduleWork(cfd, &sv_context);
+    }
    sv_context.Clean();
+  }
+
+  if (s.ok() && impl->immutable_db_options_.persist_stats_to_disk) {
    // try to read format version
    s = impl->PersistentStatsProcessFormatVersion();
  }
@@ -2687,7 +2624,8 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
    s = impl->StartPeriodicTaskScheduler();
  }
  if (s.ok()) {
-    s = impl->RegisterRecordSeqnoTimeWorker();
+    s = impl->RegisterRecordSeqnoTimeWorker(read_options, write_options,
+                                            recovery_ctx.is_new_db_);
  }
  impl->options_mutex_.Unlock();
  if (s.ok()) {
@@ -185,10 +185,16 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& _read_options,
          ? static_cast<const SnapshotImpl*>(read_options.snapshot)->number_
          : latest_snapshot;
  ReadCallback* read_callback = nullptr;  // No read callback provided.
-  return NewArenaWrappedDbIterator(
-      env_, read_options, cfh, super_version, read_seq, read_callback, this,
-      /*expose_blob_index=*/false, /*allow_refresh=*/false,
-      /*allow_mark_memtable_for_flush=*/false);
+  auto db_iter = NewArenaWrappedDbIterator(
+      env_, read_options, cfd->ioptions(), super_version->mutable_cf_options,
+      super_version->current, read_seq,
+      super_version->mutable_cf_options.max_sequential_skip_in_iterations,
+      super_version->version_number, read_callback);
+  auto internal_iter = NewInternalIterator(
+      db_iter->GetReadOptions(), cfd, super_version, db_iter->GetArena(),
+      read_seq, /* allow_unprepared_value */ true, db_iter);
+  db_iter->SetIterUnderDBIter(internal_iter);
+  return db_iter;
 }

 Status DBImplReadOnly::NewIterators(
@@ -225,32 +231,36 @@ Status DBImplReadOnly::NewIterators(
          ? static_cast<const SnapshotImpl*>(read_options.snapshot)->number_
          : latest_snapshot;

-  autovector<std::tuple<ColumnFamilyHandleImpl*, SuperVersion*>> cfh_to_sv;
+  autovector<std::tuple<ColumnFamilyData*, SuperVersion*>> cfd_to_sv;

  const bool check_read_ts =
      read_options.timestamp && read_options.timestamp->size() > 0;
  for (auto cfh : column_families) {
    auto* cfd = static_cast_with_check<ColumnFamilyHandleImpl>(cfh)->cfd();
    auto* sv = cfd->GetSuperVersion()->Ref();
-    cfh_to_sv.emplace_back(static_cast_with_check<ColumnFamilyHandleImpl>(cfh),
-                           sv);
+    cfd_to_sv.emplace_back(cfd, sv);
    if (check_read_ts) {
      const Status s =
          FailIfReadCollapsedHistory(cfd, sv, *(read_options.timestamp));
      if (!s.ok()) {
-        for (auto prev_entry : cfh_to_sv) {
+        for (auto prev_entry : cfd_to_sv) {
          std::get<1>(prev_entry)->Unref();
        }
        return s;
      }
    }
  }
-  assert(cfh_to_sv.size() == column_families.size());
-  for (auto [cfh, sv] : cfh_to_sv) {
+  assert(cfd_to_sv.size() == column_families.size());
+  for (auto [cfd, sv] : cfd_to_sv) {
    auto* db_iter = NewArenaWrappedDbIterator(
-        env_, read_options, cfh, sv, read_seq, read_callback, this,
-        /*expose_blob_index=*/false, /*allow_refresh=*/false,
-        /*allow_mark_memtable_for_flush=*/false);
+        env_, read_options, cfd->ioptions(), sv->mutable_cf_options,
+        sv->current, read_seq,
+        sv->mutable_cf_options.max_sequential_skip_in_iterations,
+        sv->version_number, read_callback);
+    auto* internal_iter = NewInternalIterator(
+        db_iter->GetReadOptions(), cfd, sv, db_iter->GetArena(), read_seq,
+        /* allow_unprepared_value */ true, db_iter);
+    db_iter->SetIterUnderDBIter(internal_iter);
    iterators->push_back(db_iter);
  }

@@ -155,29 +155,6 @@ class DBImplReadOnly : public DBImpl {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

-  using DB::CreateColumnFamily;
-  using DBImpl::CreateColumnFamily;
-  Status CreateColumnFamily(const ColumnFamilyOptions& /*cf_options*/,
-                            const std::string& /*column_family*/,
-                            ColumnFamilyHandle** /*handle*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  using DB::CreateColumnFamilies;
-  using DBImpl::CreateColumnFamilies;
-  Status CreateColumnFamilies(
-      const ColumnFamilyOptions& /*cf_options*/,
-      const std::vector<std::string>& /*column_family_names*/,
-      std::vector<ColumnFamilyHandle*>* /*handles*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
-  Status CreateColumnFamilies(
-      const std::vector<ColumnFamilyDescriptor>& /*column_families*/,
-      std::vector<ColumnFamilyHandle*>* /*handles*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
  // FIXME: some missing overrides for more "write" functions

 protected:
@@ -49,6 +49,9 @@ Status DBImplSecondary::Recover(
    }
    return s;
  }
+  if (immutable_db_options_.paranoid_checks && s.ok()) {
+    s = CheckConsistency();
+  }
  // Initial max_total_in_memory_state_ before recovery logs.
  max_total_in_memory_state_ = 0;
  for (auto cfd : *versions_->GetColumnFamilySet()) {
@@ -563,10 +566,17 @@ ArenaWrappedDBIter* DBImplSecondary::NewIteratorImpl(
  assert(snapshot == kMaxSequenceNumber);
  snapshot = versions_->LastSequence();
  assert(snapshot != kMaxSequenceNumber);
-  return NewArenaWrappedDbIterator(env_, read_options, cfh, super_version,
-                                   snapshot, read_callback, this,
-                                   expose_blob_index, allow_refresh,
-                                   /*allow_mark_memtable_for_flush=*/false);
+  auto db_iter = NewArenaWrappedDbIterator(
+      env_, read_options, cfh->cfd()->ioptions(),
+      super_version->mutable_cf_options, super_version->current, snapshot,
+      super_version->mutable_cf_options.max_sequential_skip_in_iterations,
+      super_version->version_number, read_callback, cfh, expose_blob_index,
+      allow_refresh);
+  auto internal_iter = NewInternalIterator(
+      db_iter->GetReadOptions(), cfh->cfd(), super_version, db_iter->GetArena(),
+      snapshot, /* allow_unprepared_value */ true, db_iter);
+  db_iter->SetIterUnderDBIter(internal_iter);
+  return db_iter;
 }

 Status DBImplSecondary::NewIterators(
@@ -650,15 +660,58 @@ Status DBImplSecondary::NewIterators(
  return Status::OK();
 }

+Status DBImplSecondary::CheckConsistency() {
+  mutex_.AssertHeld();
+  Status s = DBImpl::CheckConsistency();
+  // If DBImpl::CheckConsistency() which is stricter returns success, then we
+  // do not need to give a second chance.
+  if (s.ok()) {
+    return s;
+  }
+  // It's possible that DBImpl::CheckConssitency() can fail because the primary
+  // may have removed certain files, causing the GetFileSize(name) call to
+  // fail and returning a PathNotFound. In this case, we take a best-effort
+  // approach and just proceed.
+  TEST_SYNC_POINT_CALLBACK(
+      "DBImplSecondary::CheckConsistency:AfterFirstAttempt", &s);
+
+  if (immutable_db_options_.skip_checking_sst_file_sizes_on_db_open) {
+    return Status::OK();
+  }
+
+  std::vector<LiveFileMetaData> metadata;
+  versions_->GetLiveFilesMetaData(&metadata);
+
+  std::string corruption_messages;
+  for (const auto& md : metadata) {
+    // md.name has a leading "/".
+    std::string file_path = md.db_path + md.name;
+
+    uint64_t fsize = 0;
+    s = env_->GetFileSize(file_path, &fsize);
+    if (!s.ok() &&
+        (env_->GetFileSize(Rocks2LevelTableFileName(file_path), &fsize).ok() ||
+         s.IsPathNotFound())) {
+      s = Status::OK();
+    }
+    if (!s.ok()) {
+      corruption_messages +=
+          "Can't access " + md.name + ": " + s.ToString() + "\n";
+    }
+  }
+  return corruption_messages.empty() ? Status::OK()
+                                     : Status::Corruption(corruption_messages);
+}
+
 Status DBImplSecondary::TryCatchUpWithPrimary() {
  assert(versions_.get() != nullptr);
+  assert(manifest_reader_.get() != nullptr);
  Status s;
  // read the manifest and apply new changes to the secondary instance
  std::unordered_set<ColumnFamilyData*> cfds_changed;
  JobContext job_context(0, true /*create_superversion*/);
  {
    InstrumentedMutexLock lock_guard(&mutex_);
-    assert(manifest_reader_.get() != nullptr);
    s = static_cast_with_check<ReactiveVersionSet>(versions_.get())
            ->ReadAndApply(&mutex_, &manifest_reader_,
                           manifest_reader_status_.get(), &cfds_changed,
@@ -682,13 +735,13 @@ Status DBImplSecondary::TryCatchUpWithPrimary() {
    // instance
    if (s.ok()) {
      s = FindAndRecoverLogFiles(&cfds_changed, &job_context);
-      if (s.IsPathNotFound()) {
-        ROCKS_LOG_INFO(
-            immutable_db_options_.info_log,
-            "Secondary tries to read WAL, but WAL file(s) have already "
-            "been purged by primary.");
-        s = Status::OK();
-      }
+    }
+    if (s.IsPathNotFound()) {
+      ROCKS_LOG_INFO(
+          immutable_db_options_.info_log,
+          "Secondary tries to read WAL, but WAL file(s) have already "
+          "been purged by primary.");
+      s = Status::OK();
    }
    if (s.ok()) {
      for (auto cfd : cfds_changed) {
@@ -848,6 +901,7 @@ Status DBImplSecondary::CompactWithoutInstallation(

  VersionStorageInfo* vstorage = version->storage_info();

+  // Use comp_options to reuse some CompactFiles functions
  CompactionOptions comp_options;
  comp_options.compression = kDisableCompressionOption;
  comp_options.output_file_size_limit = MaxFileSizeForLevel(
@@ -862,31 +916,17 @@ Status DBImplSecondary::CompactWithoutInstallation(
    ROCKS_LOG_ERROR(
        immutable_db_options_.info_log,
        "GetCompactionInputsFromFileNumbers() failed - %s.\n DebugString: %s",
-        s.ToString().c_str(), version->DebugString(/*hex=*/true).c_str());
+        s.ToString().c_str(), version->DebugString().c_str());
    return s;
  }

-  const int job_id = next_job_id_.fetch_add(1);
-  JobContext job_context(job_id, true /*create_superversion*/);
-  std::vector<SequenceNumber> snapshots = input.snapshots;
-
-  // TODO - snapshot_checker support in Remote Compaction
-  job_context.InitSnapshotContext(/*checker=*/nullptr,
-                                  /*managed_snapshot=*/nullptr,
-                                  kMaxSequenceNumber, std::move(snapshots));
-
-  // TODO - consider serializing the entire Compaction object and using it as
-  // input instead of recreating it in the remote worker
  std::unique_ptr<Compaction> c;
  assert(cfd->compaction_picker());
  c.reset(cfd->compaction_picker()->CompactFiles(
      comp_options, input_files, input.output_level, vstorage,
-      cfd->GetLatestMutableCFOptions(), mutable_db_options_, 0,
-      /*earliest_snapshot=*/job_context.snapshot_seqs.empty()
-          ? kMaxSequenceNumber
-          : job_context.snapshot_seqs.front(),
-      job_context.snapshot_checker));
+      cfd->GetLatestMutableCFOptions(), mutable_db_options_, 0));
  assert(c != nullptr);
+
  c->FinalizeInputInfo(version);

  // Create output directory if it's not existed yet
@@ -899,6 +939,8 @@ Status DBImplSecondary::CompactWithoutInstallation(
  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL,
                       immutable_db_options_.info_log.get());

+  const int job_id = next_job_id_.fetch_add(1);
+
  // use primary host's db_id for running the compaction, but db_session_id is
  // using the local one, which is to make sure the unique id is unique from
  // the remote compactors. Because the id is generated from db_id,
@@ -909,7 +951,7 @@ Status DBImplSecondary::CompactWithoutInstallation(
      job_id, c.get(), immutable_db_options_, mutable_db_options_,
      file_options_for_compaction_, versions_.get(), &shutting_down_,
      &log_buffer, output_dir.get(), stats_, &mutex_, &error_handler_,
-      &job_context, table_cache_, &event_logger_, dbname_, io_tracer_,
+      input.snapshots, table_cache_, &event_logger_, dbname_, io_tracer_,
      options.canceled ? *options.canceled : kManualCompactionCanceledFalse_,
      input.db_id, db_session_id_, secondary_path_, input, result);

@@ -949,7 +991,7 @@ Status DB::OpenAndCompact(
  }

  // 2. Load the options
-  DBOptions base_db_options;
+  DBOptions db_options;
  ConfigOptions config_options;
  config_options.env = override_options.env;
  config_options.ignore_unknown_options = true;
@@ -962,22 +1004,13 @@ Status DB::OpenAndCompact(
  std::string options_file_name =
      OptionsFileName(name, compaction_input.options_file_number);

-  s = LoadOptionsFromFile(config_options, options_file_name, &base_db_options,
+  s = LoadOptionsFromFile(config_options, options_file_name, &db_options,
                          &all_column_families);
  if (!s.ok()) {
    return s;
  }

-  // 3. Options to Override
-  // Override serializable configurations from override_options.options_map
-  DBOptions db_options;
-  s = GetDBOptionsFromMap(config_options, base_db_options,
-                          override_options.options_map, &db_options);
-  if (!s.ok()) {
-    return s;
-  }
-
-  // Override options that are directly set as shared ptrs in
+  // 3. Override pointer configurations in DBOptions with
  // CompactionServiceOptionsOverride
  db_options.env = override_options.env;
  db_options.file_checksum_gen_factory =
@@ -988,7 +1021,6 @@ Status DB::OpenAndCompact(
  // We will close the DB after the compaction anyway.
  // Open as many files as needed for the compaction.
  db_options.max_open_files = -1;
-  db_options.info_log = override_options.info_log;

  // 4. Filter CFs that are needed for OpenAndCompact()
  // We do not need to open all column families for the remote compaction.
@@ -998,18 +1030,6 @@ Status DB::OpenAndCompact(
  std::vector<ColumnFamilyDescriptor> column_families;
  for (auto& cf : all_column_families) {
    if (cf.name == compaction_input.cf_name) {
-      ColumnFamilyOptions cf_options;
-      // Override serializable configurations from override_options.options_map
-      s = GetColumnFamilyOptionsFromMap(config_options, cf.options,
-                                        override_options.options_map,
-                                        &cf_options);
-      if (!s.ok()) {
-        return s;
-      }
-      cf.options = std::move(cf_options);
-
-      // Override options that are directly set as shared ptrs in
-      // CompactionServiceOptionsOverride
      cf.options.comparator = override_options.comparator;
      cf.options.merge_operator = override_options.merge_operator;
      cf.options.compaction_filter = override_options.compaction_filter;
@@ -1021,7 +1041,6 @@ Status DB::OpenAndCompact(
          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);
@@ -1038,9 +1057,6 @@ Status DB::OpenAndCompact(
  }
  assert(db);

-  TEST_SYNC_POINT_CALLBACK(
-      "DBImplSecondary::OpenAndCompact::AfterOpenAsSecondary:0", db);
-
  // 6. Find the handle of the Column Family that this will compact
  ColumnFamilyHandle* cfh = nullptr;
  for (auto* handle : handles) {
@@ -248,6 +248,12 @@ class DBImplSecondary : public DBImpl {
  Status MaybeInitLogReader(uint64_t log_number,
                            log::FragmentBufferedReader** log_reader);

+  // Check if all live files exist on file system and that their file sizes
+  // matche to the in-memory records. It is possible that some live files may
+  // have been deleted by the primary. In this case, CheckConsistency() does
+  // not flag the missing file as inconsistency.
+  Status CheckConsistency() override;
+
 #ifndef NDEBUG
  Status TEST_CompactWithoutInstallation(const OpenAndCompactOptions& options,
                                         ColumnFamilyHandle* cfh,
@@ -157,7 +157,7 @@ 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,
-                  /*wal_used=*/nullptr);
+                  /*log_used=*/nullptr);
  }
  return s;
 }
@@ -190,38 +190,11 @@ Status DBImpl::WriteWithCallback(const WriteOptions& write_options,
  return s;
 }

-Status DBImpl::IngestWriteBatchWithIndex(
-    const WriteOptions& write_options,
-    std::shared_ptr<WriteBatchWithIndex> wbwi) {
-  if (!wbwi) {
-    return Status::InvalidArgument("Batch is nullptr!");
-  }
-  if (!write_options.disableWAL) {
-    return Status::NotSupported(
-        "IngestWriteBatchWithIndex does not support disableWAL=true");
-  }
-  Status s;
-  if (write_options.protection_bytes_per_key > 0) {
-    s = WriteBatchInternal::UpdateProtectionInfo(
-        wbwi->GetWriteBatch(), write_options.protection_bytes_per_key);
-  }
-  if (s.ok()) {
-    WriteBatch dummy_empty_batch;
-    s = WriteImpl(
-        write_options, /*updates=*/&dummy_empty_batch, /*callback=*/nullptr,
-        /*user_write_cb=*/nullptr, /*log_used=*/nullptr, /*log_ref=*/0,
-        /*disable_memtable=*/false, /*seq_used=*/nullptr,
-        /*batch_cnt=*/0, /*pre_release_callback=*/nullptr,
-        /*post_memtable_callback=*/nullptr, /*wbwi=*/wbwi);
-  }
-  return s;
-}
-
-Status DBImpl::IngestWBWIAsMemtable(
-    std::shared_ptr<WriteBatchWithIndex> wbwi,
-    const WBWIMemTable::SeqnoRange& assigned_seqno, uint64_t min_prep_log,
-    SequenceNumber last_seqno_after_ingest, bool memtable_updated,
-    bool ignore_missing_cf) {
+Status DBImpl::IngestWBWI(std::shared_ptr<WriteBatchWithIndex> wbwi,
+                          const WBWIMemTable::SeqnoRange& assigned_seqno,
+                          uint64_t prep_log,
+                          SequenceNumber last_seqno_after_ingest,
+                          bool memtable_updated, bool ignore_missing_cf) {
  // Keys in new memtable have seqno > last_seqno_after_ingest >= keys in wbwi.
  assert(assigned_seqno.upper_bound <= last_seqno_after_ingest);
  // Keys in the current memtable have seqno <= LastSequence() < keys in wbwi.
@@ -265,30 +238,12 @@ Status DBImpl::IngestWBWIAsMemtable(
    wbwi_memtable->AssignSequenceNumbers(assigned_seqno);
    // This is needed to keep the WAL that contains Prepare alive until
    // committed data in this memtable is persisted.
-    wbwi_memtable->SetMinPrepLog(min_prep_log);
+    wbwi_memtable->SetMinPrepLog(prep_log);
    memtables.push_back(wbwi_memtable);
    cfd->Ref();
    cfds.push_back(cfd);
  }

-  autovector<ColumnFamilyData*> cfds_for_atomic_flush;
-  if (immutable_db_options_.atomic_flush) {
-    SelectColumnFamiliesForAtomicFlush(&cfds_for_atomic_flush);
-    for (auto cfd : cfds_for_atomic_flush) {
-      bool found = false;
-      for (auto existing_cfd : cfds) {
-        if (existing_cfd == cfd) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        cfd->Ref();
-        cfds.push_back(cfd);
-      }
-    }
-  }
-
  // Stop writes to the DB by entering both write threads
  WriteThread::Writer nonmem_w;
  if (two_write_queues_) {
@@ -298,16 +253,15 @@ Status DBImpl::IngestWBWIAsMemtable(

  // Switch memtable and add WBWIMemTables
  Status s;
-  for (size_t i = 0; i < cfds.size(); ++i) {
+  for (size_t i = 0; i < memtables.size(); ++i) {
+    assert(!immutable_db_options_.atomic_flush);
+    // NOTE: to support atomic flush, need to call
+    // SelectColumnFamiliesForAtomicFlush()
    WriteContext write_context;
    // TODO: not switch on empty memtable, may need to update metadata
    //   like NextLogNumber(), earliest_seqno and memtable id.
-    if (i < memtables.size()) {
-      s = SwitchMemtable(cfds[i], &write_context, memtables[i],
-                         last_seqno_after_ingest);
-    } else {
-      s = SwitchMemtable(cfds[i], &write_context);
-    }
+    s = SwitchMemtable(cfds[i], &write_context, memtables[i],
+                       last_seqno_after_ingest);
    if (!s.ok()) {
      // SwitchMemtable() can only fail if a new WAL is to be created, this
      // should only happen for the first call to SwitchMemtable(). log will
@@ -347,18 +301,9 @@ Status DBImpl::IngestWBWIAsMemtable(
        continue;
      }
      cfd->imm()->FlushRequested();
-      if (!immutable_db_options_.atomic_flush) {
-        FlushRequest flush_req;
-        // TODO: a new flush reason for ingesting memtable
-        GenerateFlushRequest({cfd}, FlushReason::kExternalFileIngestion,
-                             &flush_req);
-        EnqueuePendingFlush(flush_req);
-      }
-    }
-    if (immutable_db_options_.atomic_flush) {
-      AssignAtomicFlushSeq(cfds);
      FlushRequest flush_req;
-      GenerateFlushRequest(cfds, FlushReason::kExternalFileIngestion,
+      // TODO: a new flush reason for ingesting memtable
+      GenerateFlushRequest({cfd}, FlushReason::kExternalFileIngestion,
                           &flush_req);
      EnqueuePendingFlush(flush_req);
    }
@@ -369,12 +314,13 @@ Status DBImpl::IngestWBWIAsMemtable(

 Status DBImpl::WriteImpl(const WriteOptions& write_options,
                         WriteBatch* my_batch, WriteCallback* callback,
-                         UserWriteCallback* user_write_cb, uint64_t* wal_used,
+                         UserWriteCallback* user_write_cb, 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,
-                         std::shared_ptr<WriteBatchWithIndex> wbwi) {
+                         std::shared_ptr<WriteBatchWithIndex> wbwi,
+                         uint64_t prep_log) {
  assert(!seq_per_batch_ || batch_cnt != 0);
  assert(my_batch == nullptr || my_batch->Count() == 0 ||
         write_options.protection_bytes_per_key == 0 ||
@@ -463,17 +409,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    return Status::NotSupported(
        "DeleteRange is not compatible with row cache.");
  }
-  // Whether the WBWI is from transaction commit or a direct write
-  // (IngestWriteBatchWithIndex())
-  bool ingest_wbwi_for_commit = false;
  if (wbwi) {
-    if (my_batch->HasCommit()) {
-      ingest_wbwi_for_commit = true;
-      assert(log_ref);
-    } else {
-      // Only supports disableWAL for directly ingesting WBWI for now.
-      assert(write_options.disableWAL);
-    }
+    assert(prep_log > 0);
+    // Used only in WriteCommittedTxn::CommitInternal() with no `callback`.
    assert(!callback);
    if (immutable_db_options_.unordered_write) {
      return Status::NotSupported(
@@ -483,9 +421,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      return Status::NotSupported(
          "Ingesting WriteBatch does not support pipelined_write");
    }
-    if (!wbwi->GetOverwriteKey()) {
+    if (immutable_db_options_.atomic_flush) {
      return Status::NotSupported(
-          "WriteBatchWithIndex ingestion requires overwrite_key=true");
+          "Ingesting WriteBatch does not support atomic_flush");
    }
  }
  // Otherwise IsLatestPersistentState optimization does not make sense
@@ -506,7 +444,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // they don't consume sequence.
    return WriteImplWALOnly(
        &nonmem_write_thread_, write_options, my_batch, callback, user_write_cb,
-        wal_used, log_ref, seq_used, batch_cnt, pre_release_callback,
+        log_used, log_ref, seq_used, batch_cnt, pre_release_callback,
        assign_order, kDontPublishLastSeq, disable_memtable);
  }

@@ -520,7 +458,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // sequence in in increasing order, iii) call pre_release_callback serially
    Status status = WriteImplWALOnly(
        &write_thread_, write_options, my_batch, callback, user_write_cb,
-        wal_used, log_ref, &seq, sub_batch_cnt, pre_release_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()) {
@@ -539,7 +477,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,

  if (immutable_db_options_.enable_pipelined_write) {
    return PipelinedWriteImpl(write_options, my_batch, callback, user_write_cb,
-                              wal_used, log_ref, disable_memtable, seq_used);
+                              log_used, log_ref, disable_memtable, seq_used);
  }

  PERF_TIMER_GUARD(write_pre_and_post_process_time);
@@ -586,19 +524,16 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
          assert(tmp_s.ok());
        }
      }
-      if (w.status.ok()) {  // Don't publish a partial batch write
-        versions_->SetLastSequence(last_sequence);
-      } else {
-        HandleMemTableInsertFailure(w.status);
-      }
+      versions_->SetLastSequence(last_sequence);
+      MemTableInsertStatusCheck(w.status);
      write_thread_.ExitAsBatchGroupFollower(&w);
    }
    assert(w.state == WriteThread::STATE_COMPLETED);
    // STATE_COMPLETED conditional below handles exit
  }
  if (w.state == WriteThread::STATE_COMPLETED) {
-    if (wal_used != nullptr) {
-      *wal_used = w.wal_used;
+    if (log_used != nullptr) {
+      *log_used = w.log_used;
    }
    if (seq_used != nullptr) {
      *seq_used = w.sequence;
@@ -614,8 +549,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
  // when it finds suitable, and finish them in the same write batch.
  // This is how a write job could be done by the other writer.
  WriteContext write_context;
-  // FIXME: also check disableWAL like others?
-  WalContext wal_context(write_options.sync);
+  LogContext log_context(write_options.sync);
  WriteThread::WriteGroup write_group;
  bool in_parallel_group = false;
  uint64_t last_sequence = kMaxSequenceNumber;
@@ -629,7 +563,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // PreprocessWrite does its own perf timing.
    PERF_TIMER_STOP(write_pre_and_post_process_time);

-    status = PreprocessWrite(write_options, &wal_context, &write_context);
+    status = PreprocessWrite(write_options, &log_context, &write_context);
    if (!two_write_queues_) {
      // Assign it after ::PreprocessWrite since the sequence might advance
      // inside it by WriteRecoverableState
@@ -697,13 +631,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
            continue;
          }
          // TODO: maybe handle the tracing status?
-          if (wbwi && !ingest_wbwi_for_commit) {
-            // for transaction write, tracer only needs the commit marker which
-            // is in writer->batch
-            tracer_->Write(wbwi->GetWriteBatch()).PermitUncheckedError();
-          } else {
-            tracer_->Write(writer->batch).PermitUncheckedError();
-          }
+          tracer_->Write(writer->batch).PermitUncheckedError();
        }
      }
    }
@@ -761,21 +689,22 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,

    if (!two_write_queues_) {
      if (status.ok() && !write_options.disableWAL) {
-        assert(wal_context.wal_file_number_size);
-        wal_context.prev_size = wal_context.writer->file()->GetFileSize();
+        assert(log_context.log_file_number_size);
+        LogFileNumberSize& log_file_number_size =
+            *(log_context.log_file_number_size);
        PERF_TIMER_GUARD(write_wal_time);
-        io_s = WriteGroupToWAL(write_group, wal_context.writer, wal_used,
-                               wal_context.need_wal_sync,
-                               wal_context.need_wal_dir_sync, last_sequence + 1,
-                               *wal_context.wal_file_number_size);
+        io_s =
+            WriteToWAL(write_group, log_context.writer, log_used,
+                       log_context.need_log_sync, log_context.need_log_dir_sync,
+                       last_sequence + 1, log_file_number_size);
      }
    } else {
      if (status.ok() && !write_options.disableWAL) {
        PERF_TIMER_GUARD(write_wal_time);
        // LastAllocatedSequence is increased inside WriteToWAL under
        // wal_write_mutex_ to ensure ordered events in WAL
-        io_s = ConcurrentWriteGroupToWAL(write_group, wal_used, &last_sequence,
-                                         seq_inc);
+        io_s = ConcurrentWriteToWAL(write_group, log_used, &last_sequence,
+                                    seq_inc);
      } else {
        // Otherwise we inc seq number for memtable writes
        last_sequence = versions_->FetchAddLastAllocatedSequence(seq_inc);
@@ -787,16 +716,16 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    last_sequence += seq_inc;
    // Seqno assigned to this write are [current_sequence, last_sequence]

-    if (wal_context.need_wal_sync) {
+    if (log_context.need_log_sync) {
      VersionEdit synced_wals;
-      wal_write_mutex_.Lock();
+      log_write_mutex_.Lock();
      if (status.ok()) {
-        MarkLogsSynced(cur_wal_number_, wal_context.need_wal_dir_sync,
+        MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
                       &synced_wals);
      } else {
-        MarkLogsNotSynced(cur_wal_number_);
+        MarkLogsNotSynced(logfile_number_);
      }
-      wal_write_mutex_.Unlock();
+      log_write_mutex_.Unlock();
      if (status.ok() && synced_wals.IsWalAddition()) {
        InstrumentedMutexLock l(&mutex_);
        // TODO: plumb Env::IOActivity, Env::IOPriority
@@ -831,7 +760,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
        writer->sequence = next_sequence;
        if (writer->pre_release_callback) {
          Status ws = writer->pre_release_callback->Callback(
-              writer->sequence, disable_memtable, writer->wal_used, index++,
+              writer->sequence, disable_memtable, writer->log_used, index++,
              pre_release_callback_cnt);
          if (!ws.ok()) {
            status = pre_release_cb_status = ws;
@@ -856,7 +785,8 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
            write_group, current_sequence, column_family_memtables_.get(),
            &flush_scheduler_, &trim_history_scheduler_,
            write_options.ignore_missing_column_families,
-            0 /*recovery_log_number*/, this, seq_per_batch_, batch_per_txn_);
+            0 /*recovery_log_number*/, this, parallel, seq_per_batch_,
+            batch_per_txn_);
      } else {
        write_group.last_sequence = last_sequence;
        write_thread_.LaunchParallelMemTableWriters(&write_group);
@@ -904,13 +834,12 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // handle exit, false means somebody else did
    should_exit_batch_group = write_thread_.CompleteParallelMemTableWriter(&w);
  }
-  if (wbwi && status.ok() && w.status.ok()) {
-    uint32_t wbwi_count = wbwi->GetWriteBatch()->Count();
-    // skip empty batch case
-    if (wbwi_count) {
+  if (wbwi) {
+    if (status.ok() && w.status.ok()) {
      // w.batch contains (potentially empty) commit time batch updates,
      // only ingest wbwi if w.batch is applied to memtable successfully
      uint32_t memtable_update_count = w.batch->Count();
+      uint32_t wbwi_count = wbwi->GetWriteBatch()->Count();
      // Seqno assigned to this write are [last_seq + 1 - seq_inc, last_seq].
      // seq_inc includes w.batch (memtable updates) and wbwi
      // w.batch gets first `memtable_update_count` sequence numbers.
@@ -923,12 +852,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      if (two_write_queues_) {
        assert(ub <= versions_->LastAllocatedSequence());
      }
-      status =
-          IngestWBWIAsMemtable(wbwi, {/*lower_bound=*/lb, /*upper_bound=*/ub},
-                               /*min_prep_log=*/log_ref, last_sequence,
-                               /*memtable_updated=*/memtable_update_count > 0,
-                               write_options.ignore_missing_column_families);
-      RecordTick(stats_, NUMBER_WBWI_INGEST);
+      status = IngestWBWI(wbwi, {/*lower_bound=*/lb, /*upper_bound=*/ub},
+                          prep_log, last_sequence,
+                          /*memtable_updated=*/memtable_update_count > 0,
+                          write_options.ignore_missing_column_families);
    }
  }

@@ -946,19 +873,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
      }
      // Note: if we are to resume after non-OK statuses we need to revisit how
      // we react to non-OK statuses here.
-      if (w.status.ok()) {  // Don't publish a partial batch write
-        versions_->SetLastSequence(last_sequence);
-      }
-    }
-    if (!w.status.ok()) {
-      if (wal_context.prev_size < SIZE_MAX) {
-        InstrumentedMutexLock l(&wal_write_mutex_);
-        if (logs_.back().number == wal_context.wal_file_number_size->number) {
-          logs_.back().SetAttemptTruncateSize(wal_context.prev_size);
-        }
-      }
-      HandleMemTableInsertFailure(w.status);
+      versions_->SetLastSequence(last_sequence);
    }
+    MemTableInsertStatusCheck(w.status);
    write_thread_.ExitAsBatchGroupLeader(write_group, status);
  }

@@ -971,7 +888,7 @@ 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* wal_used, uint64_t log_ref,
+                                  uint64_t* log_used, uint64_t log_ref,
                                  bool disable_memtable, uint64_t* seq_used) {
  PERF_TIMER_GUARD(write_pre_and_post_process_time);
  StopWatch write_sw(immutable_db_options_.clock, stats_, DB_WRITE);
@@ -988,10 +905,10 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    if (w.callback && !w.callback->AllowWriteBatching()) {
      write_thread_.WaitForMemTableWriters();
    }
-    WalContext wal_context(!write_options.disableWAL && write_options.sync);
+    LogContext log_context(!write_options.disableWAL && write_options.sync);
    // PreprocessWrite does its own perf timing.
    PERF_TIMER_STOP(write_pre_and_post_process_time);
-    w.status = PreprocessWrite(write_options, &wal_context, &write_context);
+    w.status = PreprocessWrite(write_options, &log_context, &write_context);
    PERF_TIMER_START(write_pre_and_post_process_time);

    // This can set non-OK status if callback fail.
@@ -1060,13 +977,13 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
                          wal_write_group.size - 1);
        RecordTick(stats_, WRITE_DONE_BY_OTHER, wal_write_group.size - 1);
      }
-      assert(wal_context.wal_file_number_size);
-      WalFileNumberSize& wal_file_number_size =
-          *(wal_context.wal_file_number_size);
-      io_s = WriteGroupToWAL(wal_write_group, wal_context.writer, wal_used,
-                             wal_context.need_wal_sync,
-                             wal_context.need_wal_dir_sync, current_sequence,
-                             wal_file_number_size);
+      assert(log_context.log_file_number_size);
+      LogFileNumberSize& log_file_number_size =
+          *(log_context.log_file_number_size);
+      io_s =
+          WriteToWAL(wal_write_group, log_context.writer, log_used,
+                     log_context.need_log_sync, log_context.need_log_dir_sync,
+                     current_sequence, log_file_number_size);
      w.status = io_s;
    }

@@ -1078,13 +995,13 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

    VersionEdit synced_wals;
-    if (wal_context.need_wal_sync) {
-      InstrumentedMutexLock l(&wal_write_mutex_);
+    if (log_context.need_log_sync) {
+      InstrumentedMutexLock l(&log_write_mutex_);
      if (w.status.ok()) {
-        MarkLogsSynced(cur_wal_number_, wal_context.need_wal_dir_sync,
+        MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
                       &synced_wals);
      } else {
-        MarkLogsNotSynced(cur_wal_number_);
+        MarkLogsNotSynced(logfile_number_);
      }
    }
    if (w.status.ok() && synced_wals.IsWalAddition()) {
@@ -1114,13 +1031,8 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
          memtable_write_group, w.sequence, column_family_memtables_.get(),
          &flush_scheduler_, &trim_history_scheduler_,
          write_options.ignore_missing_column_families, 0 /*log_number*/, this,
-          seq_per_batch_, batch_per_txn_);
-      if (memtable_write_group.status
-              .ok()) {  // Don't publish a partial batch write
-        versions_->SetLastSequence(memtable_write_group.last_sequence);
-      } else {
-        HandleMemTableInsertFailure(memtable_write_group.status);
-      }
+          false /*concurrent_memtable_writes*/, seq_per_batch_, batch_per_txn_);
+      versions_->SetLastSequence(memtable_write_group.last_sequence);
      write_thread_.ExitAsMemTableWriter(&w, memtable_write_group);
    }
  } else {
@@ -1149,11 +1061,8 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    PERF_TIMER_START(write_pre_and_post_process_time);

    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
-      if (w.status.ok()) {  // Don't publish a partial batch write
-        versions_->SetLastSequence(w.write_group->last_sequence);
-      } else {
-        HandleMemTableInsertFailure(w.status);
-      }
+      MemTableInsertStatusCheck(w.status);
+      versions_->SetLastSequence(w.write_group->last_sequence);
      write_thread_.ExitAsMemTableWriter(&w, *w.write_group);
    }
  }
@@ -1225,7 +1134,7 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options,
 Status DBImpl::WriteImplWALOnly(
    WriteThread* write_thread, const WriteOptions& write_options,
    WriteBatch* my_batch, WriteCallback* callback,
-    UserWriteCallback* user_write_cb, uint64_t* wal_used,
+    UserWriteCallback* user_write_cb, 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) {
@@ -1238,8 +1147,8 @@ Status DBImpl::WriteImplWALOnly(
  write_thread->JoinBatchGroup(&w);
  assert(w.state != WriteThread::STATE_PARALLEL_MEMTABLE_WRITER);
  if (w.state == WriteThread::STATE_COMPLETED) {
-    if (wal_used != nullptr) {
-      *wal_used = w.wal_used;
+    if (log_used != nullptr) {
+      *log_used = w.log_used;
    }
    if (seq_used != nullptr) {
      *seq_used = w.sequence;
@@ -1255,10 +1164,10 @@ Status DBImpl::WriteImplWALOnly(

    // TODO(myabandeh): Make preliminary checks thread-safe so we could do them
    // without paying the cost of obtaining the mutex.
-    WalContext wal_context;
+    LogContext log_context;
    WriteContext write_context;
    Status status =
-        PreprocessWrite(write_options, &wal_context, &write_context);
+        PreprocessWrite(write_options, &log_context, &write_context);
    WriteStatusCheckOnLocked(status);

    if (!status.ok()) {
@@ -1355,8 +1264,8 @@ Status DBImpl::WriteImplWALOnly(
  }
  Status status;
  if (!write_options.disableWAL) {
-    IOStatus io_s = ConcurrentWriteGroupToWAL(write_group, wal_used,
-                                              &last_sequence, seq_inc);
+    IOStatus io_s =
+        ConcurrentWriteToWAL(write_group, log_used, &last_sequence, seq_inc);
    status = io_s;
    // last_sequence may not be set if there is an error
    // This error checking and return is moved up to avoid using uninitialized
@@ -1408,7 +1317,7 @@ Status DBImpl::WriteImplWALOnly(
      if (!writer->CallbackFailed() && writer->pre_release_callback) {
        assert(writer->sequence != kMaxSequenceNumber);
        Status ws = writer->pre_release_callback->Callback(
-            writer->sequence, disable_memtable, writer->wal_used, index++,
+            writer->sequence, disable_memtable, writer->log_used, index++,
            pre_release_callback_cnt);
        if (!ws.ok()) {
          status = ws;
@@ -1477,22 +1386,24 @@ void DBImpl::WALIOStatusCheck(const IOStatus& io_status) {
  }
 }

-void DBImpl::HandleMemTableInsertFailure(const Status& status) {
-  assert(!status.ok());
-  // A non-OK status on memtable insert indicates that the state implied by the
-  // WAL has diverged from the in-memory state.  This could be because of a
-  // corrupt write_batch (very bad), or because the client specified an invalid
-  // column family and didn't specify ignore_missing_column_families.
-  mutex_.Lock();
-  assert(!error_handler_.IsBGWorkStopped());
-  error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable);
-  mutex_.Unlock();
+void DBImpl::MemTableInsertStatusCheck(const Status& status) {
+  // A non-OK status here indicates that the state implied by the
+  // WAL has diverged from the in-memory state.  This could be
+  // because of a corrupt write_batch (very bad), or because the
+  // client specified an invalid column family and didn't specify
+  // ignore_missing_column_families.
+  if (!status.ok()) {
+    mutex_.Lock();
+    assert(!error_handler_.IsBGWorkStopped());
+    error_handler_.SetBGError(status, BackgroundErrorReason::kMemTable);
+    mutex_.Unlock();
+  }
 }

 Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
-                               WalContext* wal_context,
+                               LogContext* log_context,
                               WriteContext* write_context) {
-  assert(write_context != nullptr && wal_context != nullptr);
+  assert(write_context != nullptr && log_context != nullptr);
  Status status;

  if (error_handler_.IsDBStopped()) {
@@ -1502,8 +1413,7 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,

  PERF_TIMER_GUARD(write_scheduling_flushes_compactions_time);

-  if (UNLIKELY(status.ok() &&
-               wals_total_size_.LoadRelaxed() > GetMaxTotalWalSize())) {
+  if (UNLIKELY(status.ok() && total_log_size_ > GetMaxTotalWalSize())) {
    assert(versions_);
    InstrumentedMutexLock l(&mutex_);
    const ColumnFamilySet* const column_families =
@@ -1572,17 +1482,17 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
      WriteBufferManagerStallWrites();
    }
  }
-  InstrumentedMutexLock l(&wal_write_mutex_);
-  if (status.ok() && wal_context->need_wal_sync) {
+  InstrumentedMutexLock l(&log_write_mutex_);
+  if (status.ok() && log_context->need_log_sync) {
    // Wait until the parallel syncs are finished. Any sync process has to sync
    // the front log too so it is enough to check the status of front()
-    // We do a while loop since wal_sync_cv_ is signalled when any sync is
+    // We do a while loop since log_sync_cv_ is signalled when any sync is
    // finished
    // Note: there does not seem to be a reason to wait for parallel sync at
    // this early step but it is not important since parallel sync (SyncWAL) and
-    // need_wal_sync are usually not used together.
+    // need_log_sync are usually not used together.
    while (logs_.front().IsSyncing()) {
-      wal_sync_cv_.Wait();
+      log_sync_cv_.Wait();
    }
    for (auto& log : logs_) {
      // This is just to prevent the logs to be synced by a parallel SyncWAL
@@ -1593,12 +1503,12 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
      log.PrepareForSync();
    }
  } else {
-    wal_context->need_wal_sync = false;
+    log_context->need_log_sync = false;
  }
-  wal_context->writer = logs_.back().writer;
-  wal_context->need_wal_dir_sync =
-      wal_context->need_wal_dir_sync && !wal_dir_synced_;
-  wal_context->wal_file_number_size = std::addressof(alive_wal_files_.back());
+  log_context->writer = logs_.back().writer;
+  log_context->need_log_dir_sync =
+      log_context->need_log_dir_sync && !log_dir_synced_;
+  log_context->log_file_number_size = std::addressof(alive_log_files_.back());

  return status;
 }
@@ -1649,12 +1559,12 @@ Status DBImpl::MergeBatch(const WriteThread::WriteGroup& write_group,
 }

 // When two_write_queues_ is disabled, this function is called from the only
-// write thread. Otherwise this must be called holding wal_write_mutex_.
+// write thread. Otherwise this must be called holding log_write_mutex_.
 IOStatus DBImpl::WriteToWAL(const WriteBatch& merged_batch,
                            const WriteOptions& write_options,
-                            log::Writer* log_writer, uint64_t* wal_used,
+                            log::Writer* log_writer, uint64_t* log_used,
                            uint64_t* log_size,
-                            WalFileNumberSize& wal_file_number_size,
+                            LogFileNumberSize& log_file_number_size,
                            SequenceNumber sequence) {
  assert(log_size != nullptr);

@@ -1666,7 +1576,7 @@ IOStatus DBImpl::WriteToWAL(const WriteBatch& merged_batch,
  }
  *log_size = log_entry.size();
  // When two_write_queues_ WriteToWAL has to be protected from concurretn calls
-  // from the two queues anyway and wal_write_mutex_ is already held. Otherwise
+  // from the two queues anyway and log_write_mutex_ is already held. Otherwise
  // if manual_wal_flush_ is enabled we need to protect log_writer->AddRecord
  // from possible concurrent calls via the FlushWAL by the application.
  const bool needs_locking = manual_wal_flush_ && !two_write_queues_;
@@ -1674,7 +1584,7 @@ IOStatus DBImpl::WriteToWAL(const WriteBatch& merged_batch,
  // manual_wal_flush_ feature (by UNLIKELY) instead of the more common case
  // when we do not need any locking.
  if (UNLIKELY(needs_locking)) {
-    wal_write_mutex_.Lock();
+    log_write_mutex_.Lock();
  }
  IOStatus io_s = log_writer->MaybeAddUserDefinedTimestampSizeRecord(
      write_options, versions_->GetColumnFamiliesTimestampSizeForRecord());
@@ -1684,24 +1594,23 @@ IOStatus DBImpl::WriteToWAL(const WriteBatch& merged_batch,
  io_s = log_writer->AddRecord(write_options, log_entry, sequence);

  if (UNLIKELY(needs_locking)) {
-    wal_write_mutex_.Unlock();
+    log_write_mutex_.Unlock();
  }
-  if (wal_used != nullptr) {
-    *wal_used = cur_wal_number_;
-    assert(*wal_used == wal_file_number_size.number);
+  if (log_used != nullptr) {
+    *log_used = logfile_number_;
  }
-  wals_total_size_.FetchAddRelaxed(log_entry.size());
-  wal_file_number_size.AddSize(*log_size);
-  wal_empty_ = false;
+  total_log_size_ += log_entry.size();
+  log_file_number_size.AddSize(*log_size);
+  log_empty_ = false;

  return io_s;
 }

-IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
-                                 log::Writer* log_writer, uint64_t* wal_used,
-                                 bool need_wal_sync, bool need_wal_dir_sync,
-                                 SequenceNumber sequence,
-                                 WalFileNumberSize& wal_file_number_size) {
+IOStatus DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
+                            log::Writer* log_writer, uint64_t* log_used,
+                            bool need_log_sync, bool need_log_dir_sync,
+                            SequenceNumber sequence,
+                            LogFileNumberSize& log_file_number_size) {
  IOStatus io_s;
  assert(!two_write_queues_);
  assert(!write_group.leader->disable_wal);
@@ -1716,10 +1625,10 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
  }

  if (merged_batch == write_group.leader->batch) {
-    write_group.leader->wal_used = cur_wal_number_;
+    write_group.leader->log_used = logfile_number_;
  } else if (write_with_wal > 1) {
    for (auto writer : write_group) {
-      writer->wal_used = cur_wal_number_;
+      writer->log_used = logfile_number_;
    }
  }

@@ -1731,14 +1640,14 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
  WriteOptions write_options;
  write_options.rate_limiter_priority =
      write_group.leader->rate_limiter_priority;
-  io_s = WriteToWAL(*merged_batch, write_options, log_writer, wal_used,
-                    &log_size, wal_file_number_size, sequence);
+  io_s = WriteToWAL(*merged_batch, write_options, log_writer, log_used,
+                    &log_size, log_file_number_size, sequence);
  if (to_be_cached_state) {
    cached_recoverable_state_ = *to_be_cached_state;
    cached_recoverable_state_empty_ = false;
  }

-  if (io_s.ok() && need_wal_sync) {
+  if (io_s.ok() && need_log_sync) {
    StopWatch sw(immutable_db_options_.clock, stats_, WAL_FILE_SYNC_MICROS);
    // It's safe to access logs_ with unlocked mutex_ here because:
    //  - we've set getting_synced=true for all logs,
@@ -1748,15 +1657,15 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
    //  - as long as other threads don't modify it, it's safe to read
    //    from std::deque from multiple threads concurrently.
    //
-    // Sync operation should work with locked wal_write_mutex_, because:
+    // Sync operation should work with locked log_write_mutex_, because:
    //   when DBOptions.manual_wal_flush_ is set,
    //   FlushWAL function will be invoked by another thread.
-    //   if without locked wal_write_mutex_, the log file may get data
+    //   if without locked log_write_mutex_, the log file may get data
    //   corruption

    const bool needs_locking = manual_wal_flush_ && !two_write_queues_;
    if (UNLIKELY(needs_locking)) {
-      wal_write_mutex_.Lock();
+      log_write_mutex_.Lock();
    }

    if (io_s.ok()) {
@@ -1779,10 +1688,10 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
    }

    if (UNLIKELY(needs_locking)) {
-      wal_write_mutex_.Unlock();
+      log_write_mutex_.Unlock();
    }

-    if (io_s.ok() && need_wal_dir_sync) {
+    if (io_s.ok() && need_log_dir_sync) {
      // We only sync WAL directory the first time WAL syncing is
      // requested, so that in case users never turn on WAL sync,
      // we can avoid the disk I/O in the write code path.
@@ -1797,7 +1706,7 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
  }
  if (io_s.ok()) {
    auto stats = default_cf_internal_stats_;
-    if (need_wal_sync) {
+    if (need_log_sync) {
      stats->AddDBStats(InternalStats::kIntStatsWalFileSynced, 1);
      RecordTick(stats_, WAL_FILE_SYNCED);
    }
@@ -1814,8 +1723,8 @@ IOStatus DBImpl::WriteGroupToWAL(const WriteThread::WriteGroup& write_group,
  return io_s;
 }

-IOStatus DBImpl::ConcurrentWriteGroupToWAL(
-    const WriteThread::WriteGroup& write_group, uint64_t* wal_used,
+IOStatus DBImpl::ConcurrentWriteToWAL(
+    const WriteThread::WriteGroup& write_group, uint64_t* log_used,
    SequenceNumber* last_sequence, size_t seq_inc) {
  IOStatus io_s;

@@ -1832,14 +1741,14 @@ IOStatus DBImpl::ConcurrentWriteGroupToWAL(
    return io_s;
  }

-  // We need to lock wal_write_mutex_ since logs_ and alive_wal_files might be
+  // We need to lock log_write_mutex_ since logs_ and alive_log_files might be
  // pushed back concurrently
-  wal_write_mutex_.Lock();
+  log_write_mutex_.Lock();
  if (merged_batch == write_group.leader->batch) {
-    write_group.leader->wal_used = cur_wal_number_;
+    write_group.leader->log_used = logfile_number_;
  } else if (write_with_wal > 1) {
    for (auto writer : write_group) {
-      writer->wal_used = cur_wal_number_;
+      writer->log_used = logfile_number_;
    }
  }
  *last_sequence = versions_->FetchAddLastAllocatedSequence(seq_inc);
@@ -1847,9 +1756,9 @@ IOStatus DBImpl::ConcurrentWriteGroupToWAL(
  WriteBatchInternal::SetSequence(merged_batch, sequence);

  log::Writer* log_writer = logs_.back().writer;
-  WalFileNumberSize& wal_file_number_size = alive_wal_files_.back();
+  LogFileNumberSize& log_file_number_size = alive_log_files_.back();

-  assert(log_writer->get_log_number() == wal_file_number_size.number);
+  assert(log_writer->get_log_number() == log_file_number_size.number);

  uint64_t log_size;

@@ -1857,13 +1766,13 @@ IOStatus DBImpl::ConcurrentWriteGroupToWAL(
  WriteOptions write_options;
  write_options.rate_limiter_priority =
      write_group.leader->rate_limiter_priority;
-  io_s = WriteToWAL(*merged_batch, write_options, log_writer, wal_used,
-                    &log_size, wal_file_number_size, sequence);
+  io_s = WriteToWAL(*merged_batch, write_options, log_writer, log_used,
+                    &log_size, log_file_number_size, sequence);
  if (to_be_cached_state) {
    cached_recoverable_state_ = *to_be_cached_state;
    cached_recoverable_state_empty_ = false;
  }
-  wal_write_mutex_.Unlock();
+  log_write_mutex_.Unlock();

  if (io_s.ok()) {
    const bool concurrent = true;
@@ -1891,7 +1800,7 @@ Status DBImpl::WriteRecoverableState() {
    bool dont_care_bool;
    SequenceNumber next_seq;
    if (two_write_queues_) {
-      wal_write_mutex_.Lock();
+      log_write_mutex_.Lock();
    }
    SequenceNumber seq;
    if (two_write_queues_) {
@@ -1906,17 +1815,13 @@ Status DBImpl::WriteRecoverableState() {
        0 /*recovery_log_number*/, this, false /* concurrent_memtable_writes */,
        &next_seq, &dont_care_bool, seq_per_batch_);
    auto last_seq = next_seq - 1;
-    if (status.ok()) {  // Don't publish a partial batch write
-      if (two_write_queues_) {
-        versions_->FetchAddLastAllocatedSequence(last_seq - seq);
-        versions_->SetLastPublishedSequence(last_seq);
-      }
-      versions_->SetLastSequence(last_seq);
-    } else {
-      HandleMemTableInsertFailure(status);
-    }
    if (two_write_queues_) {
-      wal_write_mutex_.Unlock();
+      versions_->FetchAddLastAllocatedSequence(last_seq - seq);
+      versions_->SetLastPublishedSequence(last_seq);
+    }
+    versions_->SetLastSequence(last_seq);
+    if (two_write_queues_) {
+      log_write_mutex_.Unlock();
    }
    if (status.ok() && recoverable_state_pre_release_callback_) {
      const bool DISABLE_MEMTABLE = true;
@@ -1988,10 +1893,7 @@ void DBImpl::AssignAtomicFlushSeq(const autovector<ColumnFamilyData*>& cfds) {
  assert(immutable_db_options_.atomic_flush);
  auto seq = versions_->LastSequence();
  for (auto cfd : cfds) {
-    // cfd can be nullptr, see ScheduleFlushes()
-    if (cfd) {
-      cfd->imm()->AssignAtomicFlushSeq(seq);
-    }
+    cfd->imm()->AssignAtomicFlushSeq(seq);
  }
 }

@@ -2000,11 +1902,11 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
  assert(write_context != nullptr);
  Status status;

-  if (alive_wal_files_.begin()->getting_flushed) {
+  if (alive_log_files_.begin()->getting_flushed) {
    return status;
  }

-  auto oldest_alive_log = alive_wal_files_.begin()->number;
+  auto oldest_alive_log = alive_log_files_.begin()->number;
  bool flush_wont_release_oldest_log = false;
  if (allow_2pc()) {
    auto oldest_log_with_uncommitted_prep =
@@ -2034,14 +1936,14 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
    // transactions then we cannot flush this log until those transactions are
    // commited.
    unable_to_release_oldest_log_ = false;
-    alive_wal_files_.begin()->getting_flushed = true;
+    alive_log_files_.begin()->getting_flushed = true;
  }

  ROCKS_LOG_INFO(
      immutable_db_options_.info_log,
      "Flushing all column families with data in WAL number %" PRIu64
      ". Total log size is %" PRIu64 " while max_total_wal_size is %" PRIu64,
-      oldest_alive_log, wals_total_size_.LoadRelaxed(), GetMaxTotalWalSize());
+      oldest_alive_log, total_log_size_.load(), GetMaxTotalWalSize());
  // no need to refcount because drop is happening in write thread, so can't
  // happen while we're in the write thread
  autovector<ColumnFamilyData*> cfds;
@@ -2511,21 +2413,21 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  // Do this without holding the dbmutex lock.
  assert(versions_->prev_log_number() == 0);
  if (two_write_queues_) {
-    wal_write_mutex_.Lock();
+    log_write_mutex_.Lock();
  }
-  bool creating_new_log = !wal_empty_;
+  bool creating_new_log = !log_empty_;
  if (two_write_queues_) {
-    wal_write_mutex_.Unlock();
+    log_write_mutex_.Unlock();
  }
  uint64_t recycle_log_number = 0;
  // If file deletion is disabled, don't recycle logs since it'll result in
  // the file getting renamed
  if (creating_new_log && immutable_db_options_.recycle_log_file_num &&
-      !wal_recycle_files_.empty() && IsFileDeletionsEnabled()) {
-    recycle_log_number = wal_recycle_files_.front();
+      !log_recycle_files_.empty() && IsFileDeletionsEnabled()) {
+    recycle_log_number = log_recycle_files_.front();
  }
  uint64_t new_log_number =
-      creating_new_log ? versions_->NewFileNumber() : cur_wal_number_;
+      creating_new_log ? versions_->NewFileNumber() : logfile_number_;
  // For use outside of holding DB mutex
  const MutableCFOptions mutable_cf_options_copy =
      cfd->GetLatestMutableCFOptions();
@@ -2551,14 +2453,14 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
  mutex_.Unlock();
  if (creating_new_log) {
    PredecessorWALInfo info;
-    wal_write_mutex_.Lock();
+    log_write_mutex_.Lock();
    if (!logs_.empty()) {
      log::Writer* cur_log_writer = logs_.back().writer;
      info = PredecessorWALInfo(cur_log_writer->get_log_number(),
                                cur_log_writer->file()->GetFileSize(),
                                cur_log_writer->GetLastSeqnoRecorded());
    }
-    wal_write_mutex_.Unlock();
+    log_write_mutex_.Unlock();
    // TODO: Write buffer size passed in should be max of all CF's instead
    // of mutable_cf_options.write_buffer_size.
    io_s = CreateWAL(write_options, new_log_number, recycle_log_number,
@@ -2599,11 +2501,11 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
    // concurrent full purges don't delete the file while we're recycling it.
    // To achieve that we hold the old log number in the recyclable list until
    // after it has been renamed.
-    assert(wal_recycle_files_.front() == recycle_log_number);
-    wal_recycle_files_.pop_front();
+    assert(log_recycle_files_.front() == recycle_log_number);
+    log_recycle_files_.pop_front();
  }
  if (s.ok() && creating_new_log) {
-    InstrumentedMutexLock l(&wal_write_mutex_);
+    InstrumentedMutexLock l(&log_write_mutex_);
    assert(new_log != nullptr);
    if (!logs_.empty()) {
      // Alway flush the buffer of the last log before switching to a new one
@@ -2625,11 +2527,11 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
      }
    }
    if (s.ok()) {
-      cur_wal_number_ = new_log_number;
-      wal_empty_ = true;
-      wal_dir_synced_ = false;
-      logs_.emplace_back(cur_wal_number_, new_log);
-      alive_wal_files_.emplace_back(cur_wal_number_);
+      logfile_number_ = new_log_number;
+      log_empty_ = true;
+      log_dir_synced_ = false;
+      logs_.emplace_back(logfile_number_, new_log);
+      alive_log_files_.emplace_back(logfile_number_);
    }
  }

@@ -2660,7 +2562,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
    // obsolete. So we should track the WAL obsoletion event before actually
    // updating the empty CF's log number.
    uint64_t min_wal_number_to_keep =
-        versions_->PreComputeMinLogNumberWithUnflushedData(cur_wal_number_);
+        versions_->PreComputeMinLogNumberWithUnflushedData(logfile_number_);
    if (min_wal_number_to_keep >
        versions_->GetWalSet().GetMinWalNumberToKeep()) {
      // TODO: plumb Env::IOActivity, Env::IOPriority
@@ -2695,7 +2597,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,

      for (auto cf : empty_cfs) {
        if (cf->IsEmpty()) {
-          cf->SetLogNumber(cur_wal_number_);
+          cf->SetLogNumber(logfile_number_);
          // MEMPURGE: No need to change this, because new adds
          // should still receive new sequence numbers.
          cf->mem()->SetCreationSeq(versions_->LastSequence());
@@ -2712,14 +2614,14 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
      // advance the log number. no need to persist this in the manifest
      if (cf->IsEmpty()) {
        if (creating_new_log) {
-          cf->SetLogNumber(cur_wal_number_);
+          cf->SetLogNumber(logfile_number_);
        }
        cf->mem()->SetCreationSeq(versions_->LastSequence());
      }
    }
  }

-  cfd->mem()->SetNextLogNumber(cur_wal_number_);
+  cfd->mem()->SetNextLogNumber(logfile_number_);
  assert(new_mem != nullptr);
  cfd->imm()->Add(cfd->mem(), &context->memtables_to_free_);
  if (new_imm) {
@@ -2731,7 +2633,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
    // we always try to flush all immutable memtable. For atomic flush, these
    // two memtables will be marked eligible for flush in the same call to
    // AssignAtomicFlushSeq().
-    new_imm->SetNextLogNumber(cur_wal_number_);
+    new_imm->SetNextLogNumber(logfile_number_);
    cfd->imm()->Add(new_imm, &context->memtables_to_free_);
  }
  new_mem->Ref();
@@ -7,8 +7,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

-#include <iomanip>
-
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "test_util/testutil.h"
@@ -9,6 +9,7 @@

 #include "db/db_iter.h"

+#include <iostream>
 #include <limits>
 #include <string>

@@ -41,8 +42,9 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
               const MutableCFOptions& mutable_cf_options,
               const Comparator* cmp, InternalIterator* iter,
               const Version* version, SequenceNumber s, bool arena_mode,
+               uint64_t max_sequential_skip_in_iterations,
               ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
-               bool expose_blob_index, ReadOnlyMemTable* active_mem)
+               bool expose_blob_index)
    : prefix_extractor_(mutable_cf_options.prefix_extractor.get()),
      env_(_env),
      clock_(ioptions.clock),
@@ -56,21 +58,11 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
      read_callback_(read_callback),
      sequence_(s),
      statistics_(ioptions.stats),
-      max_skip_(mutable_cf_options.max_sequential_skip_in_iterations),
+      max_skip_(max_sequential_skip_in_iterations),
      max_skippable_internal_keys_(read_options.max_skippable_internal_keys),
      num_internal_keys_skipped_(0),
      iterate_lower_bound_(read_options.iterate_lower_bound),
      iterate_upper_bound_(read_options.iterate_upper_bound),
-      cfh_(cfh),
-      timestamp_ub_(read_options.timestamp),
-      timestamp_lb_(read_options.iter_start_ts),
-      timestamp_size_(timestamp_ub_ ? timestamp_ub_->size() : 0),
-      active_mem_(active_mem),
-      memtable_seqno_lb_(kMaxSequenceNumber),
-      memtable_op_scan_flush_trigger_(0),
-      avg_op_scan_flush_trigger_(0),
-      iter_step_since_seek_(1),
-      mem_hidden_op_scanned_since_seek_(0),
      direction_(kForward),
      valid_(false),
      current_entry_is_merged_(false),
@@ -84,7 +76,11 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
      expose_blob_index_(expose_blob_index),
      allow_unprepared_value_(read_options.allow_unprepared_value),
      is_blob_(false),
-      arena_mode_(arena_mode) {
+      arena_mode_(arena_mode),
+      cfh_(cfh),
+      timestamp_ub_(read_options.timestamp),
+      timestamp_lb_(read_options.iter_start_ts),
+      timestamp_size_(timestamp_ub_ ? timestamp_ub_->size() : 0) {
  RecordTick(statistics_, NO_ITERATOR_CREATED);
  if (pin_thru_lifetime_) {
    pinned_iters_mgr_.StartPinning();
@@ -98,25 +94,6 @@ DBIter::DBIter(Env* _env, const ReadOptions& read_options,
  // 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);
-  if (active_mem_) {
-    // FIXME: GetEarliestSequenceNumber() may return a seqno that is one smaller
-    // than the smallest seqno in the memtable. This violates its comment and
-    // entries with that seqno may not be in the active memtable. Before it's
-    // fixed, we use GetFirstSequenceNumber() for more accurate result.
-    memtable_seqno_lb_ = active_mem_->IsEmpty()
-                             ? active_mem_->GetEarliestSequenceNumber()
-                             : active_mem_->GetFirstSequenceNumber();
-    memtable_op_scan_flush_trigger_ =
-        mutable_cf_options.memtable_op_scan_flush_trigger;
-    if (memtable_op_scan_flush_trigger_) {
-      // avg_op_scan_flush_trigger_ requires memtable_op_scan_flush_trigger_ > 0
-      avg_op_scan_flush_trigger_ =
-          mutable_cf_options.memtable_avg_op_scan_flush_trigger;
-    }
-  } else {
-    // memtable_op_scan_flush_trigger_ and avg_op_scan_flush_trigger_ are
-    // initialized to 0(disabled) as default.
-  }
 }

 Status DBIter::GetProperty(std::string prop_name, std::string* prop) {
@@ -178,7 +155,6 @@ void DBIter::Next() {
  local_stats_.skip_count_ += num_internal_keys_skipped_;
  local_stats_.skip_count_--;
  num_internal_keys_skipped_ = 0;
-  iter_step_since_seek_++;
  bool ok = true;
  if (direction_ == kReverse) {
    is_key_seqnum_zero_ = false;
@@ -393,7 +369,6 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
  // to one.
  bool reseek_done = false;

-  uint64_t mem_hidden_op_scanned = 0;
  do {
    // Will update is_key_seqnum_zero_ as soon as we parsed the current key
    // but we need to save the previous value to be used in the loop.
@@ -450,7 +425,6 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
          CompareKeyForSkip(ikey_.user_key, saved_key_.GetUserKey()) <= 0) {
        num_skipped++;  // skip this entry
        PERF_COUNTER_ADD(internal_key_skipped_count, 1);
-        MarkMemtableForFlushForPerOpTrigger(mem_hidden_op_scanned);
      } else {
        assert(!skipping_saved_key ||
               CompareKeyForSkip(ikey_.user_key, saved_key_.GetUserKey()) > 0);
@@ -472,7 +446,6 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
                                      !iter_.iter()->IsKeyPinned() /* copy */);
              skipping_saved_key = true;
              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
-              MarkMemtableForFlushForPerOpTrigger(mem_hidden_op_scanned);
            }
            break;
          case kTypeValue:
@@ -511,6 +484,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,

            valid_ = true;
            return true;
+            break;
          case kTypeMerge:
            if (!PrepareValueInternal()) {
              return false;
@@ -522,6 +496,7 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
            current_entry_is_merged_ = true;
            valid_ = true;
            return MergeValuesNewToOld();  // Go to a different state machine
+            break;
          default:
            valid_ = false;
            status_ = Status::Corruption(
@@ -1122,6 +1097,7 @@ bool DBIter::FindValueForCurrentKey() {
        }
        return true;
      }
+      break;
    case kTypeValue:
    case kTypeValuePreferredSeqno:
      SetValueAndColumnsFromPlain(pinned_value_);
@@ -1248,8 +1224,6 @@ bool DBIter::FindValueForCurrentKeyUsingSeek() {

    if (timestamp_lb_ != nullptr) {
      saved_key_.SetInternalKey(ikey);
-    } else {
-      saved_key_.SetUserKey(ikey.user_key);
    }

    valid_ = true;
@@ -1594,7 +1568,6 @@ void DBIter::Seek(const Slice& target) {
  ResetBlobData();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
-  MarkMemtableForFlushForAvgTrigger();

  // Seek the inner iterator based on the target key.
  {
@@ -1671,7 +1644,6 @@ void DBIter::SeekForPrev(const Slice& target) {
  ResetBlobData();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
-  MarkMemtableForFlushForAvgTrigger();

  // Seek the inner iterator based on the target key.
  {
@@ -1733,7 +1705,6 @@ void DBIter::SeekToFirst() {
  ResetBlobData();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
-  MarkMemtableForFlushForAvgTrigger();
  ClearSavedValue();
  is_key_seqnum_zero_ = false;

@@ -1797,7 +1768,6 @@ void DBIter::SeekToLast() {
  ResetBlobData();
  ResetValueAndColumns();
  ResetInternalKeysSkippedCounter();
-  MarkMemtableForFlushForAvgTrigger();
  ClearSavedValue();
  is_key_seqnum_zero_ = false;

@@ -1820,4 +1790,21 @@ void DBIter::SeekToLast() {
        StripTimestampFromUserKey(saved_key_.GetUserKey(), timestamp_size_)));
  }
 }
+
+Iterator* NewDBIterator(Env* env, const ReadOptions& read_options,
+                        const ImmutableOptions& ioptions,
+                        const MutableCFOptions& mutable_cf_options,
+                        const Comparator* user_key_comparator,
+                        InternalIterator* internal_iter, const Version* version,
+                        const SequenceNumber& sequence,
+                        uint64_t max_sequential_skip_in_iterations,
+                        ReadCallback* read_callback,
+                        ColumnFamilyHandleImpl* cfh, bool expose_blob_index) {
+  DBIter* db_iter = new DBIter(
+      env, read_options, ioptions, mutable_cf_options, user_key_comparator,
+      internal_iter, version, sequence, false,
+      max_sequential_skip_in_iterations, read_callback, cfh, expose_blob_index);
+  return db_iter;
+}
+
 }  // namespace ROCKSDB_NAMESPACE
@@ -12,6 +12,7 @@
 #include <string>

 #include "db/db_impl/db_impl.h"
+#include "db/range_del_aggregator.h"
 #include "memory/arena.h"
 #include "options/cf_options.h"
 #include "rocksdb/db.h"
@@ -56,34 +57,6 @@ class Version;
 // numbers, deletion markers, overwrites, etc.
 class DBIter final : public Iterator {
 public:
-  // Return a new DBIter that reads from `internal_iter` at the specified
-  // `sequence` number.
-  //
-  // @param active_mem Pointer to the active memtable that `internal_iter`
-  // is reading from. If not null, the memtable can be marked for flush
-  // according to options mutable_cf_options.memtable_op_scan_flush_trigger
-  // and mutable_cf_options.memtable_avg_op_scan_flush_trigger.
-  // @param arena_mode If true, the DBIter will be allocated from the arena.
-  static DBIter* NewIter(Env* env, const ReadOptions& read_options,
-                         const ImmutableOptions& ioptions,
-                         const MutableCFOptions& mutable_cf_options,
-                         const Comparator* user_key_comparator,
-                         InternalIterator* internal_iter,
-                         const Version* version, const SequenceNumber& sequence,
-                         ReadCallback* read_callback,
-                         ReadOnlyMemTable* active_mem,
-                         ColumnFamilyHandleImpl* cfh = nullptr,
-                         bool expose_blob_index = false,
-                         Arena* arena = nullptr) {
-    void* mem = arena ? arena->AllocateAligned(sizeof(DBIter))
-                      : operator new(sizeof(DBIter));
-    DBIter* db_iter = new (mem)
-        DBIter(env, read_options, ioptions, mutable_cf_options,
-               user_key_comparator, internal_iter, version, sequence, arena,
-               read_callback, cfh, expose_blob_index, active_mem);
-    return db_iter;
-  }
-
  // The following is grossly complicated. TODO: clean it up
  // Which direction is the iterator currently moving?
  // (1) When moving forward:
@@ -140,12 +113,19 @@ class DBIter final : public Iterator {
    uint64_t skip_count_;
  };

+  DBIter(Env* _env, const ReadOptions& read_options,
+         const ImmutableOptions& ioptions,
+         const MutableCFOptions& mutable_cf_options, const Comparator* cmp,
+         InternalIterator* iter, const Version* version, SequenceNumber s,
+         bool arena_mode, uint64_t max_sequential_skip_in_iterations,
+         ReadCallback* read_callback, ColumnFamilyHandleImpl* cfh,
+         bool expose_blob_index);
+
  // No copying allowed
  DBIter(const DBIter&) = delete;
  void operator=(const DBIter&) = delete;

  ~DBIter() override {
-    MarkMemtableForFlushForAvgTrigger();
    ThreadStatus::OperationType cur_op_type =
        ThreadStatusUtil::GetThreadOperation();
    ThreadStatusUtil::SetThreadOperation(
@@ -240,26 +220,7 @@ class DBIter final : public Iterator {

  bool PrepareValue() override;

-  void Prepare(const std::vector<ScanOptions>& scan_opts) override {
-    std::optional<std::vector<ScanOptions>> new_scan_opts;
-    new_scan_opts.emplace(scan_opts);
-    scan_opts_.swap(new_scan_opts);
-    if (!scan_opts.empty()) {
-      iter_.Prepare(&scan_opts_.value());
-    } else {
-      iter_.Prepare(nullptr);
-    }
-  }
-
 private:
-  DBIter(Env* _env, const ReadOptions& read_options,
-         const ImmutableOptions& ioptions,
-         const MutableCFOptions& mutable_cf_options, const Comparator* cmp,
-         InternalIterator* iter, const Version* version, SequenceNumber s,
-         bool arena_mode, ReadCallback* read_callback,
-         ColumnFamilyHandleImpl* cfh, bool expose_blob_index,
-         ReadOnlyMemTable* active_mem);
-
  class BlobReader {
   public:
    BlobReader(const Version* version, ReadTier read_tier,
@@ -418,36 +379,6 @@ class DBIter final : public Iterator {
    return true;
  }

-  void MarkMemtableForFlushForAvgTrigger() {
-    if (avg_op_scan_flush_trigger_ &&
-        mem_hidden_op_scanned_since_seek_ >= memtable_op_scan_flush_trigger_ &&
-        mem_hidden_op_scanned_since_seek_ >=
-            static_cast<uint64_t>(iter_step_since_seek_) *
-                avg_op_scan_flush_trigger_) {
-      assert(memtable_op_scan_flush_trigger_ > 0);
-      active_mem_->MarkForFlush();
-      avg_op_scan_flush_trigger_ = 0;
-      memtable_op_scan_flush_trigger_ = 0;
-    }
-    iter_step_since_seek_ = 1;
-    mem_hidden_op_scanned_since_seek_ = 0;
-  }
-
-  void MarkMemtableForFlushForPerOpTrigger(uint64_t& mem_hidden_op_scanned) {
-    if (memtable_op_scan_flush_trigger_ &&
-        ikey_.sequence >= memtable_seqno_lb_) {
-      if (++mem_hidden_op_scanned >= memtable_op_scan_flush_trigger_) {
-        active_mem_->MarkForFlush();
-        // Turn off the flush trigger checks.
-        memtable_op_scan_flush_trigger_ = 0;
-        avg_op_scan_flush_trigger_ = 0;
-      }
-      if (avg_op_scan_flush_trigger_) {
-        ++mem_hidden_op_scanned_since_seek_;
-      }
-    }
-  }
-
  const SliceTransform* prefix_extractor_;
  Env* const env_;
  SystemClock* clock_;
@@ -494,24 +425,6 @@ class DBIter final : public Iterator {
  IterKey prefix_;

  Status status_;
-  Slice lazy_blob_index_;
-
-  // List of operands for merge operator.
-  MergeContext merge_context_;
-  LocalStatistics local_stats_;
-  PinnedIteratorsManager pinned_iters_mgr_;
-  ColumnFamilyHandleImpl* cfh_;
-  const Slice* const timestamp_ub_;
-  const Slice* const timestamp_lb_;
-  const size_t timestamp_size_;
-  std::string saved_timestamp_;
-  std::optional<std::vector<ScanOptions>> scan_opts_;
-  ReadOnlyMemTable* const active_mem_;
-  SequenceNumber memtable_seqno_lb_;
-  uint32_t memtable_op_scan_flush_trigger_;
-  uint32_t avg_op_scan_flush_trigger_;
-  uint32_t iter_step_since_seek_;
-  uint32_t mem_hidden_op_scanned_since_seek_;
  Direction direction_;
  bool valid_;
  bool current_entry_is_merged_;
@@ -530,7 +443,29 @@ class DBIter final : public Iterator {
  // the stacked BlobDB implementation is used, false otherwise.
  bool expose_blob_index_;
  bool allow_unprepared_value_;
+  Slice lazy_blob_index_;
  bool is_blob_;
  bool arena_mode_;
+  // List of operands for merge operator.
+  MergeContext merge_context_;
+  LocalStatistics local_stats_;
+  PinnedIteratorsManager pinned_iters_mgr_;
+  ColumnFamilyHandleImpl* cfh_;
+  const Slice* const timestamp_ub_;
+  const Slice* const timestamp_lb_;
+  const size_t timestamp_size_;
+  std::string saved_timestamp_;
 };
+
+// Return a new iterator that converts internal keys (yielded by
+// "*internal_iter") that were live at the specified `sequence` number
+// into appropriate user keys.
+Iterator* NewDBIterator(
+    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    const MutableCFOptions& mutable_cf_options,
+    const Comparator* user_key_comparator, InternalIterator* internal_iter,
+    const Version* version, const SequenceNumber& sequence,
+    uint64_t max_sequential_skip_in_iterations, ReadCallback* read_callback,
+    ColumnFamilyHandleImpl* cfh = nullptr, bool expose_blob_index = false);
+
 }  // namespace ROCKSDB_NAMESPACE
@@ -528,11 +528,12 @@ TEST_F(DBIteratorStressTest, StressTest) {
                  internal_iter->target_hidden_fraction =
                      target_hidden_fraction;
                  internal_iter->trace = trace;
-                  db_iter.reset(DBIter::NewIter(
+                  db_iter.reset(NewDBIterator(
                      env_, ropt, ImmutableOptions(options),
                      MutableCFOptions(options), BytewiseComparator(),
-                      internal_iter, /*version=*/nullptr, sequence,
-                      nullptr /*read_callback*/, /*active_mem=*/nullptr));
+                      internal_iter, nullptr /* version */, sequence,
+                      options.max_sequential_skip_in_iterations,
+                      nullptr /*read_callback*/));
                }

                // Do a random operation. It's important to do it on ref_it
@@ -259,10 +259,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -293,10 +294,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -320,10 +322,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -353,10 +356,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -389,10 +393,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

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

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 7 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    SetPerfLevel(kEnableCount);
    ASSERT_TRUE(GetPerfLevel() == kEnableCount);
@@ -459,10 +465,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 4 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -485,10 +492,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

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

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -545,10 +554,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    ReadOptions ro;
    ro.iterate_upper_bound = &prefix;

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 7 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    SetPerfLevel(kEnableCount);
    ASSERT_TRUE(GetPerfLevel() == kEnableCount);
@@ -576,10 +586,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -620,10 +631,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 2 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -652,10 +664,11 @@ TEST_F(DBIteratorTest, DBIteratorPrevNext) {
    internal_iter->Finish();

    ReadOptions ro;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -683,10 +696,11 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 0 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
    ASSERT_OK(db_iter->status());
@@ -696,10 +710,11 @@ TEST_F(DBIteratorTest, DBIteratorEmpty) {
    TestIterator* internal_iter = new TestIterator(BytewiseComparator());
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 0 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToFirst();
    ASSERT_TRUE(!db_iter->Valid());
    ASSERT_OK(db_iter->status());
@@ -720,10 +735,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkipCountSkips) {
  }
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      2 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      2 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -766,11 +782,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      internal_iter->Finish();

      options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, i + 2 /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -804,11 +820,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      internal_iter->AddPut("c", "200");
      internal_iter->Finish();

-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, i + 2 /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -835,10 +851,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      internal_iter->AddPut("c", "200");
      internal_iter->Finish();

-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, 202 /* sequence */,
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -869,11 +886,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      }
      internal_iter->AddPut("c", "200");
      internal_iter->Finish();
-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, i /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(!db_iter->Valid());
      ASSERT_OK(db_iter->status());
@@ -889,10 +906,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
    }
    internal_iter->AddPut("c", "200");
    internal_iter->Finish();
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 200 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -926,11 +944,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      }
      internal_iter->Finish();

-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, i + 2 /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -963,11 +981,11 @@ TEST_F(DBIteratorTest, DBIteratorUseSkip) {
      }
      internal_iter->Finish();

-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, i + 2 /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));
      db_iter->SeekToLast();
      ASSERT_TRUE(db_iter->Valid());

@@ -1015,10 +1033,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 0;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1062,10 +1081,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1107,10 +1127,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1146,10 +1167,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1182,10 +1204,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -1213,10 +1236,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1251,10 +1275,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
    internal_iter->Finish();

    ro.max_skippable_internal_keys = 2;
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    ASSERT_TRUE(db_iter->Valid());
@@ -1289,11 +1314,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {
      internal_iter->Finish();

      ro.max_skippable_internal_keys = i;
-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */,
-
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));

      db_iter->SeekToFirst();
      ASSERT_TRUE(db_iter->Valid());
@@ -1344,10 +1369,11 @@ TEST_F(DBIteratorTest, DBIteratorSkipInternalKeys) {

      options.max_sequential_skip_in_iterations = 1000;
      ro.max_skippable_internal_keys = i;
-      std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
-          env_, ro, ioptions, MutableCFOptions(options), BytewiseComparator(),
+      std::unique_ptr<Iterator> db_iter(NewDBIterator(
+          env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
          internal_iter, nullptr /* version */, 2 * i + 1 /* sequence */,
-          nullptr /* read_callback */, /*active_mem=*/nullptr));
+          options.max_sequential_skip_in_iterations,
+          nullptr /* read_callback */));

      db_iter->SeekToFirst();
      ASSERT_TRUE(db_iter->Valid());
@@ -1386,11 +1412,11 @@ TEST_F(DBIteratorTest, DBIteratorTimedPutBasic) {
  internal_iter->AddTimedPut("d", "3", /*write_unix_time=*/0);
  internal_iter->Finish();

-  options.max_sequential_skip_in_iterations = 1;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      7 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      7 /* sequence */, /*max_sequential_skip_in_iterations*/ 1,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1437,10 +1463,11 @@ TEST_F(DBIteratorTest, DBIterator1) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      1 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      1 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1466,10 +1493,11 @@ TEST_F(DBIteratorTest, DBIterator2) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      0 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      0 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1491,10 +1519,11 @@ TEST_F(DBIteratorTest, DBIterator3) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      2 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      2 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1516,10 +1545,11 @@ TEST_F(DBIteratorTest, DBIterator4) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      4 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      4 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1550,10 +1580,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 0 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1574,10 +1605,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 1 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1598,10 +1630,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 2 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1622,10 +1655,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 3 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1646,10 +1680,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 4 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1670,10 +1705,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 5 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1694,10 +1730,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 6 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1716,10 +1753,11 @@ TEST_F(DBIteratorTest, DBIterator5) {
    internal_iter->AddMerge("a", "merge_2");
    internal_iter->AddPut("b", "val_b");
    internal_iter->Finish();
-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 10 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->Seek("b");
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -1747,10 +1785,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 0 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1771,10 +1810,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 1 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1795,10 +1835,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 2 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1819,10 +1860,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 3 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(!db_iter->Valid());
    ASSERT_OK(db_iter->status());
@@ -1839,10 +1881,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 4 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1863,10 +1906,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 5 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1887,10 +1931,11 @@ TEST_F(DBIteratorTest, DBIterator6) {
    internal_iter->AddMerge("a", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 6 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1931,10 +1976,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 0 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
    ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -1967,10 +2013,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 2 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2009,10 +2056,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 4 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2051,10 +2099,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 5 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2098,10 +2147,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 6 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2146,10 +2196,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 7 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2188,10 +2239,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 9 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2236,10 +2288,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 13 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2285,10 +2338,11 @@ TEST_F(DBIteratorTest, DBIterator7) {
    internal_iter->AddDeletion("c");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
        env_, ro, ioptions, mutable_cf_options, BytewiseComparator(),
        internal_iter, nullptr /* version */, 14 /* sequence */,
-        nullptr /* read_callback */, /*active_mem=*/nullptr));
+        options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));
    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());

@@ -2317,10 +2371,11 @@ TEST_F(DBIteratorTest, DBIterator8) {
  internal_iter->AddPut("b", "0");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -2348,11 +2403,11 @@ TEST_F(DBIteratorTest, DBIterator9) {
    internal_iter->AddMerge("d", "merge_6");
    internal_iter->Finish();

-    std::unique_ptr<Iterator> db_iter(
-        DBIter::NewIter(env_, ro, ImmutableOptions(options),
-                        MutableCFOptions(options), BytewiseComparator(),
-                        internal_iter, nullptr /* version */, 10 /* sequence */,
-                        nullptr /* read_callback */, /*active_mem=*/nullptr));
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
+        env_, ro, ImmutableOptions(options), MutableCFOptions(options),
+        BytewiseComparator(), internal_iter, nullptr /* version */,
+        10 /* sequence */, options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToLast();
    ASSERT_TRUE(db_iter->Valid());
@@ -2416,10 +2471,11 @@ TEST_F(DBIteratorTest, DBIterator10) {
  internal_iter->AddPut("d", "4");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));

  db_iter->Seek("c");
  ASSERT_TRUE(db_iter->Valid());
@@ -2456,10 +2512,10 @@ TEST_F(DBIteratorTest, SeekToLastOccurrenceSeq0) {
  internal_iter->AddPut("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, 0 /* force seek */, nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -2486,10 +2542,11 @@ TEST_F(DBIteratorTest, DBIterator11) {
  internal_iter->AddMerge("b", "2");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      1 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      1 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));
  db_iter->SeekToFirst();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "a");
@@ -2514,10 +2571,10 @@ TEST_F(DBIteratorTest, DBIterator12) {
  internal_iter->AddSingleDeletion("b");
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, 0 /* force seek */, nullptr /* read_callback */));
  db_iter->SeekToLast();
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "c");
@@ -2553,11 +2610,11 @@ TEST_F(DBIteratorTest, DBIterator13) {
  internal_iter->AddPut(key, "8");
  internal_iter->Finish();

-  options.max_sequential_skip_in_iterations = 3;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      2 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      2 /* sequence */, 3 /* max_sequential_skip_in_iterations */,
+      nullptr /* read_callback */));
  db_iter->Seek("b");
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), key);
@@ -2583,11 +2640,11 @@ TEST_F(DBIteratorTest, DBIterator14) {
  internal_iter->AddPut("c", "9");
  internal_iter->Finish();

-  options.max_sequential_skip_in_iterations = 1;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      4 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      4 /* sequence */, 1 /* max_sequential_skip_in_iterations */,
+      nullptr /* read_callback */));
  db_iter->Seek("b");
  ASSERT_TRUE(db_iter->Valid());
  ASSERT_EQ(db_iter->key().ToString(), "b");
@@ -2623,12 +2680,11 @@ class DBIterWithMergeIterTest : public testing::Test {
    InternalIterator* merge_iter =
        NewMergingIterator(&icomp_, child_iters.data(), 2u);

-    options_.max_sequential_skip_in_iterations = 3;
-    db_iter_.reset(DBIter::NewIter(
+    db_iter_.reset(NewDBIterator(
        env_, ro_, ImmutableOptions(options_), MutableCFOptions(options_),
        BytewiseComparator(), merge_iter, nullptr /* version */,
-        8 /* read data earlier than seqId 8 */, nullptr /* read_callback */,
-        /*active_mem=*/nullptr));
+        8 /* read data earlier than seqId 8 */,
+        3 /* max iterators before reseek */, nullptr /* read_callback */));
  }

  Env* env_;
@@ -3064,10 +3120,11 @@ TEST_F(DBIteratorTest, SeekPrefixTombstones) {
  internal_iter->Finish();

  ro.prefix_same_as_start = true;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));

  int skipped_keys = 0;

@@ -3100,11 +3157,11 @@ TEST_F(DBIteratorTest, SeekToFirstLowerBound) {
    Slice lower_bound(lower_bound_str);
    ro.iterate_lower_bound = &lower_bound;
    Options options;
-    std::unique_ptr<Iterator> db_iter(
-        DBIter::NewIter(env_, ro, ImmutableOptions(options),
-                        MutableCFOptions(options), BytewiseComparator(),
-                        internal_iter, nullptr /* version */, 10 /* sequence */,
-                        nullptr /* read_callback */, /*active_mem=*/nullptr));
+    std::unique_ptr<Iterator> db_iter(NewDBIterator(
+        env_, ro, ImmutableOptions(options), MutableCFOptions(options),
+        BytewiseComparator(), internal_iter, nullptr /* version */,
+        10 /* sequence */, options.max_sequential_skip_in_iterations,
+        nullptr /* read_callback */));

    db_iter->SeekToFirst();
    if (i == kNumKeys + 1) {
@@ -3140,10 +3197,11 @@ TEST_F(DBIteratorTest, PrevLowerBound) {
  Slice lower_bound(lower_bound_str);
  ro.iterate_lower_bound = &lower_bound;
  Options options;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));

  db_iter->SeekToLast();
  for (int i = kNumKeys; i >= kLowerBound; --i) {
@@ -3168,10 +3226,11 @@ TEST_F(DBIteratorTest, SeekLessLowerBound) {
  Slice lower_bound(lower_bound_str);
  ro.iterate_lower_bound = &lower_bound;
  Options options;
-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ro, ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));

  auto before_lower_bound_str = std::to_string(kLowerBound - 1);
  Slice before_lower_bound(lower_bound_str);
@@ -3193,10 +3252,11 @@ TEST_F(DBIteratorTest, ReverseToForwardWithDisappearingKeys) {
  }
  internal_iter->Finish();

-  std::unique_ptr<Iterator> db_iter(DBIter::NewIter(
+  std::unique_ptr<Iterator> db_iter(NewDBIterator(
      env_, ReadOptions(), ImmutableOptions(options), MutableCFOptions(options),
      BytewiseComparator(), internal_iter, nullptr /* version */,
-      10 /* sequence */, nullptr /* read_callback */, /*active_mem=*/nullptr));
+      10 /* sequence */, options.max_sequential_skip_in_iterations,
+      nullptr /* read_callback */));

  db_iter->SeekForPrev("a");
  ASSERT_TRUE(db_iter->Valid());
@@ -8,8 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include <functional>
-#include <iomanip>
-#include <iostream>

 #include "db/arena_wrapped_db_iter.h"
 #include "db/db_iter.h"
@@ -3826,511 +3824,6 @@ TEST_F(DBIteratorTest, IteratorsConsistentViewExplicitSnapshot) {
  }
 }

-TEST_P(DBIteratorTest, MemtableOpsScanFlushTriggerWithSeek) {
-  // Tests that option memtable_op_scan_flush_trigger works when the limit
-  // is reached during a Seek() operation.
-  const int kTrigger = 10;
-  Random* r = Random::GetTLSInstance();
-
-  for (int trigger : {kTrigger, kTrigger + 1}) {
-    for (bool delete_only : {false, true}) {
-      Options options;
-      options.create_if_missing = true;
-      options.memtable_op_scan_flush_trigger = trigger;
-      options.level_compaction_dynamic_level_bytes = true;
-      DestroyAndReopen(options);
-
-      // Base data that will be covered by a consecutive sequence of tombstones.
-      int kNumKeys = delete_only ? kTrigger : kTrigger / 2;
-      for (int i = 0; i < kNumKeys; ++i) {
-        ASSERT_OK(Put(Key(i), r->RandomString(100)));
-      }
-      ASSERT_OK(Flush());
-      ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-      ASSERT_EQ(1, NumTableFilesAtLevel(6));
-
-      if (delete_only) {
-        for (int i = 0; i < kNumKeys; ++i) {
-          ASSERT_OK(SingleDelete(Key(i)));
-        }
-      } else {
-        for (int i = 0; i < kNumKeys; ++i) {
-          ASSERT_OK(Put(Key(i), r->RandomString(100)));
-        }
-        for (int i = 0; i < kNumKeys; ++i) {
-          ASSERT_OK(Delete(Key(i)));
-        }
-      }
-
-      SetPerfLevel(PerfLevel::kEnableCount);
-      get_perf_context()->Reset();
-      ReadOptions ro;
-      std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
-
-      // Seek to the first key, this will scan through all the tombstones and
-      // hidden puts
-      iter->Seek(Key(0));
-      ASSERT_FALSE(
-          iter->Valid());  // All keys are deleted, so iterator is not valid
-      ASSERT_OK(iter->status());
-      ASSERT_EQ(get_perf_context()->next_on_memtable_count, kTrigger);
-
-      // Skipping kNumTrigger memtable entries in a single iterator operation
-      // should mark the memtable for flush.
-      //
-      // At the end of a write, we check and update memtable to request a flush
-      ASSERT_OK(Put(Key(11), "val"));
-      // Before a write, we schedule memtables for flush if requested.
-      ASSERT_OK(Put(Key(12), "val"));
-      ASSERT_OK(db_->WaitForCompact({}));
-
-      if (trigger <= kTrigger) {
-        // Check if memtable was flushed due to scan trigger
-        ASSERT_EQ(1, NumTableFilesAtLevel(0));
-        uint64_t val = 0;
-        ASSERT_TRUE(
-            db_->GetIntProperty("rocksdb.num-deletes-active-mem-table", &val));
-        ASSERT_EQ(0, val);
-      } else {
-        ASSERT_EQ(0, NumTableFilesAtLevel(0));
-        uint64_t val = 0;
-        ASSERT_TRUE(
-            db_->GetIntProperty("rocksdb.num-deletes-active-mem-table", &val));
-        ASSERT_EQ(kNumKeys, val);
-      }
-    }
-  }
-}
-
-TEST_P(DBIteratorTest, MemtableOpsScanFlushTriggerWithNext) {
-  // Tests that option memtable_op_scan_flush_trigger works when the limit
-  // is reached during a Next() operation, and not trigger a flush when
-  // the limit is reached across multiple Next() operations.
-  const int kTrigger = 10;
-  Random* r = Random::GetTLSInstance();
-
-  for (int trigger : {kTrigger, kTrigger + 1}) {
-    for (bool delete_only : {false, true}) {
-      Options options;
-      options.create_if_missing = true;
-      options.memtable_op_scan_flush_trigger = trigger;
-      options.level_compaction_dynamic_level_bytes = true;
-      DestroyAndReopen(options);
-
-      // Base data that will be covered by a consecutive sequence of tombstones.
-      int kNumKeys = delete_only ? kTrigger : kTrigger / 2;
-      for (int i = 0; i <= kNumKeys; ++i) {
-        ASSERT_OK(Put(Key(i), r->RandomString(100)));
-      }
-      ASSERT_OK(Flush());
-      ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-      ASSERT_EQ(1, NumTableFilesAtLevel(6));
-
-      ASSERT_OK(Put(Key(0), "val"));
-      if (delete_only) {
-        for (int i = 1; i <= kNumKeys; ++i) {
-          ASSERT_OK(SingleDelete(Key(i)));
-        }
-      } else {
-        for (int i = 1; i <= kNumKeys; ++i) {
-          ASSERT_OK(Put(Key(i), r->RandomString(100)));
-        }
-        for (int i = 1; i <= kNumKeys; ++i) {
-          ASSERT_OK(Delete(Key(i)));
-        }
-      }
-
-      // Total number of tombstones and hidden puts scanned across multiple
-      // Next() operations below will be kTrigger, and it should not trigger a
-      // flush when the limit is kTrigger + 1.
-      ASSERT_OK(Put(Key(kNumKeys + 1), "v1"));
-      ASSERT_OK(Delete(Key(kNumKeys + 2)));
-      ASSERT_OK(Put(Key(kNumKeys + 3), "v3"));
-
-      SetPerfLevel(PerfLevel::kEnableCount);
-      get_perf_context()->Reset();
-      ReadOptions ro;
-      std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
-      iter->Seek(Key(0));
-      ASSERT_TRUE(iter->Valid());
-      ASSERT_EQ(iter->value(), "val");
-      ASSERT_OK(iter->status());
-      ASSERT_EQ(get_perf_context()->next_on_memtable_count, 0);
-      iter->Next();
-      // kTrigger tombstones and invisible puts and 1 for the visible put
-      ASSERT_EQ(get_perf_context()->next_on_memtable_count, kTrigger + 1);
-      iter->Next();
-      ASSERT_EQ(get_perf_context()->next_on_memtable_count, kTrigger + 3);
-
-      // Skipping kNumTrigger memtable entries in a single iterator operation
-      // should mark the memtable for flush.
-      //
-      // At the end of a write, we check and update memtable to request a flush
-      ASSERT_OK(Put(Key(11), "val"));
-      // Before a write, we schedule memtables for flush if requested.
-      ASSERT_OK(Put(Key(12), "val"));
-      ASSERT_OK(db_->WaitForCompact({}));
-
-      if (trigger <= kTrigger) {
-        // Check if memtable was flushed due to scan trigger
-        ASSERT_EQ(1, NumTableFilesAtLevel(0));
-        uint64_t val = 0;
-        ASSERT_TRUE(
-            db_->GetIntProperty("rocksdb.num-deletes-active-mem-table", &val));
-        ASSERT_EQ(0, val);
-      } else {
-        uint64_t val = 0;
-        ASSERT_TRUE(
-            db_->GetIntProperty("rocksdb.num-deletes-active-mem-table", &val));
-        ASSERT_EQ(kNumKeys + 1, val);
-      }
-    }
-  }
-}
-
-TEST_P(DBIteratorTest, AverageMemtableOpsScanFlushTrigger) {
-  // Tests option memtable_avg_op_scan_flush_trigger with
-  // long tombstone sequences.
-  Random* r = Random::GetTLSInstance();
-
-  const int kAvgTrigger = 10;
-  const int kMaxTrigger = 500;
-  Options options;
-  options.create_if_missing = true;
-  options.memtable_op_scan_flush_trigger = kMaxTrigger;
-  options.memtable_avg_op_scan_flush_trigger = kAvgTrigger;
-  options.level_compaction_dynamic_level_bytes = true;
-  DestroyAndReopen(options);
-
-  const int kNumKeys = 1000;
-  // Base data that will be covered by a consecutive sequence of tombstones.
-  for (int i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(Put(Key(i), r->RandomString(50)));
-  }
-  ASSERT_OK(Flush());
-  ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-  ASSERT_EQ(1, NumTableFilesAtLevel(6));
-
-  for (int i = 0; i < kNumKeys; ++i) {
-    // We issue slightly more deletions than kAvgTrigger between visible keys
-    // to ensure avg skipped entries exceed kAvgTrigger.
-    if (i % (kAvgTrigger + 2) != 0) {
-      ASSERT_OK(SingleDelete(Key(i)));
-    }
-  }
-
-  // Each operation, except the first Seek, is expected to see kAvgTrigger + 1
-  // tombstones (from the active memtable) before it finds the next visible key.
-  SetPerfLevel(PerfLevel::kEnableCount);
-  get_perf_context()->Reset();
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-  iter->Seek(Key(1));
-  ASSERT_EQ(get_perf_context()->next_on_memtable_count, kAvgTrigger + 1);
-  iter.reset();
-  // Should not flush since total entries skipped is below
-  // memtable_op_scan_flush_trigger
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(db_->WaitForCompact({}));
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-
-  get_perf_context()->Reset();
-  iter.reset(db_->NewIterator(ReadOptions()));
-  int num_ops = 1;
-  uint64_t num_skipped = 0;
-  iter->Seek(Key(0));
-  ASSERT_EQ(iter->key(), Key(0));
-  uint64_t last_memtable_next_count =
-      get_perf_context()->next_on_memtable_count;
-  iter->Next();
-  num_ops++;
-  while (iter->Valid()) {
-    ASSERT_OK(iter->status());
-    uint64_t num_skipped_in_op =
-        get_perf_context()->next_on_memtable_count - last_memtable_next_count;
-    ASSERT_GE(num_skipped_in_op, kAvgTrigger + 1);
-    last_memtable_next_count = get_perf_context()->next_on_memtable_count;
-    num_skipped += num_skipped_in_op;
-    iter->Next();
-    num_ops++;
-  }
-  // During iterator destruction we mark memtable for flush
-  iter.reset();
-
-  // avg trigger
-  ASSERT_GE(num_skipped, kAvgTrigger * num_ops);
-  // memtable_op_scan_flush_trigger
-  ASSERT_GE(num_skipped, kMaxTrigger);
-  // Average hidden entries scanned from memtable per operation is more than
-  // kAvgTrigger and the total skipped is more than
-  // memtable_op_scan_flush_trigger, the current memtable should be marked for
-  // flush. The following two writes will trigger the flush.
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  // Before a write, we schedule memtables for flush if requested.
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(db_->WaitForCompact({}));
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-}
-
-TEST_P(DBIteratorTest, AverageMemtableOpsScanFlushTriggerByOverwrites) {
-  // Tests option memtable_avg_op_scan_flush_trigger with overwrites to keys.
-  Random* r = Random::GetTLSInstance();
-
-  const int kAvgTrigger = 25;
-  Options options;
-  options.create_if_missing = true;
-  options.memtable_op_scan_flush_trigger = 250;
-  options.memtable_avg_op_scan_flush_trigger = kAvgTrigger;
-  options.level_compaction_dynamic_level_bytes = true;
-  DestroyAndReopen(options);
-
-  const int kNumKeys = 100;
-  // Base data that will be covered by a consecutive sequence of tombstones.
-  for (int i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(Put(Key(i), r->RandomString(50)));
-  }
-  ASSERT_OK(Flush());
-  ASSERT_OK(db_->CompactRange({}, nullptr, nullptr));
-  ASSERT_EQ(1, NumTableFilesAtLevel(6));
-
-  // One visible key every 10 keys.
-  // Each non-visible user key has 3 non-visible entries in the active memtable.
-  for (int i = 0; i < kNumKeys; ++i) {
-    if (i % 10 != 0) {
-      ASSERT_OK(Put(Key(i), r->RandomString(50)));
-      ASSERT_OK(Put(Key(i), r->RandomString(50)));
-      ASSERT_OK(Delete(Key(i)));
-    }
-  }
-
-  SetPerfLevel(PerfLevel::kEnableCount);
-  get_perf_context()->Reset();
-  ReadOptions ro;
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ro));
-  iter->Seek(Key(1));
-  ASSERT_GT(get_perf_context()->next_on_memtable_count, kAvgTrigger);
-  // Re-seek to trigger check for flush trigger
-  iter->Seek(Key(1));
-  // Should not flush since total entries skipped is below
-  // memtable_op_scan_flush_trigger
-  ASSERT_FALSE(static_cast<ColumnFamilyHandleImpl*>(db_->DefaultColumnFamily())
-                   ->cfd()
-                   ->mem()
-                   ->IsMarkedForFlush());
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(db_->WaitForCompact({}));
-  ASSERT_EQ(0, NumTableFilesAtLevel(0));
-  get_perf_context()->Reset();
-
-  int num_ops = 1;
-  iter->Seek(Key(1));
-  while (iter->Valid()) {
-    num_ops++;
-    iter->Next();
-  }
-  ASSERT_GT(get_perf_context()->next_on_memtable_count, num_ops * kAvgTrigger);
-
-  // Re-seek should check conditions for marking memtable for flush
-  iter->Seek(Key(80));
-
-  // Average hidden entries scanned from memtable per operation is 2.
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  // Before a write, we schedule memtables for flush if requested.
-  ASSERT_OK(Put(Key(0), "dummy write"));
-  ASSERT_OK(db_->WaitForCompact({}));
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-}
-
-class DBMultiScanIteratorTest : public DBTestBase,
-                                public ::testing::WithParamInterface<bool> {
- public:
-  DBMultiScanIteratorTest()
-      : DBTestBase("db_multi_scan_iterator_test", /*env_do_fsync=*/true) {}
-};
-
-INSTANTIATE_TEST_CASE_P(DBMultiScanIteratorTest, DBMultiScanIteratorTest,
-                        ::testing::Bool());
-
-TEST_P(DBMultiScanIteratorTest, BasicTest) {
-  // Create a file
-  for (int i = 0; i < 100; ++i) {
-    std::stringstream ss;
-    ss << std::setw(2) << std::setfill('0') << i;
-    ASSERT_OK(Put("k" + ss.str(), "val" + ss.str()));
-  }
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> key_ranges({"k03", "k10", "k25", "k50"});
-  ReadOptions ro;
-  ro.fill_cache = GetParam();
-  std::vector<ScanOptions> scan_options(
-      {ScanOptions(key_ranges[0], key_ranges[1]),
-       ScanOptions(key_ranges[2], key_ranges[3])});
-  ColumnFamilyHandle* cfh = dbfull()->DefaultColumnFamily();
-  std::unique_ptr<MultiScan> iter =
-      dbfull()->NewMultiScan(ro, cfh, scan_options);
-  try {
-    int idx = 0;
-    int count = 0;
-    for (auto range : *iter) {
-      for (auto it : range) {
-        ASSERT_GE(it.first.ToString().compare(key_ranges[idx]), 0);
-        ASSERT_LT(it.first.ToString().compare(key_ranges[idx + 1]), 0);
-        count++;
-      }
-      idx += 2;
-    }
-    ASSERT_EQ(count, 32);
-  } catch (MultiScanException& ex) {
-    // Make sure exception contains the status
-    ASSERT_NOK(ex.status());
-    std::cerr << "Iterator returned status " << ex.what();
-    abort();
-  } catch (std::logic_error& ex) {
-    std::cerr << "Iterator returned logic error " << ex.what();
-    abort();
-  }
-  iter.reset();
-
-  // Test the overlapping scan case
-  key_ranges[1] = "k30";
-  scan_options[0] = ScanOptions(key_ranges[0], key_ranges[1]);
-  iter = dbfull()->NewMultiScan(ro, cfh, scan_options);
-  try {
-    int idx = 0;
-    int count = 0;
-    for (auto range : *iter) {
-      for (auto it : range) {
-        ASSERT_GE(it.first.ToString().compare(key_ranges[idx]), 0);
-        ASSERT_LT(it.first.ToString().compare(key_ranges[idx + 1]), 0);
-        count++;
-      }
-      idx += 2;
-    }
-    ASSERT_EQ(count, 52);
-  } catch (MultiScanException& ex) {
-    // Make sure exception contains the status
-    ASSERT_NOK(ex.status());
-    std::cerr << "Iterator returned status " << ex.what();
-    abort();
-  } catch (std::logic_error& ex) {
-    std::cerr << "Iterator returned logic error " << ex.what();
-    abort();
-  }
-  iter.reset();
-
-  // Test the no limit scan case
-  scan_options[0] = ScanOptions(key_ranges[0]);
-  scan_options[1] = ScanOptions(key_ranges[2]);
-  iter = dbfull()->NewMultiScan(ro, cfh, scan_options);
-  try {
-    int idx = 0;
-    int count = 0;
-    for (auto range : *iter) {
-      for (auto it : range) {
-        ASSERT_GE(it.first.ToString().compare(key_ranges[idx]), 0);
-        if (it.first.ToString().compare(key_ranges[idx + 1]) == 0) {
-          break;
-        }
-        count++;
-      }
-      idx += 2;
-    }
-    ASSERT_EQ(count, 52);
-  } catch (MultiScanException& ex) {
-    // Make sure exception contains the status
-    ASSERT_NOK(ex.status());
-    std::cerr << "Iterator returned status " << ex.what();
-    abort();
-  } catch (std::logic_error& ex) {
-    std::cerr << "Iterator returned logic error " << ex.what();
-    abort();
-  }
-  iter.reset();
-}
-
-TEST_P(DBMultiScanIteratorTest, MixedBoundsTest) {
-  // Create a file
-  for (int i = 0; i < 100; ++i) {
-    std::stringstream ss;
-    ss << std::setw(2) << std::setfill('0') << i;
-    ASSERT_OK(Put("k" + ss.str(), "val" + ss.str()));
-  }
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> key_ranges(
-      {"k03", "k10", "k25", "k50", "k75", "k90"});
-  ReadOptions ro;
-  ro.fill_cache = GetParam();
-  std::vector<ScanOptions> scan_options(
-      {ScanOptions(key_ranges[0], key_ranges[1]), ScanOptions(key_ranges[2]),
-       ScanOptions(key_ranges[4], key_ranges[5])});
-  ColumnFamilyHandle* cfh = dbfull()->DefaultColumnFamily();
-  std::unique_ptr<MultiScan> iter =
-      dbfull()->NewMultiScan(ro, cfh, scan_options);
-  try {
-    int idx = 0;
-    int count = 0;
-    for (auto range : *iter) {
-      for (auto it : range) {
-        ASSERT_GE(it.first.ToString().compare(
-                      scan_options[idx].range.start->ToString()),
-                  0);
-        if (scan_options[idx].range.limit) {
-          ASSERT_LT(it.first.ToString().compare(
-                        scan_options[idx].range.limit->ToString()),
-                    0);
-        }
-        count++;
-      }
-      idx++;
-    }
-    ASSERT_EQ(count, 97);
-  } catch (MultiScanException& ex) {
-    // Make sure exception contains the status
-    ASSERT_NOK(ex.status());
-    std::cerr << "Iterator returned status " << ex.what();
-    abort();
-  } catch (std::logic_error& ex) {
-    std::cerr << "Iterator returned logic error " << ex.what();
-    abort();
-  }
-  iter.reset();
-
-  scan_options[0] = ScanOptions(key_ranges[0]);
-  scan_options[1] = ScanOptions(key_ranges[2], key_ranges[3]);
-  scan_options[2] = ScanOptions(key_ranges[4]);
-  iter = dbfull()->NewMultiScan(ro, cfh, scan_options);
-  try {
-    int idx = 0;
-    int count = 0;
-    for (auto range : *iter) {
-      for (auto it : range) {
-        ASSERT_GE(it.first.ToString().compare(
-                      scan_options[idx].range.start->ToString()),
-                  0);
-        if (scan_options[idx].range.limit) {
-          ASSERT_LT(it.first.ToString().compare(
-                        scan_options[idx].range.limit->ToString()),
-                    0);
-        }
-        count++;
-      }
-      idx++;
-    }
-    ASSERT_EQ(count, 147);
-  } catch (MultiScanException& ex) {
-    // Make sure exception contains the status
-    ASSERT_NOK(ex.status());
-    std::cerr << "Iterator returned status " << ex.what();
-    abort();
-  } catch (std::logic_error& ex) {
-    std::cerr << "Iterator returned logic error " << ex.what();
-    abort();
-  }
-  iter.reset();
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -312,12 +312,12 @@ TEST_P(DbKvChecksumTest, WriteToWALCorrupted) {
    // Corrupted write batch leads to read-only mode, so we have to
    // reopen for every attempt.
    Reopen(options);
-    auto log_size_pre_write = dbfull()->TEST_wals_total_size();
+    auto log_size_pre_write = dbfull()->TEST_total_log_size();

    SyncPoint::GetInstance()->EnableProcessing();
    ASSERT_TRUE(ExecuteWrite(nullptr /* cf_handle */).IsCorruption());
    // Confirm that nothing was written to WAL
-    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_wals_total_size());
+    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_total_log_size());
    ASSERT_TRUE(dbfull()->TEST_GetBGError().IsCorruption());
    SyncPoint::GetInstance()->DisableProcessing();

@@ -350,12 +350,12 @@ TEST_P(DbKvChecksumTest, WriteToWALWithColumnFamilyCorrupted) {
    // Corrupted write batch leads to read-only mode, so we have to
    // reopen for every attempt.
    ReopenWithColumnFamilies({kDefaultColumnFamilyName, "pikachu"}, options);
-    auto log_size_pre_write = dbfull()->TEST_wals_total_size();
+    auto log_size_pre_write = dbfull()->TEST_total_log_size();

    SyncPoint::GetInstance()->EnableProcessing();
    ASSERT_TRUE(ExecuteWrite(nullptr /* cf_handle */).IsCorruption());
    // Confirm that nothing was written to WAL
-    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_wals_total_size());
+    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_total_log_size());
    ASSERT_TRUE(dbfull()->TEST_GetBGError().IsCorruption());
    SyncPoint::GetInstance()->DisableProcessing();

@@ -487,7 +487,7 @@ TEST_P(DbKvChecksumTestMergedBatch, WriteToWALCorrupted) {
    // Reopen DB since it failed WAL write which lead to read-only mode
    Reopen(options);
    SyncPoint::GetInstance()->EnableProcessing();
-    auto log_size_pre_write = dbfull()->TEST_wals_total_size();
+    auto log_size_pre_write = dbfull()->TEST_total_log_size();
    leader_batch_and_status =
        GetWriteBatch(GetCFHandleToUse(nullptr, op_type1_),
                      8 /* protection_bytes_per_key */, op_type1_);
@@ -499,7 +499,7 @@ TEST_P(DbKvChecksumTestMergedBatch, WriteToWALCorrupted) {
    SyncPoint::GetInstance()->ClearCallBack("WriteThread::JoinBatchGroup:Wait");
    ASSERT_EQ(1, leader_count);
    // Nothing should have been written to WAL
-    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_wals_total_size());
+    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_total_log_size());
    ASSERT_TRUE(dbfull()->TEST_GetBGError().IsCorruption());

    corrupt_byte_offset++;
@@ -599,7 +599,7 @@ TEST_P(DbKvChecksumTestMergedBatch, WriteToWALWithColumnFamilyCorrupted) {
    // Reopen DB since it failed WAL write which lead to read-only mode
    ReopenWithColumnFamilies({kDefaultColumnFamilyName, "ramen"}, options);
    SyncPoint::GetInstance()->EnableProcessing();
-    auto log_size_pre_write = dbfull()->TEST_wals_total_size();
+    auto log_size_pre_write = dbfull()->TEST_total_log_size();
    leader_batch_and_status =
        GetWriteBatch(GetCFHandleToUse(handles_[1], op_type1_),
                      8 /* protection_bytes_per_key */, op_type1_);
@@ -612,7 +612,7 @@ TEST_P(DbKvChecksumTestMergedBatch, WriteToWALWithColumnFamilyCorrupted) {

    ASSERT_EQ(1, leader_count);
    // Nothing should have been written to WAL
-    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_wals_total_size());
+    ASSERT_EQ(log_size_pre_write, dbfull()->TEST_total_log_size());
    ASSERT_TRUE(dbfull()->TEST_GetBGError().IsCorruption());

    corrupt_byte_offset++;
@@ -424,96 +424,6 @@ TEST_F(DBMemTableTest, IntegrityChecks) {
    ASSERT_FALSE(iter->Valid());
  }
 }
-
-TEST_F(DBMemTableTest, VectorConcurrentInsert) {
-  Options options;
-  options.create_if_missing = true;
-  options.create_missing_column_families = true;
-  options.allow_concurrent_memtable_write = true;
-  options.memtable_factory.reset(new VectorRepFactory());
-  DestroyAndReopen(options);
-  CreateAndReopenWithCF({"cf1"}, options);
-
-  // Multi-threaded writes
-  {
-    WriteOptions write_options;
-    std::vector<port::Thread> threads;
-    for (int i = 0; i < 10; ++i) {
-      threads.emplace_back([&, i]() {
-        int start = i * 100;
-        int end = start + 100;
-        WriteBatch batch;
-        for (int j = start; j < end; ++j) {
-          ASSERT_OK(
-              batch.Put(handles_[0], Key(j), "value" + std::to_string(j)));
-        }
-        ASSERT_OK(db_->Write(write_options, &batch));
-      });
-    }
-    for (auto& t : threads) {
-      t.join();
-    }
-
-    std::unique_ptr<Iterator> iter(
-        db_->NewIterator(ReadOptions(), handles_[0]));
-    iter->SeekToFirst();
-    for (int i = 0; i < 1000; ++i) {
-      ASSERT_TRUE(iter->Valid());
-      ASSERT_EQ(iter->key().ToString(), Key(i));
-      ASSERT_EQ(iter->value().ToString(), "value" + std::to_string(i));
-      iter->Next();
-    }
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-  }
-
-  // Multi-threaded writes, multi CF
-  {
-    WriteOptions write_options;
-    std::vector<port::Thread> threads;
-    for (int i = 0; i < 10; ++i) {
-      threads.emplace_back([&, i]() {
-        int start = i * 100;
-        int end = start + 100;
-        WriteBatch batch;
-        for (int j = start; j < end; ++j) {
-          ASSERT_OK(batch.Put(handles_[0], Key(j), "CF0" + std::to_string(j)));
-          ASSERT_OK(batch.Put(handles_[1], Key(j), "CF1" + std::to_string(j)));
-        }
-        ASSERT_OK(db_->Write(write_options, &batch));
-      });
-    }
-
-    for (auto& t : threads) {
-      t.join();
-    }
-
-    std::unique_ptr<Iterator> iter0(
-        db_->NewIterator(ReadOptions(), handles_[0]));
-    std::unique_ptr<Iterator> iter1(
-        db_->NewIterator(ReadOptions(), handles_[1]));
-    iter0->SeekToFirst();
-    iter1->SeekToFirst();
-    for (int i = 0; i < 1000; ++i) {
-      ASSERT_TRUE(iter0->Valid());
-      ASSERT_EQ(iter0->key().ToString(), Key(i));
-      ASSERT_EQ(iter0->value().ToString(), "CF0" + std::to_string(i));
-      iter0->Next();
-
-      ASSERT_TRUE(iter1->Valid());
-      ASSERT_EQ(iter1->key().ToString(), Key(i));
-      ASSERT_EQ(iter1->value().ToString(), "CF1" + std::to_string(i));
-      iter1->Next();
-    }
-    ASSERT_FALSE(iter0->Valid());
-    ASSERT_OK(iter0->status());
-    ASSERT_FALSE(iter1->Valid());
-    ASSERT_OK(iter1->status());
-  }
-
-  ASSERT_OK(Flush(0));
-  ASSERT_OK(Flush(1));
-}
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -971,7 +971,7 @@ TEST_F(DBMergeOperatorTest, MaxSuccessiveMergesBaseValues) {

  // No base value
  {
-    const std::string key = "key1";
+    constexpr char key[] = "key1";

    ASSERT_OK(db_->Merge(WriteOptions(), db_->DefaultColumnFamily(), key, foo));
    ASSERT_OK(db_->Merge(WriteOptions(), db_->DefaultColumnFamily(), key, bar));
@@ -994,7 +994,7 @@ TEST_F(DBMergeOperatorTest, MaxSuccessiveMergesBaseValues) {

  // Plain base value
  {
-    const std::string key = "key2";
+    constexpr char key[] = "key2";

    ASSERT_OK(db_->Put(WriteOptions(), db_->DefaultColumnFamily(), key, foo));
    ASSERT_OK(db_->Merge(WriteOptions(), db_->DefaultColumnFamily(), key, bar));
@@ -1019,7 +1019,7 @@ TEST_F(DBMergeOperatorTest, MaxSuccessiveMergesBaseValues) {

  // Wide-column base value
  {
-    const std::string key = "key3";
+    constexpr char key[] = "key3";
    const WideColumns columns{{kDefaultWideColumnName, foo}, {bar, baz}};

    ASSERT_OK(db_->PutEntity(WriteOptions(), db_->DefaultColumnFamily(), key,
@@ -70,8 +70,7 @@ class DBOptionsTest : public DBTestBase {
    options.env = env_;
    ImmutableDBOptions db_options(options);
    test::RandomInitCFOptions(&options, options, rnd);
-    auto sanitized_options =
-        SanitizeCfOptions(db_options, /*read_only*/ false, options);
+    auto sanitized_options = SanitizeOptions(db_options, options);
    auto opt_map = GetMutableCFOptionsMap(sanitized_options);
    delete options.compaction_filter;
    return opt_map;
@@ -322,26 +321,31 @@ TEST_F(DBOptionsTest, SetWithCustomMemTableFactory) {
  }
  Options options;
  options.create_if_missing = true;
-  options.env = env_;
-  options.disable_auto_compactions = false;
+  // Try with fail_if_options_file_error=false/true to update the options
+  for (bool on_error : {false, true}) {
+    options.fail_if_options_file_error = on_error;
+    options.env = env_;
+    options.disable_auto_compactions = false;

-  options.memtable_factory.reset(new DummySkipListFactory());
-  Reopen(options);
+    options.memtable_factory.reset(new DummySkipListFactory());
+    Reopen(options);

-  ColumnFamilyHandle* cfh = dbfull()->DefaultColumnFamily();
-  ASSERT_OK(dbfull()->SetOptions(cfh, {{"disable_auto_compactions", "true"}}));
-  ColumnFamilyDescriptor cfd;
-  ASSERT_OK(cfh->GetDescriptor(&cfd));
-  ASSERT_STREQ(cfd.options.memtable_factory->Name(),
-               DummySkipListFactory::kClassName());
-  ColumnFamilyHandle* test = nullptr;
-  ASSERT_OK(dbfull()->CreateColumnFamily(options, "test", &test));
-  ASSERT_OK(test->GetDescriptor(&cfd));
-  ASSERT_STREQ(cfd.options.memtable_factory->Name(),
-               DummySkipListFactory::kClassName());
+    ColumnFamilyHandle* cfh = dbfull()->DefaultColumnFamily();
+    ASSERT_OK(
+        dbfull()->SetOptions(cfh, {{"disable_auto_compactions", "true"}}));
+    ColumnFamilyDescriptor cfd;
+    ASSERT_OK(cfh->GetDescriptor(&cfd));
+    ASSERT_STREQ(cfd.options.memtable_factory->Name(),
+                 DummySkipListFactory::kClassName());
+    ColumnFamilyHandle* test = nullptr;
+    ASSERT_OK(dbfull()->CreateColumnFamily(options, "test", &test));
+    ASSERT_OK(test->GetDescriptor(&cfd));
+    ASSERT_STREQ(cfd.options.memtable_factory->Name(),
+                 DummySkipListFactory::kClassName());

-  ASSERT_OK(dbfull()->DropColumnFamily(test));
-  delete test;
+    ASSERT_OK(dbfull()->DropColumnFamily(test));
+    delete test;
+  }
 }

 TEST_F(DBOptionsTest, SetBytesPerSync) {
@@ -377,8 +377,6 @@ TEST_F(DBPropertiesTest, AggregatedTableProperties) {
        NewBloomFilterPolicy(kBloomBitsPerKey, false));
    table_options.block_size = 1024;
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-    // The checks assume kTableCount number of files
-    options.disable_auto_compactions = true;

    DestroyAndReopen(options);

@@ -569,7 +567,7 @@ TEST_F(DBPropertiesTest, AggregatedTablePropertiesAtLevel) {
  options.target_file_size_base = 8192;
  options.max_bytes_for_level_base = 10000;
  options.max_bytes_for_level_multiplier = 2;
-  // The checks assume kTableCount number of files
+  // This ensures there no compaction happening when we call GetProperty().
  options.disable_auto_compactions = true;
  options.merge_operator.reset(new TestPutOperator());

@@ -160,7 +160,6 @@ TEST_F(DBSecondaryTest, NonExistingDb) {
 TEST_F(DBSecondaryTest, ReopenAsSecondary) {
  Options options;
  options.env = env_;
-  options.preserve_internal_time_seconds = 300;
  Reopen(options);
  ASSERT_OK(Put("foo", "foo_value"));
  ASSERT_OK(Put("bar", "bar_value"));
@@ -508,81 +507,6 @@ TEST_F(DBSecondaryTest, OpenAsSecondary) {
  verify_db_func("new_foo_value", "new_bar_value");
 }

-TEST_F(DBSecondaryTest, OptionsOverrideTest) {
-  Options options;
-  options.env = env_;
-  options.preserve_internal_time_seconds = 300;
-  options.compaction_readahead_size = 200;
-  options.blob_compaction_readahead_size = 100;
-  Reopen(options);
-
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_OK(Put("foo", "foo_value" + std::to_string(i)));
-    ASSERT_OK(Put("bar", "bar_value" + std::to_string(i)));
-    ASSERT_OK(Flush());
-  }
-
-  CompactionServiceInput input;
-
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-  for (auto& file : meta.levels[0].files) {
-    ASSERT_EQ(0, meta.levels[0].level);
-    input.input_files.push_back(file.name);
-  }
-  ASSERT_EQ(input.input_files.size(), 3);
-
-  input.output_level = 1;
-  input.options_file_number = dbfull()->GetVersionSet()->options_file_number();
-  input.cf_name = kDefaultColumnFamilyName;
-  ASSERT_OK(db_->GetDbIdentity(input.db_id));
-
-  ASSERT_EQ(db_->GetOptions().compaction_readahead_size, 200);
-  ASSERT_EQ(db_->GetOptions().blob_compaction_readahead_size, 100);
-
-  Close();
-
-  std::string compaction_input_binary;
-  ASSERT_OK(input.Write(&compaction_input_binary));
-  std::string compaction_result_binary;
-
-  CompactionServiceOptionsOverride override_options;
-  override_options.env = env_;
-  override_options.table_factory.reset(
-      NewBlockBasedTableFactory(BlockBasedTableOptions()));
-
-  ASSERT_OK(
-      StringToMap("compaction_readahead_size=8388608;"
-                  "blob_compaction_readahead_size=4194304;"
-                  "some_invalid_option=ignore_me;"
-                  "env=this_should_not_fail;"
-                  "max_open_files=100;",  // this should be always overriden as
-                                          // -1 in remote compaction
-                  &override_options.options_map));
-
-  bool verified = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "DBImplSecondary::OpenAndCompact::AfterOpenAsSecondary:0",
-      [&](void* arg) {
-        auto secondary_db = static_cast<DB*>(arg);
-        auto secondary_db_options = secondary_db->GetOptions();
-        // DBOption
-        ASSERT_EQ(secondary_db_options.compaction_readahead_size, 8388608);
-        ASSERT_EQ(secondary_db_options.max_open_files, -1);
-        // CFOption
-        ASSERT_EQ(secondary_db_options.blob_compaction_readahead_size, 4194304);
-        verified = true;
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(DB::OpenAndCompact(OpenAndCompactOptions(), dbname_,
-                               secondary_path_, compaction_input_binary,
-                               &compaction_result_binary, override_options));
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  ASSERT_TRUE(verified);
-}
-
 namespace {
 class TraceFileEnv : public EnvWrapper {
 public:
@@ -605,9 +529,6 @@ class TraceFileEnv : public EnvWrapper {
                  char* scratch) const override {
        return target_->Read(offset, n, result, scratch);
      }
-      Status GetFileSize(uint64_t* file_size) override {
-        return target_->GetFileSize(file_size);
-      }

     private:
      std::unique_ptr<RandomAccessFile> target_;
@@ -1294,6 +1215,46 @@ TEST_F(DBSecondaryTest, CatchUpAfterFlush) {
  ASSERT_OK(iter3->status());
 }

+TEST_F(DBSecondaryTest, CheckConsistencyWhenOpen) {
+  bool called = false;
+  Options options;
+  options.env = env_;
+  options.disable_auto_compactions = true;
+  Reopen(options);
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+  SyncPoint::GetInstance()->SetCallBack(
+      "DBImplSecondary::CheckConsistency:AfterFirstAttempt", [&](void* arg) {
+        ASSERT_NE(nullptr, arg);
+        called = true;
+        auto* s = static_cast<Status*>(arg);
+        ASSERT_NOK(*s);
+      });
+  SyncPoint::GetInstance()->LoadDependency(
+      {{"DBImpl::CheckConsistency:AfterGetLiveFilesMetaData",
+        "BackgroundCallCompaction:0"},
+       {"DBImpl::BackgroundCallCompaction:PurgedObsoleteFiles",
+        "DBImpl::CheckConsistency:BeforeGetFileSize"}});
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  ASSERT_OK(Put("a", "value0"));
+  ASSERT_OK(Put("c", "value0"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(Put("b", "value1"));
+  ASSERT_OK(Put("d", "value1"));
+  ASSERT_OK(Flush());
+  port::Thread thread([this]() {
+    Options opts;
+    opts.env = env_;
+    opts.max_open_files = -1;
+    OpenSecondary(opts);
+  });
+  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  thread.join();
+  ASSERT_TRUE(called);
+}
+
 TEST_F(DBSecondaryTest, StartFromInconsistent) {
  Options options = CurrentOptions();
  DestroyAndReopen(options);
@@ -135,6 +135,21 @@ TEST_F(DBSSTTest, SSTsWithLdbSuffixHandling) {
  Destroy(options);
 }

+// Check that we don't crash when opening DB with
+// DBOptions::skip_checking_sst_file_sizes_on_db_open = true.
+TEST_F(DBSSTTest, SkipCheckingSSTFileSizesOnDBOpen) {
+  ASSERT_OK(Put("pika", "choo"));
+  ASSERT_OK(Flush());
+
+  // Just open the DB with the option set to true and check that we don't crash.
+  Options options;
+  options.env = env_;
+  options.skip_checking_sst_file_sizes_on_db_open = true;
+  Reopen(options);
+
+  ASSERT_EQ("choo", Get("pika"));
+}
+
 TEST_F(DBSSTTest, DontDeleteMovedFile) {
  // This test triggers move compaction and verifies that the file is not
  // deleted when it's part of move compaction
@@ -1733,6 +1748,45 @@ TEST_F(DBSSTTest, GetTotalSstFilesSize) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 }

+TEST_F(DBSSTTest, OpenDBWithoutGetFileSizeInvocations) {
+  Options options = CurrentOptions();
+  std::unique_ptr<MockEnv> env{MockEnv::Create(Env::Default())};
+  options.env = env.get();
+  options.disable_auto_compactions = true;
+  options.compression = kNoCompression;
+  options.enable_blob_files = true;
+  options.blob_file_size = 32;  // create one blob per file
+  options.skip_checking_sst_file_sizes_on_db_open = true;
+
+  DestroyAndReopen(options);
+  // Generate 5 files in L0
+  for (int i = 0; i < 5; i++) {
+    for (int j = 0; j < 10; j++) {
+      std::string val = "val_file_" + std::to_string(i);
+      ASSERT_OK(Put(Key(j), val));
+    }
+    ASSERT_OK(Flush());
+  }
+  Close();
+
+  bool is_get_file_size_called = false;
+  SyncPoint::GetInstance()->SetCallBack(
+      "MockFileSystem::GetFileSize:CheckFileType", [&](void* arg) {
+        std::string* filename = static_cast<std::string*>(arg);
+        if (filename->find(".blob") != std::string::npos) {
+          is_get_file_size_called = true;
+        }
+      });
+
+  SyncPoint::GetInstance()->EnableProcessing();
+  Reopen(options);
+  ASSERT_FALSE(is_get_file_size_called);
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+
+  Destroy(options);
+}
+
 TEST_F(DBSSTTest, GetTotalSstFilesSizeVersionsFilesShared) {
  Options options = CurrentOptions();
  options.disable_auto_compactions = true;
@@ -229,56 +229,6 @@ TEST_F(DBTablePropertiesTest, CreateOnDeletionCollectorFactory) {
  ASSERT_EQ(0.5, del_factory->GetDeletionRatio());
 }

-TEST_F(DBTablePropertiesTest, GetPropertiesOfTablesByLevelTest) {
-  Random rnd(202);
-  Options options;
-  options.level_compaction_dynamic_level_bytes = false;
-  options.create_if_missing = true;
-  options.write_buffer_size = 4096;
-  options.max_write_buffer_number = 2;
-  options.level0_file_num_compaction_trigger = 2;
-  options.level0_slowdown_writes_trigger = 2;
-  options.level0_stop_writes_trigger = 2;
-  options.target_file_size_base = 2048;
-  options.max_bytes_for_level_base = 40960;
-  options.max_bytes_for_level_multiplier = 4;
-  options.hard_pending_compaction_bytes_limit = 16 * 1024;
-  options.num_levels = 8;
-  options.env = env_;
-
-  DestroyAndReopen(options);
-
-  // build a decent LSM
-  for (int i = 0; i < 10000; i++) {
-    EXPECT_OK(Put(test::RandomKey(&rnd, 5), rnd.RandomString(102)));
-  }
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  if (NumTableFilesAtLevel(0) == 0) {
-    EXPECT_OK(Put(test::RandomKey(&rnd, 5), rnd.RandomString(102)));
-    ASSERT_OK(Flush());
-  }
-
-  ASSERT_OK(db_->PauseBackgroundWork());
-
-  // Ensure that we have at least L0, L1 and L2
-  ASSERT_GT(NumTableFilesAtLevel(0), 0);
-  ASSERT_GT(NumTableFilesAtLevel(1), 0);
-  ASSERT_GT(NumTableFilesAtLevel(2), 0);
-  ColumnFamilyMetaData cf_meta;
-  db_->GetColumnFamilyMetaData(&cf_meta);
-  std::vector<std::unique_ptr<TablePropertiesCollection>> levels_props;
-  ASSERT_OK(db_->GetPropertiesOfTablesByLevel(db_->DefaultColumnFamily(),
-                                              &levels_props));
-  for (int i = 0; i < 8; i++) {
-    const std::unique_ptr<TablePropertiesCollection>& level_props =
-        levels_props[i];
-    ASSERT_EQ(level_props->size(), cf_meta.levels[i].files.size());
-  }
-
-  Close();
-}
-
 // Test params:
 // 1) whether to enable user-defined timestamps
 class DBTablePropertiesInRangeTest : public DBTestBase,
@@ -342,7 +292,7 @@ class DBTablePropertiesInRangeTest : public DBTestBase,
    keys.reserve(range_size * 2);
    for (auto& r : ranges) {
      auto [start, limit] = MaybeAddTimestampsToRange(
-          r.start, r.limit, ts_sz, &keys.emplace_back(), &keys.emplace_back(),
+          &r.start, &r.limit, ts_sz, &keys.emplace_back(), &keys.emplace_back(),
          /*exclusive_end=*/false);
      EXPECT_TRUE(start.has_value());
      EXPECT_TRUE(limit.has_value());
@@ -59,13 +59,11 @@
 #include "rocksdb/utilities/checkpoint.h"
 #include "rocksdb/utilities/optimistic_transaction_db.h"
 #include "rocksdb/utilities/write_batch_with_index.h"
-#include "table/block_based/block_based_table_factory.h"
 #include "table/mock_table.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/compression.h"
-#include "util/defer.h"
 #include "util/mutexlock.h"
 #include "util/random.h"
 #include "util/rate_limiter_impl.h"
@@ -144,121 +142,6 @@ TEST_F(DBTest, MockEnvTest) {
  delete db;
 }

-TEST_F(DBTest, RequestIdPlumbingTest) {
-  // test that request_id is passed to the filesystem, from
-  // ReadOptions to IODebugContext
-  Options options = CurrentOptions();
-  options.env = env_;
-
-  // Create a mock environment to capture IODebugContext during reads
-  IODebugContext dbgCopy;
-  const std::string* captured_request_id_dbg;
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "RandomAccessFileReader::Read:IODebugContext", [&](void* arg) {
-        IODebugContext* dbg = static_cast<IODebugContext*>(arg);
-        if (dbg == nullptr) {
-          captured_request_id_dbg = nullptr;
-        } else {
-          captured_request_id_dbg = dbg->request_id;
-          // Test IODebugContext assignment operator
-          dbgCopy = *dbg;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put("k1", "v1"));
-  ASSERT_OK(Flush());
-
-  // test request_id plumbing during a get
-  {
-    const std::string test_request_id = "test_request_id_123";
-    ReadOptions read_opts;
-    read_opts.request_id = &test_request_id;
-    std::string value;
-    ASSERT_OK(db_->Get(read_opts, "k1", &value));
-
-    // Verify the request_id was propagated to the file system
-    ASSERT_NE(captured_request_id_dbg, nullptr);
-    ASSERT_EQ(*captured_request_id_dbg, test_request_id);
-
-    ASSERT_NE(dbgCopy.request_id, nullptr);
-    ASSERT_NE(dbgCopy.request_id, captured_request_id_dbg);
-    ASSERT_EQ(*dbgCopy.request_id, test_request_id);
-  }
-
-  captured_request_id_dbg = nullptr;
-
-  // test request_id plumbing during iterator seek
-  ASSERT_OK(Put("k2", "v2"));
-  ASSERT_OK(Flush());
-  {
-    ReadOptions read_opts;
-    const std::string request_id = "test_request_id_456";
-    read_opts.request_id = &request_id;
-
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_opts));
-    iter->Seek("k2");
-    ASSERT_TRUE(iter->Valid());
-
-    // Verify the request_id was propagated to the file system
-    ASSERT_NE(captured_request_id_dbg, nullptr);
-    ASSERT_EQ(*captured_request_id_dbg, request_id);
-
-    ASSERT_NE(dbgCopy.request_id, nullptr);
-    ASSERT_NE(dbgCopy.request_id, captured_request_id_dbg);
-    ASSERT_EQ(*dbgCopy.request_id, request_id);
-
-    // Test IODebugContext copy constructor
-    IODebugContext dbgCopy2(dbgCopy);
-    ASSERT_NE(dbgCopy2.request_id, nullptr);
-    ASSERT_NE(dbgCopy2.request_id, captured_request_id_dbg);
-    ASSERT_NE(dbgCopy2.request_id, dbgCopy.request_id);
-    ASSERT_EQ(*dbgCopy2.request_id, request_id);
-  }
-
-  // test request_id plumbing during multiget
-  captured_request_id_dbg = nullptr;
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "RandomAccessFileReader::MultiRead:IODebugContext", [&](void* arg) {
-        IODebugContext* dbg = static_cast<IODebugContext*>(arg);
-        if (dbg == nullptr) {
-          captured_request_id_dbg = nullptr;
-        } else {
-          captured_request_id_dbg = dbg->request_id;
-        }
-      });
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(Put("k3", "v3"));
-  ASSERT_OK(Put("k4", "v4"));
-  ASSERT_OK(Flush());
-
-  {
-    ReadOptions read_opts;
-    const std::string multiget_request_id = "test_request_id_789";
-    read_opts.request_id = &multiget_request_id;
-
-    std::vector<std::string> values;
-    std::vector<Slice> keys = {Slice("k3"), Slice("k4")};
-
-    values.resize(keys.size());
-
-    std::vector<ColumnFamilyHandle*> cfhs(keys.size(),
-                                          db_->DefaultColumnFamily());
-    db_->MultiGet(read_opts, cfhs, keys, &values);
-
-    ASSERT_NE(captured_request_id_dbg, nullptr);
-    ASSERT_EQ(*captured_request_id_dbg, multiget_request_id);
-  }
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(DBTest, MemEnvTest) {
  std::unique_ptr<Env> env{NewMemEnv(Env::Default())};
  Options options;
@@ -1278,6 +1161,12 @@ class DelayFilterFactory : public CompactionFilterFactory {
 };
 }  // anonymous namespace

+static std::string CompressibleString(Random* rnd, int len) {
+  std::string r;
+  test::CompressibleString(rnd, 0.8, len, &r);
+  return r;
+}
+
 TEST_F(DBTest, FailMoreDbPaths) {
  Options options = CurrentOptions();
  options.db_paths.emplace_back(dbname_, 10000000);
@@ -3291,15 +3180,6 @@ class ModelDB : public DB {
    return Status();
  }

-  using DB::GetPropertiesOfTablesByLevel;
-  Status GetPropertiesOfTablesByLevel(
-      ColumnFamilyHandle* /* column_family */,
-      std::vector<
-          std::unique_ptr<TablePropertiesCollection>>* /* props_by_level */)
-      override {
-    return Status();
-  }
-
  using DB::KeyMayExist;
  bool KeyMayExist(const ReadOptions& /*options*/,
                   ColumnFamilyHandle* /*column_family*/, const Slice& /*key*/,
@@ -3460,6 +3340,11 @@ class ModelDB : public DB {
  using DB::NumberLevels;
  int NumberLevels(ColumnFamilyHandle* /*column_family*/) override { return 1; }

+  using DB::MaxMemCompactionLevel;
+  int MaxMemCompactionLevel(ColumnFamilyHandle* /*column_family*/) override {
+    return 1;
+  }
+
  using DB::Level0StopWriteTrigger;
  int Level0StopWriteTrigger(ColumnFamilyHandle* /*column_family*/) override {
    return -1;
@@ -3516,7 +3401,7 @@ class ModelDB : public DB {
  }

  Status GetCurrentWalFile(
-      std::unique_ptr<LogFile>* /*current_wal_file*/) override {
+      std::unique_ptr<LogFile>* /*current_log_file*/) override {
    return Status::OK();
  }

@@ -3555,11 +3440,6 @@ class ModelDB : public DB {
    return Status::OK();
  }

-  Status GetNewestUserDefinedTimestamp(
-      ColumnFamilyHandle* /*cf*/, std::string* /*newest_timestamp*/) override {
-    return Status::OK();
-  }
-
  ColumnFamilyHandle* DefaultColumnFamily() const override { return nullptr; }

 private:
@@ -5401,6 +5281,272 @@ TEST_F(DBTest, FlushOnDestroy) {
  CancelAllBackgroundWork(db_);
 }

+TEST_F(DBTest, DynamicLevelCompressionPerLevel) {
+  if (!Snappy_Supported()) {
+    return;
+  }
+  const int kNKeys = 120;
+  int keys[kNKeys];
+  for (int i = 0; i < kNKeys; i++) {
+    keys[i] = i;
+  }
+
+  Random rnd(301);
+  Options options;
+  options.env = env_;
+  options.create_if_missing = true;
+  options.db_write_buffer_size = 20480;
+  options.write_buffer_size = 20480;
+  options.max_write_buffer_number = 2;
+  options.level0_file_num_compaction_trigger = 2;
+  options.level0_slowdown_writes_trigger = 2;
+  options.level0_stop_writes_trigger = 2;
+  options.target_file_size_base = 20480;
+  options.level_compaction_dynamic_level_bytes = true;
+  options.max_bytes_for_level_base = 102400;
+  options.max_bytes_for_level_multiplier = 4;
+  options.max_background_compactions = 1;
+  options.num_levels = 5;
+  options.statistics = CreateDBStatistics();
+
+  options.compression_per_level.resize(3);
+  // No compression for L0
+  options.compression_per_level[0] = kNoCompression;
+  // No compression for the Ln whre L0 is compacted to
+  options.compression_per_level[1] = kNoCompression;
+  // Snappy compression for Ln+1
+  options.compression_per_level[2] = kSnappyCompression;
+
+  OnFileDeletionListener* listener = new OnFileDeletionListener();
+  options.listeners.emplace_back(listener);
+
+  DestroyAndReopen(options);
+
+  // Insert more than 80K. L4 should be base level. Neither L0 nor L4 should
+  // be compressed, so there shouldn't be any compression.
+  for (int i = 0; i < 20; i++) {
+    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
+    ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
+  }
+  ASSERT_OK(Flush());
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+
+  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
+  ASSERT_TRUE(NumTableFilesAtLevel(0) > 0 || NumTableFilesAtLevel(4) > 0);
+
+  // Verify there was no compression
+  auto num_block_compressed =
+      options.statistics->getTickerCount(NUMBER_BLOCK_COMPRESSED);
+  ASSERT_EQ(num_block_compressed, 0);
+
+  // Insert 400KB and there will be some files end up in L3. According to the
+  // above compression settings for each level, there will be some compression.
+  ASSERT_OK(options.statistics->Reset());
+  ASSERT_EQ(num_block_compressed, 0);
+  for (int i = 20; i < 120; i++) {
+    ASSERT_OK(Put(Key(keys[i]), CompressibleString(&rnd, 4000)));
+    ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
+  }
+  ASSERT_OK(Flush());
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
+  ASSERT_GE(NumTableFilesAtLevel(3), 1);
+  ASSERT_GE(NumTableFilesAtLevel(4), 1);
+
+  // Verify there was compression
+  num_block_compressed =
+      options.statistics->getTickerCount(NUMBER_BLOCK_COMPRESSED);
+  ASSERT_GT(num_block_compressed, 0);
+
+  // Make sure data in files in L3 is not compacted by removing all files
+  // in L4 and calculate number of rows
+  ASSERT_OK(dbfull()->SetOptions({
+      {"disable_auto_compactions", "true"},
+  }));
+  ColumnFamilyMetaData cf_meta;
+  db_->GetColumnFamilyMetaData(&cf_meta);
+
+  // Ensure that L1+ files are non-overlapping and together with L0 encompass
+  // full key range between smallestkey and largestkey from CF file metadata.
+  int largestkey_in_prev_level = -1;
+  int keys_found = 0;
+  for (int level = (int)cf_meta.levels.size() - 1; level >= 0; level--) {
+    int files_in_level = (int)cf_meta.levels[level].files.size();
+    int largestkey_in_prev_file = -1;
+    for (int j = 0; j < files_in_level; j++) {
+      int smallestkey = IdFromKey(cf_meta.levels[level].files[j].smallestkey);
+      int largestkey = IdFromKey(cf_meta.levels[level].files[j].largestkey);
+      int num_entries = (int)cf_meta.levels[level].files[j].num_entries;
+      ASSERT_EQ(num_entries, largestkey - smallestkey + 1);
+      keys_found += num_entries;
+      if (level > 0) {
+        if (j == 0) {
+          ASSERT_GT(smallestkey, largestkey_in_prev_level);
+        }
+        if (j > 0) {
+          ASSERT_GT(smallestkey, largestkey_in_prev_file);
+        }
+        if (j == files_in_level - 1) {
+          largestkey_in_prev_level = largestkey;
+        }
+      }
+      largestkey_in_prev_file = largestkey;
+    }
+  }
+  ASSERT_EQ(keys_found, kNKeys);
+
+  for (const auto& file : cf_meta.levels[4].files) {
+    listener->SetExpectedFileName(dbname_ + file.name);
+    Slice start(file.smallestkey), limit(file.largestkey);
+    const RangePtr ranges(&start, &limit);
+    // Given verification from above, we're guaranteed that by deleting all the
+    // files in [<smallestkey>, <largestkey>] range, we're effectively deleting
+    // that very single file and nothing more.
+    EXPECT_OK(dbfull()->DeleteFilesInRanges(dbfull()->DefaultColumnFamily(),
+                                            &ranges, true /* include_end */));
+  }
+  listener->VerifyMatchedCount(cf_meta.levels[4].files.size());
+
+  int num_keys = 0;
+  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
+  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
+    num_keys++;
+  }
+  ASSERT_OK(iter->status());
+
+  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
+  ASSERT_GE(NumTableFilesAtLevel(3), 1);
+  ASSERT_EQ(NumTableFilesAtLevel(4), 0);
+
+  ASSERT_GT(SizeAtLevel(0) + SizeAtLevel(3), num_keys * 4000U + num_keys * 10U);
+}
+
+TEST_F(DBTest, DynamicLevelCompressionPerLevel2) {
+  if (!Snappy_Supported() || !LZ4_Supported() || !Zlib_Supported()) {
+    return;
+  }
+  const int kNKeys = 500;
+  int keys[kNKeys];
+  for (int i = 0; i < kNKeys; i++) {
+    keys[i] = i;
+  }
+  RandomShuffle(std::begin(keys), std::end(keys));
+
+  Random rnd(301);
+  Options options;
+  options.create_if_missing = true;
+  options.db_write_buffer_size = 6000000;
+  options.write_buffer_size = 600000;
+  options.max_write_buffer_number = 2;
+  options.level0_file_num_compaction_trigger = 2;
+  options.level0_slowdown_writes_trigger = 2;
+  options.level0_stop_writes_trigger = 2;
+  options.soft_pending_compaction_bytes_limit = 1024 * 1024;
+  options.target_file_size_base = 20;
+  options.env = env_;
+  options.level_compaction_dynamic_level_bytes = true;
+  options.max_bytes_for_level_base = 200;
+  options.max_bytes_for_level_multiplier = 8;
+  options.max_background_compactions = 1;
+  options.num_levels = 5;
+  std::shared_ptr<mock::MockTableFactory> mtf(new mock::MockTableFactory);
+  options.table_factory = mtf;
+
+  options.compression_per_level.resize(3);
+  options.compression_per_level[0] = kNoCompression;
+  options.compression_per_level[1] = kLZ4Compression;
+  options.compression_per_level[2] = kZlibCompression;
+
+  DestroyAndReopen(options);
+  // When base level is L4, L4 is LZ4.
+  std::atomic<int> num_zlib(0);
+  std::atomic<int> num_lz4(0);
+  std::atomic<int> num_no(0);
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
+        Compaction* compaction = static_cast<Compaction*>(arg);
+        if (compaction->output_level() == 4) {
+          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
+          num_lz4.fetch_add(1);
+        }
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
+        auto* compression = static_cast<CompressionType*>(arg);
+        ASSERT_TRUE(*compression == kNoCompression);
+        num_no.fetch_add(1);
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+
+  for (int i = 0; i < 100; i++) {
+    std::string value = rnd.RandomString(200);
+    ASSERT_OK(Put(Key(keys[i]), value));
+    if (i % 25 == 24) {
+      ASSERT_OK(Flush());
+      ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    }
+  }
+
+  ASSERT_OK(Flush());
+  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
+
+  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(3), 0);
+  ASSERT_GT(NumTableFilesAtLevel(4), 0);
+  ASSERT_GT(num_no.load(), 2);
+  ASSERT_GT(num_lz4.load(), 0);
+  int prev_num_files_l4 = NumTableFilesAtLevel(4);
+
+  // After base level turn L4->L3, L3 becomes LZ4 and L4 becomes Zlib
+  num_lz4.store(0);
+  num_no.store(0);
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "LevelCompactionPicker::PickCompaction:Return", [&](void* arg) {
+        Compaction* compaction = static_cast<Compaction*>(arg);
+        if (compaction->output_level() == 4 && compaction->start_level() == 3) {
+          ASSERT_TRUE(compaction->output_compression() == kZlibCompression);
+          num_zlib.fetch_add(1);
+        } else {
+          ASSERT_TRUE(compaction->output_compression() == kLZ4Compression);
+          num_lz4.fetch_add(1);
+        }
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "FlushJob::WriteLevel0Table:output_compression", [&](void* arg) {
+        auto* compression = static_cast<CompressionType*>(arg);
+        ASSERT_TRUE(*compression == kNoCompression);
+        num_no.fetch_add(1);
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+
+  for (int i = 101; i < 500; i++) {
+    std::string value = rnd.RandomString(200);
+    ASSERT_OK(Put(Key(keys[i]), value));
+    if (i % 100 == 99) {
+      ASSERT_OK(Flush());
+      ASSERT_OK(dbfull()->TEST_WaitForCompact());
+    }
+  }
+
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  ASSERT_EQ(NumTableFilesAtLevel(1), 0);
+  ASSERT_EQ(NumTableFilesAtLevel(2), 0);
+  ASSERT_GT(NumTableFilesAtLevel(3), 0);
+  ASSERT_GT(NumTableFilesAtLevel(4), prev_num_files_l4);
+  ASSERT_GT(num_no.load(), 2);
+  ASSERT_GT(num_lz4.load(), 0);
+  ASSERT_GT(num_zlib.load(), 0);
+}
+
 TEST_F(DBTest, DynamicCompactionOptions) {
  // minimum write buffer size is enforced at 64KB
  const uint64_t k32KB = 1 << 15;
@@ -5938,11 +6084,6 @@ TEST_F(DBTest, L0L1L2AndUpHitCounter) {
 }

 TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
-  // Allow testing format_version=1
-  bool& allow_unsupported_fv = TEST_AllowUnsupportedFormatVersion();
-  SaveAndRestore guard(&allow_unsupported_fv);
-  ASSERT_FALSE(allow_unsupported_fv);
-
  // iter 0 -- zlib
  // iter 1 -- bzip2
  // iter 2 -- lz4
@@ -5965,16 +6106,7 @@ TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
      table_options.format_version = first_table_version;
      table_options.filter_policy.reset(NewBloomFilterPolicy(10));
      Options options = CurrentOptions();
-
-      // Hack to generate old files (checked in factory construction)
-      allow_unsupported_fv = true;
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-      ASSERT_EQ(options.table_factory->GetOptions<BlockBasedTableOptions>()
-                    ->format_version,
-                first_table_version);
-      // Able to read old files without the hack
-      allow_unsupported_fv = false;
-
      options.create_if_missing = true;
      options.compression = comp;
      DestroyAndReopen(options);
@@ -5986,14 +6118,9 @@ TEST_F(DBTest, EncodeDecompressedBlockSizeTest) {
        // compressible string
        ASSERT_OK(Put(Key(i), rnd.RandomString(128) + std::string(128, 'a')));
      }
-      ASSERT_OK(Flush());

      table_options.format_version = first_table_version == 1 ? 2 : 1;
      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-      // format_version (for writing) is sanitized to minimum supported
-      ASSERT_EQ(options.table_factory->GetOptions<BlockBasedTableOptions>()
-                    ->format_version,
-                BlockBasedTableFactory::kMinSupportedFormatVersion);
      Reopen(options);
      for (int i = 0; i < kNumKeysWritten; ++i) {
        auto r = Get(Key(i));
@@ -6262,7 +6389,7 @@ TEST_F(DBTest, TestLogCleanup) {

  for (int i = 0; i < 100000; ++i) {
    ASSERT_OK(Put(Key(i), "val"));
-    // only 2 memtables will be alive, so wals_to_free needs to always be below
+    // only 2 memtables will be alive, so logs_to_free needs to always be below
    // 2
    ASSERT_LT(dbfull()->TEST_LogsToFreeSize(), static_cast<size_t>(3));
  }
@@ -7078,6 +7205,27 @@ TEST_F(DBTest, LastWriteBufferDelay) {
 }
 #endif  // !defined(ROCKSDB_DISABLE_STALL_NOTIFICATION)

+TEST_F(DBTest, FailWhenCompressionNotSupportedTest) {
+  CompressionType compressions[] = {kZlibCompression, kBZip2Compression,
+                                    kLZ4Compression, kLZ4HCCompression,
+                                    kXpressCompression};
+  for (auto comp : compressions) {
+    if (!CompressionTypeSupported(comp)) {
+      // not supported, we should fail the Open()
+      Options options = CurrentOptions();
+      options.compression = comp;
+      ASSERT_TRUE(!TryReopen(options).ok());
+      // Try if CreateColumnFamily also fails
+      options.compression = kNoCompression;
+      ASSERT_OK(TryReopen(options));
+      ColumnFamilyOptions cf_options(options);
+      cf_options.compression = comp;
+      ColumnFamilyHandle* handle;
+      ASSERT_TRUE(!db_->CreateColumnFamily(cf_options, "name", &handle).ok());
+    }
+  }
+}
+
 TEST_F(DBTest, CreateColumnFamilyShouldFailOnIncompatibleOptions) {
  Options options = CurrentOptions();
  options.max_open_files = 100;
@@ -10,6 +10,7 @@
 #include <atomic>
 #include <cstdlib>
 #include <functional>
+#include <iostream>
 #include <memory>

 #include "db/db_test_util.h"
@@ -1185,6 +1186,705 @@ TEST_F(DBTest2, WalFilterTestWithColumnFamilies) {
  ASSERT_EQ(index, keys_cf.size());
 }

+TEST_F(DBTest2, PresetCompressionDict) {
+  // Verifies that compression ratio improves when dictionary is enabled, and
+  // improves even further when the dictionary is trained by ZSTD.
+  const size_t kBlockSizeBytes = 4 << 10;
+  const size_t kL0FileBytes = 128 << 10;
+  const size_t kApproxPerBlockOverheadBytes = 50;
+  const int kNumL0Files = 5;
+
+  Options options;
+  // Make sure to use any custom env that the test is configured with.
+  options.env = CurrentOptions().env;
+  options.allow_concurrent_memtable_write = false;
+  options.arena_block_size = kBlockSizeBytes;
+  options.create_if_missing = true;
+  options.disable_auto_compactions = true;
+  options.level0_file_num_compaction_trigger = kNumL0Files;
+  options.memtable_factory.reset(
+      test::NewSpecialSkipListFactory(kL0FileBytes / kBlockSizeBytes));
+  options.num_levels = 2;
+  options.target_file_size_base = kL0FileBytes;
+  options.target_file_size_multiplier = 2;
+  options.write_buffer_size = kL0FileBytes;
+  BlockBasedTableOptions table_options;
+  table_options.block_size = kBlockSizeBytes;
+  std::vector<CompressionType> compression_types;
+  if (Zlib_Supported()) {
+    compression_types.push_back(kZlibCompression);
+  }
+#if LZ4_VERSION_NUMBER >= 10400  // r124+
+  compression_types.push_back(kLZ4Compression);
+  compression_types.push_back(kLZ4HCCompression);
+#endif  // LZ4_VERSION_NUMBER >= 10400
+  if (ZSTD_Supported()) {
+    compression_types.push_back(kZSTD);
+  }
+
+  enum DictionaryTypes : int {
+    kWithoutDict,
+    kWithDict,
+    kWithZSTDfinalizeDict,
+    kWithZSTDTrainedDict,
+    kDictEnd,
+  };
+
+  for (auto compression_type : compression_types) {
+    options.compression = compression_type;
+    size_t bytes_without_dict = 0;
+    size_t bytes_with_dict = 0;
+    size_t bytes_with_zstd_finalize_dict = 0;
+    size_t bytes_with_zstd_trained_dict = 0;
+    for (int i = kWithoutDict; i < kDictEnd; i++) {
+      // First iteration: compress without preset dictionary
+      // Second iteration: compress with preset dictionary
+      // Third iteration (zstd only): compress with zstd-trained dictionary
+      //
+      // To make sure the compression dictionary has the intended effect, we
+      // verify the compressed size is smaller in successive iterations. Also in
+      // the non-first iterations, verify the data we get out is the same data
+      // we put in.
+      switch (i) {
+        case kWithoutDict:
+          options.compression_opts.max_dict_bytes = 0;
+          options.compression_opts.zstd_max_train_bytes = 0;
+          break;
+        case kWithDict:
+          options.compression_opts.max_dict_bytes = kBlockSizeBytes;
+          options.compression_opts.zstd_max_train_bytes = 0;
+          break;
+        case kWithZSTDfinalizeDict:
+          if (compression_type != kZSTD ||
+              !ZSTD_FinalizeDictionarySupported()) {
+            continue;
+          }
+          options.compression_opts.max_dict_bytes = kBlockSizeBytes;
+          options.compression_opts.zstd_max_train_bytes = kL0FileBytes;
+          options.compression_opts.use_zstd_dict_trainer = false;
+          break;
+        case kWithZSTDTrainedDict:
+          if (compression_type != kZSTD || !ZSTD_TrainDictionarySupported()) {
+            continue;
+          }
+          options.compression_opts.max_dict_bytes = kBlockSizeBytes;
+          options.compression_opts.zstd_max_train_bytes = kL0FileBytes;
+          options.compression_opts.use_zstd_dict_trainer = true;
+          break;
+        default:
+          assert(false);
+      }
+
+      options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+      options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+      CreateAndReopenWithCF({"pikachu"}, options);
+      Random rnd(301);
+      std::string seq_datas[10];
+      for (int j = 0; j < 10; ++j) {
+        seq_datas[j] =
+            rnd.RandomString(kBlockSizeBytes - kApproxPerBlockOverheadBytes);
+      }
+
+      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
+      for (int j = 0; j < kNumL0Files; ++j) {
+        for (size_t k = 0; k < kL0FileBytes / kBlockSizeBytes + 1; ++k) {
+          auto key_num = j * (kL0FileBytes / kBlockSizeBytes) + k;
+          ASSERT_OK(Put(1, Key(static_cast<int>(key_num)),
+                        seq_datas[(key_num / 10) % 10]));
+        }
+        ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[1]));
+        ASSERT_EQ(j + 1, NumTableFilesAtLevel(0, 1));
+      }
+      ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1],
+                                            true /* disallow_trivial_move */));
+      ASSERT_EQ(0, NumTableFilesAtLevel(0, 1));
+      ASSERT_GT(NumTableFilesAtLevel(1, 1), 0);
+
+      // Get the live sst files size
+      size_t total_sst_bytes = TotalSize(1);
+      if (i == kWithoutDict) {
+        bytes_without_dict = total_sst_bytes;
+      } else if (i == kWithDict) {
+        bytes_with_dict = total_sst_bytes;
+      } else if (i == kWithZSTDfinalizeDict) {
+        bytes_with_zstd_finalize_dict = total_sst_bytes;
+      } else if (i == kWithZSTDTrainedDict) {
+        bytes_with_zstd_trained_dict = total_sst_bytes;
+      }
+
+      for (size_t j = 0; j < kNumL0Files * (kL0FileBytes / kBlockSizeBytes);
+           j++) {
+        ASSERT_EQ(seq_datas[(j / 10) % 10], Get(1, Key(static_cast<int>(j))));
+      }
+      if (i == kWithDict) {
+        ASSERT_GT(bytes_without_dict, bytes_with_dict);
+      } else if (i == kWithZSTDTrainedDict) {
+        // In zstd compression, it is sometimes possible that using a finalized
+        // dictionary does not get as good a compression ratio as raw content
+        // dictionary. But using a dictionary should always get better
+        // compression ratio than not using one.
+        ASSERT_TRUE(bytes_with_dict > bytes_with_zstd_finalize_dict ||
+                    bytes_without_dict > bytes_with_zstd_finalize_dict);
+      } else if (i == kWithZSTDTrainedDict) {
+        // In zstd compression, it is sometimes possible that using a trained
+        // dictionary does not get as good a compression ratio as without
+        // training.
+        // But using a dictionary (with or without training) should always get
+        // better compression ratio than not using one.
+        ASSERT_TRUE(bytes_with_dict > bytes_with_zstd_trained_dict ||
+                    bytes_without_dict > bytes_with_zstd_trained_dict);
+      }
+
+      DestroyAndReopen(options);
+    }
+  }
+}
+
+TEST_F(DBTest2, PresetCompressionDictLocality) {
+  if (!ZSTD_Supported()) {
+    return;
+  }
+  // Verifies that compression dictionary is generated from local data. The
+  // verification simply checks all output SSTs have different compression
+  // dictionaries. We do not verify effectiveness as that'd likely be flaky in
+  // the future.
+  const int kNumEntriesPerFile = 1 << 10;  // 1KB
+  const int kNumBytesPerEntry = 1 << 10;   // 1KB
+  const int kNumFiles = 4;
+  Options options = CurrentOptions();
+  options.compression = kZSTD;
+  options.compression_opts.max_dict_bytes = 1 << 14;        // 16KB
+  options.compression_opts.zstd_max_train_bytes = 1 << 18;  // 256KB
+  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+  options.target_file_size_base = kNumEntriesPerFile * kNumBytesPerEntry;
+  BlockBasedTableOptions table_options;
+  table_options.cache_index_and_filter_blocks = true;
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  Reopen(options);
+
+  Random rnd(301);
+  for (int i = 0; i < kNumFiles; ++i) {
+    for (int j = 0; j < kNumEntriesPerFile; ++j) {
+      ASSERT_OK(Put(Key(i * kNumEntriesPerFile + j),
+                    rnd.RandomString(kNumBytesPerEntry)));
+    }
+    ASSERT_OK(Flush());
+    MoveFilesToLevel(1);
+    ASSERT_EQ(NumTableFilesAtLevel(1), i + 1);
+  }
+
+  // Store all the dictionaries generated during a full compaction.
+  std::vector<std::string> compression_dicts;
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "BlockBasedTableBuilder::WriteCompressionDictBlock:RawDict",
+      [&](void* arg) {
+        compression_dicts.emplace_back(static_cast<Slice*>(arg)->ToString());
+      });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+  CompactRangeOptions compact_range_opts;
+  compact_range_opts.bottommost_level_compaction =
+      BottommostLevelCompaction::kForceOptimized;
+  ASSERT_OK(db_->CompactRange(compact_range_opts, nullptr, nullptr));
+
+  // Dictionary compression should not be so good as to compress four totally
+  // random files into one. If it does then there's probably something wrong
+  // with the test.
+  ASSERT_GT(NumTableFilesAtLevel(1), 1);
+
+  // Furthermore, there should be one compression dictionary generated per file.
+  // And they should all be different from each other.
+  ASSERT_EQ(NumTableFilesAtLevel(1),
+            static_cast<int>(compression_dicts.size()));
+  for (size_t i = 1; i < compression_dicts.size(); ++i) {
+    std::string& a = compression_dicts[i - 1];
+    std::string& b = compression_dicts[i];
+    size_t alen = a.size();
+    size_t blen = b.size();
+    ASSERT_TRUE(alen != blen || memcmp(a.data(), b.data(), alen) != 0);
+  }
+}
+
+class PresetCompressionDictTest
+    : public DBTestBase,
+      public testing::WithParamInterface<std::tuple<CompressionType, bool>> {
+ public:
+  PresetCompressionDictTest()
+      : DBTestBase("db_test2", false /* env_do_fsync */),
+        compression_type_(std::get<0>(GetParam())),
+        bottommost_(std::get<1>(GetParam())) {}
+
+ protected:
+  const CompressionType compression_type_;
+  const bool bottommost_;
+};
+
+INSTANTIATE_TEST_CASE_P(
+    DBTest2, PresetCompressionDictTest,
+    ::testing::Combine(::testing::ValuesIn(GetSupportedDictCompressions()),
+                       ::testing::Bool()));
+
+TEST_P(PresetCompressionDictTest, Flush) {
+  // Verifies that dictionary is generated and written during flush only when
+  // `ColumnFamilyOptions::compression` enables dictionary. Also verifies the
+  // size of the dictionary is within expectations according to the limit on
+  // buffering set by `CompressionOptions::max_dict_buffer_bytes`.
+  const size_t kValueLen = 256;
+  const size_t kKeysPerFile = 1 << 10;
+  const size_t kDictLen = 16 << 10;
+  const size_t kBlockLen = 4 << 10;
+
+  Options options = CurrentOptions();
+  if (bottommost_) {
+    options.bottommost_compression = compression_type_;
+    options.bottommost_compression_opts.enabled = true;
+    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
+    options.bottommost_compression_opts.max_dict_buffer_bytes = kBlockLen;
+  } else {
+    options.compression = compression_type_;
+    options.compression_opts.max_dict_bytes = kDictLen;
+    options.compression_opts.max_dict_buffer_bytes = kBlockLen;
+  }
+  options.memtable_factory.reset(test::NewSpecialSkipListFactory(kKeysPerFile));
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions bbto;
+  bbto.block_size = kBlockLen;
+  bbto.cache_index_and_filter_blocks = true;
+  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  Reopen(options);
+
+  Random rnd(301);
+  for (size_t i = 0; i <= kKeysPerFile; ++i) {
+    ASSERT_OK(Put(Key(static_cast<int>(i)), rnd.RandomString(kValueLen)));
+  }
+  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+
+  // We can use `BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT` to detect whether a
+  // compression dictionary exists since dictionaries would be preloaded when
+  // the flush finishes.
+  if (bottommost_) {
+    // Flush is never considered bottommost. This should change in the future
+    // since flushed files may have nothing underneath them, like the one in
+    // this test case.
+    ASSERT_EQ(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        0);
+  } else {
+    ASSERT_GT(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        0);
+    // TODO(ajkr): fix the below assertion to work with ZSTD. The expectation on
+    // number of bytes needs to be adjusted in case the cached block is in
+    // ZSTD's digested dictionary format.
+    if (compression_type_ != kZSTD) {
+      // Although we limited buffering to `kBlockLen`, there may be up to two
+      // blocks of data included in the dictionary since we only check limit
+      // after each block is built.
+      ASSERT_LE(TestGetTickerCount(options,
+                                   BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+                2 * kBlockLen);
+    }
+  }
+}
+
+TEST_P(PresetCompressionDictTest, CompactNonBottommost) {
+  // Verifies that dictionary is generated and written during compaction to
+  // non-bottommost level only when `ColumnFamilyOptions::compression` enables
+  // dictionary. Also verifies the size of the dictionary is within expectations
+  // according to the limit on buffering set by
+  // `CompressionOptions::max_dict_buffer_bytes`.
+  const size_t kValueLen = 256;
+  const size_t kKeysPerFile = 1 << 10;
+  const size_t kDictLen = 16 << 10;
+  const size_t kBlockLen = 4 << 10;
+
+  Options options = CurrentOptions();
+  if (bottommost_) {
+    options.bottommost_compression = compression_type_;
+    options.bottommost_compression_opts.enabled = true;
+    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
+    options.bottommost_compression_opts.max_dict_buffer_bytes = kBlockLen;
+  } else {
+    options.compression = compression_type_;
+    options.compression_opts.max_dict_bytes = kDictLen;
+    options.compression_opts.max_dict_buffer_bytes = kBlockLen;
+  }
+  options.disable_auto_compactions = true;
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions bbto;
+  bbto.block_size = kBlockLen;
+  bbto.cache_index_and_filter_blocks = true;
+  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  Reopen(options);
+
+  Random rnd(301);
+  for (size_t j = 0; j <= kKeysPerFile; ++j) {
+    ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
+  }
+  ASSERT_OK(Flush());
+  MoveFilesToLevel(2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (size_t j = 0; j <= kKeysPerFile; ++j) {
+      ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
+    }
+    ASSERT_OK(Flush());
+  }
+  ASSERT_EQ("2,0,1", FilesPerLevel(0));
+
+  uint64_t prev_compression_dict_bytes_inserted =
+      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT);
+  // This L0->L1 compaction merges the two L0 files into L1. The produced L1
+  // file is not bottommost due to the existing L2 file covering the same key-
+  // range.
+  ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
+  ASSERT_EQ("0,1,1", FilesPerLevel(0));
+  // We can use `BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT` to detect whether a
+  // compression dictionary exists since dictionaries would be preloaded when
+  // the compaction finishes.
+  if (bottommost_) {
+    ASSERT_EQ(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        prev_compression_dict_bytes_inserted);
+  } else {
+    ASSERT_GT(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        prev_compression_dict_bytes_inserted);
+    // TODO(ajkr): fix the below assertion to work with ZSTD. The expectation on
+    // number of bytes needs to be adjusted in case the cached block is in
+    // ZSTD's digested dictionary format.
+    if (compression_type_ != kZSTD) {
+      // Although we limited buffering to `kBlockLen`, there may be up to two
+      // blocks of data included in the dictionary since we only check limit
+      // after each block is built.
+      ASSERT_LE(TestGetTickerCount(options,
+                                   BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+                prev_compression_dict_bytes_inserted + 2 * kBlockLen);
+    }
+  }
+}
+
+TEST_P(PresetCompressionDictTest, CompactBottommost) {
+  // Verifies that dictionary is generated and written during compaction to
+  // non-bottommost level only when either `ColumnFamilyOptions::compression` or
+  // `ColumnFamilyOptions::bottommost_compression` enables dictionary. Also
+  // verifies the size of the dictionary is within expectations according to the
+  // limit on buffering set by `CompressionOptions::max_dict_buffer_bytes`.
+  const size_t kValueLen = 256;
+  const size_t kKeysPerFile = 1 << 10;
+  const size_t kDictLen = 16 << 10;
+  const size_t kBlockLen = 4 << 10;
+
+  Options options = CurrentOptions();
+  if (bottommost_) {
+    options.bottommost_compression = compression_type_;
+    options.bottommost_compression_opts.enabled = true;
+    options.bottommost_compression_opts.max_dict_bytes = kDictLen;
+    options.bottommost_compression_opts.max_dict_buffer_bytes = kBlockLen;
+  } else {
+    options.compression = compression_type_;
+    options.compression_opts.max_dict_bytes = kDictLen;
+    options.compression_opts.max_dict_buffer_bytes = kBlockLen;
+  }
+  options.disable_auto_compactions = true;
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions bbto;
+  bbto.block_size = kBlockLen;
+  bbto.cache_index_and_filter_blocks = true;
+  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+  Reopen(options);
+
+  Random rnd(301);
+  for (int i = 0; i < 2; ++i) {
+    for (size_t j = 0; j <= kKeysPerFile; ++j) {
+      ASSERT_OK(Put(Key(static_cast<int>(j)), rnd.RandomString(kValueLen)));
+    }
+    ASSERT_OK(Flush());
+  }
+  ASSERT_EQ("2", FilesPerLevel(0));
+
+  uint64_t prev_compression_dict_bytes_inserted =
+      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT);
+  CompactRangeOptions cro;
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  ASSERT_EQ("0,1", FilesPerLevel(0));
+  ASSERT_GT(
+      TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+      prev_compression_dict_bytes_inserted);
+  // TODO(ajkr): fix the below assertion to work with ZSTD. The expectation on
+  // number of bytes needs to be adjusted in case the cached block is in ZSTD's
+  // digested dictionary format.
+  if (compression_type_ != kZSTD) {
+    // Although we limited buffering to `kBlockLen`, there may be up to two
+    // blocks of data included in the dictionary since we only check limit after
+    // each block is built.
+    ASSERT_LE(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        prev_compression_dict_bytes_inserted + 2 * kBlockLen);
+  }
+}
+
+class CompactionCompressionListener : public EventListener {
+ public:
+  explicit CompactionCompressionListener(Options* db_options)
+      : db_options_(db_options) {}
+
+  void OnCompactionCompleted(DB* db, const CompactionJobInfo& ci) override {
+    // Figure out last level with files
+    int bottommost_level = 0;
+    for (int level = 0; level < db->NumberLevels(); level++) {
+      std::string files_at_level;
+      ASSERT_TRUE(
+          db->GetProperty("rocksdb.num-files-at-level" + std::to_string(level),
+                          &files_at_level));
+      if (files_at_level != "0") {
+        bottommost_level = level;
+      }
+    }
+
+    if (db_options_->bottommost_compression != kDisableCompressionOption &&
+        ci.output_level == bottommost_level) {
+      ASSERT_EQ(ci.compression, db_options_->bottommost_compression);
+    } else if (db_options_->compression_per_level.size() != 0) {
+      ASSERT_EQ(ci.compression,
+                db_options_->compression_per_level[ci.output_level]);
+    } else {
+      ASSERT_EQ(ci.compression, db_options_->compression);
+    }
+    max_level_checked = std::max(max_level_checked, ci.output_level);
+  }
+
+  int max_level_checked = 0;
+  const Options* db_options_;
+};
+
+enum CompressionFailureType {
+  kTestCompressionFail,
+  kTestDecompressionFail,
+  kTestDecompressionCorruption
+};
+
+class CompressionFailuresTest
+    : public DBTest2,
+      public testing::WithParamInterface<std::tuple<
+          CompressionFailureType, CompressionType, uint32_t, uint32_t>> {
+ public:
+  CompressionFailuresTest() {
+    std::tie(compression_failure_type_, compression_type_,
+             compression_max_dict_bytes_, compression_parallel_threads_) =
+        GetParam();
+  }
+
+  CompressionFailureType compression_failure_type_ = kTestCompressionFail;
+  CompressionType compression_type_ = kNoCompression;
+  uint32_t compression_max_dict_bytes_ = 0;
+  uint32_t compression_parallel_threads_ = 0;
+};
+
+INSTANTIATE_TEST_CASE_P(
+    DBTest2, CompressionFailuresTest,
+    ::testing::Combine(::testing::Values(kTestCompressionFail,
+                                         kTestDecompressionFail,
+                                         kTestDecompressionCorruption),
+                       ::testing::ValuesIn(GetSupportedCompressions()),
+                       ::testing::Values(0, 10), ::testing::Values(1, 4)));
+
+TEST_P(CompressionFailuresTest, CompressionFailures) {
+  if (compression_type_ == kNoCompression) {
+    return;
+  }
+
+  Options options = CurrentOptions();
+  options.level0_file_num_compaction_trigger = 2;
+  options.max_bytes_for_level_base = 1024;
+  options.max_bytes_for_level_multiplier = 2;
+  options.num_levels = 7;
+  options.max_background_compactions = 1;
+  options.target_file_size_base = 512;
+
+  BlockBasedTableOptions table_options;
+  table_options.block_size = 512;
+  table_options.verify_compression = true;
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  options.compression = compression_type_;
+  options.compression_opts.parallel_threads = compression_parallel_threads_;
+  options.compression_opts.max_dict_bytes = compression_max_dict_bytes_;
+  options.bottommost_compression_opts.parallel_threads =
+      compression_parallel_threads_;
+  options.bottommost_compression_opts.max_dict_bytes =
+      compression_max_dict_bytes_;
+
+  if (compression_failure_type_ == kTestCompressionFail) {
+    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+        "CompressData:TamperWithReturnValue", [](void* arg) {
+          bool* ret = static_cast<bool*>(arg);
+          *ret = false;
+        });
+  } else if (compression_failure_type_ == kTestDecompressionFail) {
+    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+        "UncompressBlockData:TamperWithReturnValue", [](void* arg) {
+          Status* ret = static_cast<Status*>(arg);
+          ASSERT_OK(*ret);
+          *ret = Status::Corruption("kTestDecompressionFail");
+        });
+  } else if (compression_failure_type_ == kTestDecompressionCorruption) {
+    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+        "UncompressBlockData:"
+        "TamperWithDecompressionOutput",
+        [](void* arg) {
+          BlockContents* contents = static_cast<BlockContents*>(arg);
+          // Ensure uncompressed data != original data
+          const size_t len = contents->data.size() + 1;
+          std::unique_ptr<char[]> fake_data(new char[len]());
+          *contents = BlockContents(std::move(fake_data), len);
+        });
+  }
+
+  std::map<std::string, std::string> key_value_written;
+
+  const int kKeySize = 5;
+  const int kValUnitSize = 16;
+  const int kValSize = 256;
+  Random rnd(405);
+
+  Status s = Status::OK();
+
+  DestroyAndReopen(options);
+  // Write 10 random files
+  for (int i = 0; i < 10; i++) {
+    for (int j = 0; j < 5; j++) {
+      std::string key = rnd.RandomString(kKeySize);
+      // Ensure good compression ratio
+      std::string valueUnit = rnd.RandomString(kValUnitSize);
+      std::string value;
+      for (int k = 0; k < kValSize; k += kValUnitSize) {
+        value += valueUnit;
+      }
+      s = Put(key, value);
+      if (compression_failure_type_ == kTestCompressionFail) {
+        key_value_written[key] = value;
+        ASSERT_OK(s);
+      }
+    }
+    s = Flush();
+    if (compression_failure_type_ == kTestCompressionFail) {
+      ASSERT_OK(s);
+    }
+    s = dbfull()->TEST_WaitForCompact();
+    if (compression_failure_type_ == kTestCompressionFail) {
+      ASSERT_OK(s);
+    }
+    if (i == 4) {
+      // Make compression fail at the mid of table building
+      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+    }
+  }
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+
+  if (compression_failure_type_ == kTestCompressionFail) {
+    // Should be kNoCompression, check content consistency
+    std::unique_ptr<Iterator> db_iter(db_->NewIterator(ReadOptions()));
+    for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
+      std::string key = db_iter->key().ToString();
+      std::string value = db_iter->value().ToString();
+      ASSERT_NE(key_value_written.find(key), key_value_written.end());
+      ASSERT_EQ(key_value_written[key], value);
+      key_value_written.erase(key);
+    }
+    ASSERT_OK(db_iter->status());
+    ASSERT_EQ(0, key_value_written.size());
+  } else if (compression_failure_type_ == kTestDecompressionFail) {
+    ASSERT_EQ(std::string(s.getState()),
+              "Could not decompress: kTestDecompressionFail");
+  } else if (compression_failure_type_ == kTestDecompressionCorruption) {
+    ASSERT_EQ(std::string(s.getState()),
+              "Decompressed block did not match pre-compression block");
+  }
+}
+
+TEST_F(DBTest2, CompressionOptions) {
+  if (!Zlib_Supported() || !Snappy_Supported()) {
+    return;
+  }
+
+  Options options = CurrentOptions();
+  options.level0_file_num_compaction_trigger = 2;
+  options.max_bytes_for_level_base = 100;
+  options.max_bytes_for_level_multiplier = 2;
+  options.num_levels = 7;
+  options.max_background_compactions = 1;
+
+  CompactionCompressionListener* listener =
+      new CompactionCompressionListener(&options);
+  options.listeners.emplace_back(listener);
+
+  const int kKeySize = 5;
+  const int kValSize = 20;
+  Random rnd(301);
+
+  std::vector<uint32_t> compression_parallel_threads = {1, 4};
+
+  std::map<std::string, std::string> key_value_written;
+
+  for (int iter = 0; iter <= 2; iter++) {
+    listener->max_level_checked = 0;
+
+    if (iter == 0) {
+      // Use different compression algorithms for different levels but
+      // always use Zlib for bottommost level
+      options.compression_per_level = {kNoCompression,     kNoCompression,
+                                       kNoCompression,     kSnappyCompression,
+                                       kSnappyCompression, kSnappyCompression,
+                                       kZlibCompression};
+      options.compression = kNoCompression;
+      options.bottommost_compression = kZlibCompression;
+    } else if (iter == 1) {
+      // Use Snappy except for bottommost level use ZLib
+      options.compression_per_level = {};
+      options.compression = kSnappyCompression;
+      options.bottommost_compression = kZlibCompression;
+    } else if (iter == 2) {
+      // Use Snappy everywhere
+      options.compression_per_level = {};
+      options.compression = kSnappyCompression;
+      options.bottommost_compression = kDisableCompressionOption;
+    }
+
+    for (auto num_threads : compression_parallel_threads) {
+      options.compression_opts.parallel_threads = num_threads;
+      options.bottommost_compression_opts.parallel_threads = num_threads;
+
+      DestroyAndReopen(options);
+      // Write 10 random files
+      for (int i = 0; i < 10; i++) {
+        for (int j = 0; j < 5; j++) {
+          std::string key = rnd.RandomString(kKeySize);
+          std::string value = rnd.RandomString(kValSize);
+          key_value_written[key] = value;
+          ASSERT_OK(Put(key, value));
+        }
+        ASSERT_OK(Flush());
+        ASSERT_OK(dbfull()->TEST_WaitForCompact());
+      }
+
+      // Make sure that we wrote enough to check all 7 levels
+      ASSERT_EQ(listener->max_level_checked, 6);
+
+      // Make sure database content is the same as key_value_written
+      std::unique_ptr<Iterator> db_iter(db_->NewIterator(ReadOptions()));
+      for (db_iter->SeekToFirst(); db_iter->Valid(); db_iter->Next()) {
+        std::string key = db_iter->key().ToString();
+        std::string value = db_iter->value().ToString();
+        ASSERT_NE(key_value_written.find(key), key_value_written.end());
+        ASSERT_EQ(key_value_written[key], value);
+        key_value_written.erase(key);
+      }
+      ASSERT_OK(db_iter->status());
+      ASSERT_EQ(0, key_value_written.size());
+    }
+  }
+}
+
 class CompactionStallTestListener : public EventListener {
 public:
  CompactionStallTestListener()
@@ -2310,7 +3010,7 @@ TEST_F(DBTest2, PausingManualCompaction1) {
      "TestCompactFiles:PausingManualCompaction:3", [&](void* arg) {
        auto paused = static_cast<std::atomic<int>*>(arg);
        // CompactFiles() relies on manual_compactions_paused to
-        // determine if this compaction should be paused or not
+        // determine if thie compaction should be paused or not
        ASSERT_EQ(0, paused->load(std::memory_order_acquire));
        paused->fetch_add(1, std::memory_order_release);
      });
@@ -2422,7 +3122,6 @@ TEST_F(DBTest2, PausingManualCompaction3) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();

  dbfull()->DisableManualCompaction();
-
  ASSERT_TRUE(dbfull()
                  ->CompactRange(compact_options, nullptr, nullptr)
                  .IsManualCompactionPaused());
@@ -4722,103 +5421,6 @@ TEST_F(DBTest2, TestCompactFiles) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_F(DBTest2, TestCancelCompactFiles) {
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  Options options;
-  options.env = env_;
-  options.num_levels = 2;
-  options.disable_auto_compactions = true;
-  Reopen(options);
-
-  auto* handle = db_->DefaultColumnFamily();
-  ASSERT_EQ(db_->NumberLevels(handle), 2);
-
-  ROCKSDB_NAMESPACE::SstFileWriter sst_file_writer{
-      ROCKSDB_NAMESPACE::EnvOptions(), options};
-
-  // ingest large SST files
-  std::vector<std::string> external_sst_file_names;
-  int key_counter = 0;
-  const int num_keys_per_file = 100000;
-  const int num_files = 10;
-  for (int i = 0; i < num_files; ++i) {
-    std::string file_name =
-        dbname_ + "/test_compact_files" + std::to_string(i) + ".sst_t";
-    external_sst_file_names.push_back(file_name);
-    ASSERT_OK(sst_file_writer.Open(file_name));
-    for (int j = 0; j < num_keys_per_file; ++j) {
-      ASSERT_OK(sst_file_writer.Put(Key(j + num_keys_per_file * key_counter),
-                                    std::to_string(j)));
-    }
-    key_counter += 1;
-    ASSERT_OK(sst_file_writer.Finish());
-  }
-
-  ASSERT_OK(db_->IngestExternalFile(handle, external_sst_file_names,
-                                    IngestExternalFileOptions()));
-  ASSERT_EQ(NumTableFilesAtLevel(1, 0), num_files);
-  std::vector<std::string> files;
-  GetSstFiles(env_, dbname_, &files);
-  ASSERT_EQ(files.size(), num_files);
-
-  // Test that 0 compactions happen - canceled is set to True initially
-  CompactionOptions compaction_options;
-  std::atomic<bool> canceled(true);
-  compaction_options.canceled = &canceled;
-
-  ASSERT_TRUE(db_->CompactFiles(compaction_options, handle, files, 1)
-                  .IsManualCompactionPaused());
-  ASSERT_EQ(NumTableFilesAtLevel(1, 0), num_files);
-
-  // Test cancellation before the check to cancel compaction happens -
-  // compaction should not occur
-  bool disable_compaction = false;
-  compaction_options.canceled->store(false, std::memory_order_release);
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "TestCancelCompactFiles:SuccessfulCompaction", [&](void* arg) {
-        auto paused = static_cast<std::atomic<int>*>(arg);
-        if (disable_compaction) {
-          db_->DisableManualCompaction();
-          ASSERT_EQ(1, paused->load(std::memory_order_acquire));
-        } else {
-          compaction_options.canceled->store(true, std::memory_order_release);
-          ASSERT_EQ(0, paused->load(std::memory_order_acquire));
-        }
-      });
-
-  ASSERT_TRUE(db_->CompactFiles(compaction_options, handle, files, 1)
-                  .IsManualCompactionPaused());
-  ASSERT_EQ(NumTableFilesAtLevel(1, 0), num_files);
-
-  // DisableManualCompaction() should successfully cancel compaction
-  disable_compaction = true;
-  compaction_options.canceled->store(false, std::memory_order_release);
-  ASSERT_TRUE(db_->CompactFiles(compaction_options, handle, files, 1)
-                  .IsManualCompactionPaused());
-  ASSERT_EQ(NumTableFilesAtLevel(1, 0), num_files);
-  // unlike CompactRange, value of compaction_options.canceled will be
-  // unaffected by calling DisableManualCompactions()
-  ASSERT_FALSE(compaction_options.canceled->load());
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-  db_->EnableManualCompaction();
-
-  // Test cancelation after the check to cancel compaction - compaction should
-  // occur, leaving only 1 file
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactFilesImpl:0", [&](void* /*arg*/) {
-        compaction_options.canceled->store(true, std::memory_order_release);
-      });
-
-  compaction_options.canceled->store(false, std::memory_order_release);
-  ASSERT_OK(db_->CompactFiles(compaction_options, handle, files, 1));
-  ASSERT_EQ(NumTableFilesAtLevel(1, 0), 1);
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(DBTest2, MultiDBParallelOpenTest) {
  const int kNumDbs = 2;
  Options options = CurrentOptions();
@@ -11,7 +11,6 @@

 #include "cache/cache_reservation_manager.h"
 #include "db/forward_iterator.h"
-#include "env/fs_readonly.h"
 #include "env/mock_env.h"
 #include "port/lang.h"
 #include "rocksdb/cache.h"
@@ -592,6 +591,7 @@ Options DBTestBase::GetOptions(
      options_override.level_compaction_dynamic_level_bytes;
  options.env = env_;
  options.create_if_missing = true;
+  options.fail_if_options_file_error = true;
  return options;
 }

@@ -716,17 +716,6 @@ Status DBTestBase::ReadOnlyReopen(const Options& options) {
  return DB::OpenForReadOnly(options, dbname_, &db_);
 }

-Status DBTestBase::EnforcedReadOnlyReopen(const Options& options) {
-  Close();
-  Options options_copy = options;
-  MaybeInstallTimeElapseOnlySleep(options_copy);
-  auto fs_read_only =
-      std::make_shared<ReadOnlyFileSystem>(env_->GetFileSystem());
-  env_read_only_ = std::make_shared<CompositeEnvWrapper>(env_, fs_read_only);
-  options_copy.env = env_read_only_.get();
-  return DB::OpenForReadOnly(options_copy, dbname_, &db_);
-}
-
 Status DBTestBase::TryReopen(const Options& options) {
  Close();
  last_options_.table_factory.reset();
@@ -452,10 +452,6 @@ class SpecialEnv : public EnvWrapper {
        return s;
      }

-      Status GetFileSize(uint64_t* s) override {
-        return target_->GetFileSize(s);
-      }
-
     private:
      std::unique_ptr<RandomAccessFile> target_;
      anon::AtomicCounter* counter_;
@@ -482,10 +478,6 @@ class SpecialEnv : public EnvWrapper {
        return target_->Prefetch(offset, n);
      }

-      Status GetFileSize(uint64_t* s) override {
-        return target_->GetFileSize(s);
-      }
-
     private:
      std::unique_ptr<RandomAccessFile> target_;
      std::atomic<uint64_t>* fail_cnt_;
@@ -1070,7 +1062,6 @@ class DBTestBase : public testing::Test {
  MockEnv* mem_env_;
  Env* encrypted_env_;
  SpecialEnv* env_;
-  std::shared_ptr<Env> env_read_only_;
  std::shared_ptr<Env> env_guard_;
  DB* db_;
  std::vector<ColumnFamilyHandle*> handles_;
@@ -1187,9 +1178,6 @@ class DBTestBase : public testing::Test {

  Status ReadOnlyReopen(const Options& options);

-  // With a filesystem wrapper that fails on attempted write
-  Status EnforcedReadOnlyReopen(const Options& options);
-
  Status TryReopen(const Options& options);

  bool IsDirectIOSupported();
@@ -1672,75 +1672,55 @@ TEST_P(DBTestUniversalCompaction, ConcurrentBottomPriLowPriCompactions) {
  }
  const int kNumFilesTrigger = 3;
  Env::Default()->SetBackgroundThreads(1, Env::Priority::BOTTOM);
+  Options options = CurrentOptions();
+  options.compaction_style = kCompactionStyleUniversal;
+  options.max_background_compactions = 2;
+  options.num_levels = num_levels_;
+  options.write_buffer_size = 100 << 10;     // 100KB
+  options.target_file_size_base = 32 << 10;  // 32KB
+  options.level0_file_num_compaction_trigger = kNumFilesTrigger;
+  // Trigger compaction if size amplification exceeds 110%
+  options.compaction_options_universal.max_size_amplification_percent = 110;
+  DestroyAndReopen(options);

-  for (bool universal_reduce_file_locking : {true, false}) {
-    Options options = CurrentOptions();
-    options.compaction_style = kCompactionStyleUniversal;
-    options.compaction_options_universal.reduce_file_locking =
-        universal_reduce_file_locking;
-    options.max_background_compactions = 2;
-    options.num_levels = num_levels_;
-    options.write_buffer_size = 100 << 10;     // 100KB
-    options.target_file_size_base = 32 << 10;  // 32KB
-    options.level0_file_num_compaction_trigger = kNumFilesTrigger;
-    // Trigger compaction if size amplification exceeds 110%
-    options.compaction_options_universal.max_size_amplification_percent = 110;
-    DestroyAndReopen(options);
+  // Need to get a token to enable compaction parallelism up to
+  // `max_background_compactions` jobs.
+  auto pressure_token =
+      dbfull()->TEST_write_controler().GetCompactionPressureToken();
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
+      {// wait for the full compaction to be picked before adding files intended
+       // for the second one.
+       {"DBImpl::BackgroundCompaction:ForwardToBottomPriPool",
+        "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0"},
+       // the full (bottom-pri) compaction waits until a partial (low-pri)
+       // compaction has started to verify they can run in parallel.
+       {"DBImpl::BackgroundCompaction:NonTrivial",
+        "DBImpl::BGWorkBottomCompaction"}});
+  SyncPoint::GetInstance()->EnableProcessing();

-    // Need to get a token to enable compaction parallelism up to
-    // `max_background_compactions` jobs.
-    auto pressure_token =
-        dbfull()->TEST_write_controler().GetCompactionPressureToken();
-    if (universal_reduce_file_locking) {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-          {// Wait for the full compaction to be repicked before adding files
-           // intended for the second compaction.
-           {"DBImpl::BackgroundCompaction():AfterPickCompactionBottomPri",
-            "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0"},
-           // Wait for the second compaction to run before running the full
-           // compaction to verify they can run in parallel
-           {"DBImpl::BackgroundCompaction:NonTrivial:BeforeRun",
-            "DBImpl::BackgroundCompaction:NonTrivial:BeforeRunBottomPri"}});
-    } else {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-          {// Wait for the full compaction to be forwarded before adding files
-           // intended for the second compaction.
-           {"DBImpl::BackgroundCompaction:ForwardToBottomPriPool",
-            "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0"},
-           // Wait for the second compaction to run before running the full
-           // compaction to verify they can run in parallel
-           {"DBImpl::BackgroundCompaction:NonTrivial:BeforeRun",
-            "DBImpl::BackgroundCompaction:NonTrivial:BeforeRunBottomPri"}});
+  Random rnd(301);
+  for (int i = 0; i < 2; ++i) {
+    for (int num = 0; num < kNumFilesTrigger; num++) {
+      int key_idx = 0;
+      GenerateNewFile(&rnd, &key_idx, true /* no_wait */);
+      // use no_wait above because that one waits for flush and compaction. We
+      // don't want to wait for compaction because the full compaction is
+      // intentionally blocked while more files are flushed.
+      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
    }
-
-    SyncPoint::GetInstance()->EnableProcessing();
-
-    Random rnd(301);
-    for (int i = 0; i < 2; ++i) {
-      for (int num = 0; num < kNumFilesTrigger; num++) {
-        int key_idx = 0;
-        GenerateNewFile(&rnd, &key_idx, true /* no_wait */);
-        // use no_wait above because that one waits for flush and compaction. We
-        // don't want to wait for compaction because the full compaction is
-        // intentionally blocked while more files are flushed.
-        ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-      }
-      if (i == 0) {
-        TEST_SYNC_POINT(
-            "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0");
-      }
+    if (i == 0) {
+      TEST_SYNC_POINT(
+          "DBTestUniversalCompaction:ConcurrentBottomPriLowPriCompactions:0");
    }
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-    // First compaction should output to bottom level. Second should output to
-    // L0 since older L0 files pending compaction prevent it from being placed
-    // lower.
-    ASSERT_EQ(NumSortedRuns(), 2);
-    ASSERT_GT(NumTableFilesAtLevel(0), 0);
-    ASSERT_GT(NumTableFilesAtLevel(num_levels_ - 1), 0);
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
  }
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());

+  // First compaction should output to bottom level. Second should output to L0
+  // since older L0 files pending compaction prevent it from being placed lower.
+  ASSERT_EQ(NumSortedRuns(), 2);
+  ASSERT_GT(NumTableFilesAtLevel(0), 0);
+  ASSERT_GT(NumTableFilesAtLevel(num_levels_ - 1), 0);
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
  Env::Default()->SetBackgroundThreads(0, Env::Priority::BOTTOM);
 }

@@ -3024,13 +3024,13 @@ TEST_F(DBWALTest, GetCompressedWalsAfterSync) {
  options.wal_compression = kZSTD;
  DestroyAndReopen(options);

-  // Write something to memtable and WAL so that wal_empty_ will be false after
+  // Write something to memtable and WAL so that log_empty_ will be false after
  // next DB::Open().
  ASSERT_OK(Put("a", "v"));

  Reopen(options);

-  // New WAL is created, thanks to !wal_empty_.
+  // New WAL is created, thanks to !log_empty_.
  ASSERT_OK(dbfull()->TEST_SwitchWAL());

  ASSERT_OK(Put("b", "v"));
@@ -19,13 +19,6 @@
 #include "utilities/merge_operators/string_append/stringappend2.h"

 namespace ROCKSDB_NAMESPACE {
-namespace {
-std::string EncodeAsUint64(uint64_t v) {
-  std::string dst;
-  PutFixed64(&dst, v);
-  return dst;
-}
-}  // namespace
 class DBBasicTestWithTimestamp : public DBBasicTestWithTimestampBase {
 public:
  DBBasicTestWithTimestamp()
@@ -1487,24 +1480,13 @@ TEST_F(DBBasicTestWithTimestamp, ReseekToUserKeyBeforeSavedKey) {
  Close();
 }

-class ReverseIterationWithUnpreparedBlobTest
-    : public DBBasicTestWithTimestampBase,
-      public testing::WithParamInterface<std::tuple<bool, uint64_t>> {
- public:
-  ReverseIterationWithUnpreparedBlobTest()
-      : DBBasicTestWithTimestampBase(
-            "db_basic_test_with_timestamp_reverse_with_unprepare") {}
-};
-INSTANTIATE_TEST_CASE_P(ReverseIterationWithUnpreparedBlobTest,
-                        ReverseIterationWithUnpreparedBlobTest,
-                        ::testing::Combine(::testing::Values(true, false),
-                                           ::testing::Values(0, 2)));
-TEST_P(ReverseIterationWithUnpreparedBlobTest, Basic) {
+TEST_F(DBBasicTestWithTimestamp,
+       FIXME_ReverseIterationWithBlobAndUnpreparedValue) {
  Options options = CurrentOptions();
  options.create_if_missing = true;
  options.env = env_;
  options.enable_blob_files = true;
-  options.max_sequential_skip_in_iterations = std::get<1>(GetParam());
+  options.max_sequential_skip_in_iterations = 0;

  const size_t kTimestampSize = Timestamp(0, 0).size();
  TestComparator test_cmp(kTimestampSize);
@@ -1519,7 +1501,7 @@ TEST_P(ReverseIterationWithUnpreparedBlobTest, Basic) {
  for (uint64_t key = 0; key <= kMaxKey; ++key) {
    for (size_t i = 0; i < write_timestamps.size(); ++i) {
      ASSERT_OK(db_->Put(WriteOptions(), Key1(key), write_timestamps[i],
-                         Key1(key) + "value" + std::to_string(i)));
+                         "value" + std::to_string(i)));
    }
  }

@@ -1531,28 +1513,17 @@ TEST_P(ReverseIterationWithUnpreparedBlobTest, Basic) {

    ReadOptions read_opts;
    read_opts.timestamp = &read_timestamp;
-    read_opts.allow_unprepared_value = std::get<0>(GetParam());
+    read_opts.allow_unprepared_value = true;

    std::unique_ptr<Iterator> it(db_->NewIterator(read_opts));

    it->SeekForPrev(Key1(kMaxKey));
-    uint64_t key = kMaxKey;
-    int count = 0;
-    while (it->Valid()) {
-      ASSERT_OK(it->status());
-
-      ASSERT_TRUE(it->PrepareValue());
-      ASSERT_TRUE(it->Valid());
-      ASSERT_OK(it->status());
-      ASSERT_EQ(it->key(), Key1(key));
-      ASSERT_EQ(it->timestamp(), Timestamp(3, 0));
-      ASSERT_EQ(it->value(), Key1(key) + "value" + std::to_string(1));
-      key--;
-      count++;
-      it->Prev();
-    }
+    ASSERT_TRUE(it->Valid());
    ASSERT_OK(it->status());
-    ASSERT_EQ(kMaxKey + 1, count);
+
+    // FIXME: PrepareValue() should succeed and status() should remain OK
+    ASSERT_FALSE(it->PrepareValue());
+    ASSERT_TRUE(it->status().IsCorruption());
  }

  Close();
@@ -2400,6 +2371,7 @@ class DataVisibilityTest : public DBBasicTestWithTimestampBase {
    }
  }
 };
+constexpr int DataVisibilityTest::kTestDataSize;

 // Application specifies timestamp but not snapshot.
 //           reader              writer
@@ -3774,42 +3746,17 @@ INSTANTIATE_TEST_CASE_P(
        test::UserDefinedTimestampTestMode::kStripUserDefinedTimestamp,
        test::UserDefinedTimestampTestMode::kNormal));

-// Test params:
-// 1) whether to flush before close
-class EnableDisableUDTTest : public DBBasicTestWithTimestampBase,
-                             public testing::WithParamInterface<bool> {
- public:
-  EnableDisableUDTTest()
-      : DBBasicTestWithTimestampBase("/enable_disable_udt") {}
-};
-
-INSTANTIATE_TEST_CASE_P(EnableDisableUDTTest, EnableDisableUDTTest,
-                        ::testing::Values(true, false));
-
-TEST_P(EnableDisableUDTTest, Basic) {
+TEST_F(DBBasicTestWithTimestamp, EnableDisableUDT) {
  Options options = CurrentOptions();
-  // Un-flushed data before close will involve a WAL replay on DB reopen.
-  bool flush_before_close = GetParam();
  options.env = env_;
+  // Create a column family without user-defined timestamps.
  options.comparator = BytewiseComparator();
  options.persist_user_defined_timestamps = true;
  DestroyAndReopen(options);

-  ReadOptions ropts;
-  std::string read_ts;
-  std::string value;
-  std::string key_ts;
-
  // Create one SST file, its user keys have no user-defined timestamps.
-  ASSERT_OK(db_->Put(WriteOptions(), "foo", "val0"));
-  ASSERT_OK(db_->Put(WriteOptions(), "bar", "val0"));
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), "bar", "baz"));
-  ASSERT_OK(db_->Get(ReadOptions(), "foo", &value));
-  ASSERT_EQ("val0", value);
-  ASSERT_TRUE(db_->Get(ReadOptions(), "bar", &value).IsNotFound());
-  if (flush_before_close) {
-    ASSERT_OK(Flush(0));
-  }
+  ASSERT_OK(db_->Put(WriteOptions(), "foo", "val1"));
+  ASSERT_OK(Flush(0));
  Close();

  // Reopen the existing column family and enable user-defined timestamps
@@ -3818,63 +3765,47 @@ TEST_P(EnableDisableUDTTest, Basic) {
  options.persist_user_defined_timestamps = false;
  options.allow_concurrent_memtable_write = false;
  Reopen(options);
-  // Read data from previous session before and after compaction.
-  read_ts = EncodeAsUint64(1);
+
+  std::string value;
+  ASSERT_TRUE(db_->Get(ReadOptions(), "foo", &value).IsInvalidArgument());
+  std::string read_ts;
+  PutFixed64(&read_ts, 0);
+  ReadOptions ropts;
  Slice read_ts_slice = read_ts;
  ropts.timestamp = &read_ts_slice;
-  for (int i = 0; i < 2; i++) {
-    ASSERT_TRUE(db_->Get(ReadOptions(), "foo", &value).IsInvalidArgument());
-    // Entries in pre-existing SST files are treated as if they have minimum
-    // user-defined timestamps.
-    ASSERT_OK(db_->Get(ropts, "foo", &value, &key_ts));
-    ASSERT_EQ("val0", value);
-    ASSERT_EQ(EncodeAsUint64(0), key_ts);
-    ASSERT_TRUE(db_->Get(ropts, "bar", &value, &key_ts).IsNotFound());
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  }
-
-  // Do timestamped read / write.
-  ASSERT_OK(db_->Put(WriteOptions(), "foo", EncodeAsUint64(1), "val1"));
-  ASSERT_OK(db_->Put(WriteOptions(), "bar", EncodeAsUint64(1), "val1"));
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), "bar", "baz", EncodeAsUint64(2)));
+  std::string key_ts;
+  // Entries in pre-existing SST files are treated as if they have minimum
+  // user-defined timestamps.
  ASSERT_OK(db_->Get(ropts, "foo", &value, &key_ts));
  ASSERT_EQ("val1", value);
-  ASSERT_EQ(EncodeAsUint64(1), key_ts);
-  ASSERT_OK(db_->Get(ropts, "bar", &value, &key_ts));
-  ASSERT_EQ("val1", value);
-  ASSERT_EQ(EncodeAsUint64(1), key_ts);
-  read_ts = EncodeAsUint64(2);
-  ASSERT_TRUE(db_->Get(ropts, "bar", &value, &key_ts).IsNotFound());
+  ASSERT_EQ(read_ts, key_ts);
+
+  // Do timestamped read / write.
+  std::string write_ts;
+  PutFixed64(&write_ts, 1);
+  ASSERT_OK(db_->Put(WriteOptions(), "foo", write_ts, "val2"));
+  read_ts.clear();
+  PutFixed64(&read_ts, 1);
+  ASSERT_OK(db_->Get(ropts, "foo", &value, &key_ts));
+  ASSERT_EQ("val2", value);
+  ASSERT_EQ(write_ts, key_ts);
  // The user keys in this SST file don't have user-defined timestamps either,
  // because `persist_user_defined_timestamps` flag is set to false.
-  if (flush_before_close) {
-    ASSERT_OK(Flush(0));
-  }
+  ASSERT_OK(Flush(0));
  Close();

  // Reopen the existing column family while disabling user-defined timestamps.
  options.comparator = BytewiseComparator();
  Reopen(options);

-  // Read data from previous session before and after compaction.
-  for (int i = 0; i < 2; i++) {
-    ASSERT_TRUE(db_->Get(ropts, "foo", &value).IsInvalidArgument());
-    ASSERT_OK(db_->Get(ReadOptions(), "foo", &value));
-    ASSERT_EQ("val1", value);
-    ASSERT_TRUE(db_->Get(ReadOptions(), "bar", &value).IsNotFound());
-    ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  }
-
-  // Continue to write / read the column family without user-defined timestamps.
-  ASSERT_OK(db_->Put(WriteOptions(), "foo", "val2"));
-  ASSERT_OK(db_->Put(WriteOptions(), "bar", "val2"));
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), "bar", "baz"));
+  ASSERT_TRUE(db_->Get(ropts, "foo", &value).IsInvalidArgument());
  ASSERT_OK(db_->Get(ReadOptions(), "foo", &value));
  ASSERT_EQ("val2", value);
-  ASSERT_TRUE(db_->Get(ReadOptions(), "bar", &value).IsNotFound());
-  if (flush_before_close) {
-    ASSERT_OK(Flush(0));
-  }
+
+  // Continue to write / read the column family without user-defined timestamps.
+  ASSERT_OK(db_->Put(WriteOptions(), "foo", "val3"));
+  ASSERT_OK(db_->Get(ReadOptions(), "foo", &value));
+  ASSERT_EQ("val3", value);
  Close();
 }

@@ -4913,117 +4844,6 @@ TEST_F(DBBasicTestWithTimestamp, TimestampFilterTableReadOnGet) {
  Close();
 }

-class GetNewestUserDefinedTimestampTest : public DBBasicTestWithTimestampBase {
- public:
-  explicit GetNewestUserDefinedTimestampTest()
-      : DBBasicTestWithTimestampBase("get_newest_udt_test") {}
-};
-
-TEST_F(GetNewestUserDefinedTimestampTest, Basic) {
-  std::string newest_timestamp;
-  // UDT disabled, get InvalidArgument.
-  ASSERT_TRUE(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp)
-                  .IsInvalidArgument());
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.max_write_buffer_number = 5;
-  options.min_write_buffer_number_to_merge = 4;
-  options.comparator = test::BytewiseComparatorWithU64TsWrapper();
-
-  DestroyAndReopen(options);
-  // UDT persisted, get NotSupported.
-  ASSERT_TRUE(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp)
-                  .IsNotSupported());
-
-  options.persist_user_defined_timestamps = false;
-  options.allow_concurrent_memtable_write = false;
-
-  DestroyAndReopen(options);
-  ASSERT_TRUE(
-      db_->GetNewestUserDefinedTimestamp(nullptr, nullptr).IsInvalidArgument());
-
-  ColumnFamilyHandleImpl* cfh = static_cast_with_check<ColumnFamilyHandleImpl>(
-      db_->DefaultColumnFamily());
-  ColumnFamilyData* cfd = cfh->cfd();
-  // The column family hasn't seen any user defined timestamp
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_TRUE(newest_timestamp.empty());
-
-  ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(1), "val1"));
-  // Testing get newest timestamp from mutable memtable.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(1), newest_timestamp);
-
-  ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(2), "val2"));
-  ASSERT_OK(dbfull()->TEST_SwitchMemtable(cfd));
-  // Testing get the newest timestamp from immutable memtable because the
-  // mutable one is empty.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(2), newest_timestamp);
-
-  ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(3), "val3"));
-  ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(4), "val4"));
-  ASSERT_OK(dbfull()->TEST_SwitchMemtable(cfd));
-  // Testing get the newest timestamp from the more recent immutable memtable
-  // when there are multiple immutable memtables.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(4), newest_timestamp);
-
-  ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(5), "val5"));
-  // Testing get newest timestamp from mutable memtable when it has data, in the
-  // presence of immutable memtables.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(5), newest_timestamp);
-
-  ASSERT_OK(Flush());
-  // After flushing and all the user defined timestamp are flushed. User defined
-  // timestamp info for SST files is available from MANIFEST.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(5), newest_timestamp);
-
-  Reopen(options);
-  // Similar after flush, when there is no memtables, but some SST files,
-  // if MANIFEST records the upperbound of flushed timestamps because timestamps
-  // are not persisted in SST files, this info can be found.
-  ASSERT_OK(db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-  ASSERT_EQ(EncodeAsUint64(5), newest_timestamp);
-
-  Close();
-}
-
-TEST_F(GetNewestUserDefinedTimestampTest, ConcurrentWrites) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.comparator = test::BytewiseComparatorWithU64TsWrapper();
-  options.persist_user_defined_timestamps = false;
-  options.allow_concurrent_memtable_write = false;
-
-  DestroyAndReopen(options);
-
-  std::vector<std::thread> threads;
-  threads.reserve(10);
-  std::atomic<uint64_t> current_ts{0};
-  for (int i = 0; i < 10; i++) {
-    threads.emplace_back([this, i, &current_ts]() {
-      if (i % 2 == 0) {
-        std::string newest_timestamp;
-        ASSERT_OK(
-            db_->GetNewestUserDefinedTimestamp(nullptr, &newest_timestamp));
-      } else {
-        uint64_t write_ts = current_ts.fetch_add(1);
-        ASSERT_OK(db_->Put(WriteOptions(), Key(1), EncodeAsUint64(write_ts),
-                           "val" + std::to_string(i)));
-      }
-    });
-  }
-
-  for (auto& t : threads) {
-    t.join();
-  }
-  Close();
-}
-
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -987,7 +987,7 @@ TEST_P(DBWriteTest, RecycleLogToggleTest) {

  options.recycle_log_file_num = 1;
  Reopen(options);
-  // 1.log is added to alive_wal_files_
+  // 1.log is added to alive_log_files_
  ASSERT_OK(Put(Key(2), "val1"));
  ASSERT_OK(Flush());
  // 1.log should be deleted and not recycled, since it
@@ -1000,80 +1000,6 @@ TEST_P(DBWriteTest, RecycleLogToggleTest) {
  ASSERT_EQ(Get(Key(1)), "val2");
 }

-TEST_P(DBWriteTest, IngestWriteBatchWithIndex) {
-  if (GetParam() == kPipelinedWrite) {
-    return;
-  }
-
-  Options options = GetOptions();
-  options.disable_auto_compactions = true;
-  Reopen(options);
-  Options cf_options = GetOptions();
-  cf_options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  CreateColumnFamilies({"cf1", "cf2"}, cf_options);
-  ReopenWithColumnFamilies({"default", "cf1", "cf2"},
-                           {options, cf_options, cf_options});
-
-  // default cf
-  auto wbwi1 = std::make_shared<WriteBatchWithIndex>(options.comparator, 0,
-                                                     /*overwrite_key=*/true);
-  ASSERT_OK(wbwi1->Put("key1", "value1"));
-  ASSERT_OK(wbwi1->Put("key2", "value2"));
-  if (GetParam() == kPipelinedWrite) {
-    ASSERT_TRUE(db_->IngestWriteBatchWithIndex({}, wbwi1).IsNotSupported());
-    return;
-  }
-  // Test disableWAL=false
-  ASSERT_TRUE(db_->IngestWriteBatchWithIndex({}, wbwi1).IsNotSupported());
-
-  WriteOptions wo;
-  wo.disableWAL = true;
-  ASSERT_OK(db_->IngestWriteBatchWithIndex(wo, wbwi1));
-  ASSERT_EQ("value1", Get("key1"));
-  ASSERT_EQ("value2", Get("key2"));
-
-  // Test with overwrites
-  auto wbwi = std::make_shared<WriteBatchWithIndex>(options.comparator, 0,
-                                                    /*overwrite_key=*/true);
-  ASSERT_OK(wbwi->Put("key2", "value3"));
-  ASSERT_OK(wbwi->Delete("key1"));  // Delete an existing key
-  ASSERT_OK(db_->IngestWriteBatchWithIndex(wo, wbwi));
-  ASSERT_EQ("NOT_FOUND", Get("key1"));
-  ASSERT_EQ("value3", Get("key2"));
-
-  auto wbwi2 = std::make_shared<WriteBatchWithIndex>(options.comparator, 0,
-                                                     /*overwrite_key=*/true);
-  ASSERT_OK(wbwi2->Put(handles_[1], "cf1_key1", "cf1_value1"));
-  ASSERT_OK(wbwi2->Delete(handles_[1], "cf1_key2"));
-  // Test ingestion with column family
-  ASSERT_OK(db_->IngestWriteBatchWithIndex(wo, wbwi2));
-  ASSERT_EQ("cf1_value1", Get(1, "cf1_key1"));
-  ASSERT_EQ("NOT_FOUND", Get(1, "cf1_key2"));
-
-  auto wbwi3 = std::make_shared<WriteBatchWithIndex>(options.comparator, 0,
-                                                     /*overwrite_key=*/true);
-  ASSERT_OK(wbwi3->Merge(handles_[2], "cf2_key1", "cf2_value1"));
-  ASSERT_OK(wbwi3->Merge(handles_[2], "cf2_key1", "cf2_value2"));
-  // Test ingestion with merge operations
-  ASSERT_OK(db_->IngestWriteBatchWithIndex(wo, wbwi3));
-  ASSERT_EQ("cf2_value1,cf2_value2", Get(2, "cf2_key1"));
-
-  // Test with overwrite_key = false
-  auto wbwi_no_overwrite = std::make_shared<WriteBatchWithIndex>(
-      options.comparator, 0, /*overwrite_key=*/false);
-  ASSERT_OK(wbwi_no_overwrite->Put("key1", "value1"));
-  Status s = db_->IngestWriteBatchWithIndex(wo, wbwi_no_overwrite);
-  ASSERT_TRUE(s.IsNotSupported());
-
-  auto empty_wbwi = std::make_shared<WriteBatchWithIndex>(
-      options.comparator, 0, /*overwrite_key=*/true);
-  ASSERT_OK(db_->IngestWriteBatchWithIndex(wo, empty_wbwi));
-
-  DestroyAndReopen(options);
-  // Should fail when trying to ingest to non-existent column family
-  ASSERT_NOK(db_->IngestWriteBatchWithIndex(wo, wbwi2));
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                        testing::Values(DBTestBase::kDefault,
                                        DBTestBase::kConcurrentWALWrites,
@@ -83,8 +83,6 @@ extern const ValueType kValueTypeForSeekForPrev;

 // A range of user keys used internally by RocksDB. Also see `Range` used by
 // public APIs.
-// TODO: merge with Range in pubic API, but this is generally inclusive limit
-// and it is maybe exclusive limit
 struct UserKeyRange {
  // In case of user_defined timestamp, if enabled, `start` and `limit` should
  // include user_defined timestamps.
@@ -95,17 +93,18 @@ struct UserKeyRange {
  UserKeyRange(const Slice& s, const Slice& l) : start(s), limit(l) {}
 };

-// A range of user keys used internally by RocksDB. Also see `RangeOpt` used by
+// A range of user keys used internally by RocksDB. Also see `RangePtr` used by
 // public APIs.
-struct UserKeyRangeOpt {
+struct UserKeyRangePtr {
  // In case of user_defined timestamp, if enabled, `start` and `limit` should
  // point to key with timestamp part.
  // An optional range start, if missing, indicating a start before all keys.
-  OptSlice start;
+  std::optional<Slice> start;
  // An optional range end, if missing, indicating an end after all keys.
-  OptSlice limit;
+  std::optional<Slice> limit;

-  UserKeyRangeOpt(const OptSlice& s, const OptSlice& l) : start(s), limit(l) {}
+  UserKeyRangePtr(const std::optional<Slice>& s, const std::optional<Slice>& l)
+      : start(s), limit(l) {}
 };

 // Checks whether a type is an inline value type
@@ -470,7 +469,6 @@ class InternalKey {

  Slice user_key() const { return ExtractUserKey(rep_); }
  size_t size() const { return rep_.size(); }
-  bool unset() const { return rep_.empty(); }

  void Set(const Slice& _user_key, SequenceNumber s, ValueType t) {
    SetFrom(ParsedInternalKey(_user_key, s, t));
@@ -275,6 +275,9 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
    return;
  }

+  ROCKS_LOG_INFO(db_options_.info_log,
+                 "ErrorHandler: Set regular background error\n");
+
  bool paranoid = db_options_.paranoid_checks;
  Status::Severity sev = Status::Severity::kFatalError;
  Status new_bg_err;
@@ -332,21 +335,12 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
    if (!s.ok() && (s.severity() > bg_error_.severity())) {
      bg_error_ = s;
    } else {
-      ROCKS_LOG_INFO(db_options_.info_log,
-                     "ErrorHandler: Hit less severe background error\n");
-
      // This error is less severe than previously encountered error. Don't
      // take any further action
      return;
    }
  }

-  bool stop = bg_error_.severity() >= Status::Severity::kHardError;
-  ROCKS_LOG_INFO(
-      db_options_.info_log,
-      "ErrorHandler: Set regular background error, auto_recovery=%d, stop=%d\n",
-      int{auto_recovery}, int{stop});
-
  recover_context_ = context;
  if (auto_recovery) {
    recovery_in_prog_ = true;
@@ -357,7 +351,7 @@ void ErrorHandler::HandleKnownErrors(const Status& bg_err,
      RecoverFromNoSpace();
    }
  }
-  if (stop) {
+  if (bg_error_.severity() >= Status::Severity::kHardError) {
    is_db_stopped_.store(true, std::memory_order_release);
  }
 }
@@ -77,12 +77,7 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
    TableFileCreationReason reason, const Status& s,
    const std::string& file_checksum,
    const std::string& file_checksum_func_name) {
-  if (!event_logger && listeners.empty()) {
-    s.PermitUncheckedError();
-    return;
-  }
-
-  if (event_logger) {
+  if (s.ok() && event_logger) {
    JSONWriter jwriter;
    AppendCurrentTime(&jwriter);
    jwriter << "cf_name" << cf_name << "job" << job_id << "event"
@@ -170,8 +165,6 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
      jwriter << "oldest_blob_file_number" << oldest_blob_file_number;
    }

-    jwriter << "status" << s.ToString();
-
    jwriter.EndObject();

    event_logger->Log(jwriter);
@@ -202,22 +195,18 @@ void EventHelpers::LogAndNotifyTableFileDeletion(
    const std::string& file_path, const Status& status,
    const std::string& dbname,
    const std::vector<std::shared_ptr<EventListener>>& listeners) {
-  if (!event_logger && listeners.empty()) {
-    status.PermitUncheckedError();
-    return;
+  JSONWriter jwriter;
+  AppendCurrentTime(&jwriter);
+
+  jwriter << "job" << job_id << "event" << "table_file_deletion"
+          << "file_number" << file_number;
+  if (!status.ok()) {
+    jwriter << "status" << status.ToString();
  }

-  if (event_logger) {
-    JSONWriter jwriter;
-    AppendCurrentTime(&jwriter);
+  jwriter.EndObject();

-    jwriter << "job" << job_id << "event" << "table_file_deletion"
-            << "file_number" << file_number << "status" << status.ToString();
-
-    jwriter.EndObject();
-
-    event_logger->Log(jwriter);
-  }
+  event_logger->Log(jwriter);

  if (listeners.empty()) {
    return;
@@ -285,12 +274,7 @@ void EventHelpers::LogAndNotifyBlobFileCreationFinished(
    const std::string& file_checksum,
    const std::string& file_checksum_func_name, uint64_t total_blob_count,
    uint64_t total_blob_bytes) {
-  if (!event_logger && listeners.empty()) {
-    s.PermitUncheckedError();
-    return;
-  }
-
-  if (event_logger) {
+  if (s.ok() && event_logger) {
    JSONWriter jwriter;
    AppendCurrentTime(&jwriter);
    jwriter << "cf_name" << cf_name << "job" << job_id << "event"
@@ -321,17 +305,15 @@ void EventHelpers::LogAndNotifyBlobFileDeletion(
    const std::vector<std::shared_ptr<EventListener>>& listeners, int job_id,
    uint64_t file_number, const std::string& file_path, const Status& status,
    const std::string& dbname) {
-  if (!event_logger && listeners.empty()) {
-    status.PermitUncheckedError();
-    return;
-  }
-
  if (event_logger) {
    JSONWriter jwriter;
    AppendCurrentTime(&jwriter);

    jwriter << "job" << job_id << "event" << "blob_file_deletion"
-            << "file_number" << file_number << "status" << status.ToString();
+            << "file_number" << file_number;
+    if (!status.ok()) {
+      jwriter << "status" << status.ToString();
+    }

    jwriter.EndObject();
    event_logger->Log(jwriter);
@@ -57,8 +57,7 @@ Status GetFileChecksumsFromCurrentManifest(FileSystem* fs,
  }
  assert(checksum_list);

-  const ReadOptions read_options(
-      Env::IOActivity::kGetFileChecksumsFromCurrentManifest);
+  const ReadOptions read_options(Env::IOActivity::kReadManifest);
  checksum_list->reset();

  std::unique_ptr<SequentialFileReader> file_reader;
@@ -16,7 +16,6 @@
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/defer.h"
-#include "util/file_checksum_helper.h"
 #include "util/random.h"
 #include "utilities/fault_injection_env.h"

@@ -261,6 +260,55 @@ TEST_F(ExternalSSTFileBasicTest, Basic) {
  s = sst_file_writer.DeleteRange(Key(100), Key(200));
  ASSERT_NOK(s) << s.ToString();

+  DestroyAndReopen(options);
+
+  SyncPoint::GetInstance()->LoadDependency({
+      {"DBImpl::IngestExternalFile:AfterIncIngestFileCounter",
+       "ExternalSSTFileBasicTest.LiveWriteStart"},
+      {"WriteThread::JoinBatchGroup:Wait",
+       "DBImpl::IngestExternalFile:AfterIncIngestFileCounter:2"},
+  });
+  SyncPoint::GetInstance()->EnableProcessing();
+  PerfContext* write_thread_perf_context;
+  std::thread write_thread([&] {
+    TEST_SYNC_POINT("ExternalSSTFileBasicTest.LiveWriteStart");
+    SetPerfLevel(kEnableWait);
+    write_thread_perf_context = get_perf_context();
+    write_thread_perf_context->Reset();
+    ASSERT_OK(db_->Put(WriteOptions(), "bar", "v2"));
+    ASSERT_GT(write_thread_perf_context->write_thread_wait_nanos, 0);
+    // Test sync points were used to make sure this live write enter write
+    // thread after the file ingestion entered write thread. So by the time this
+    // live write finishes, the latest seqno is 1 means file ingestion used
+    // seqno 0.
+    ASSERT_EQ(db_->GetLatestSequenceNumber(), 1U);
+  });
+
+  // Add file using file path
+  SetPerfLevel(kEnableTimeExceptForMutex);
+  PerfContext* perf_ctx = get_perf_context();
+  perf_ctx->Reset();
+  s = DeprecatedAddFile({file1});
+  ASSERT_GT(perf_context.file_ingestion_nanos, 0);
+  ASSERT_GT(perf_context.file_ingestion_blocking_live_writes_nanos, 0);
+  ASSERT_OK(s) << s.ToString();
+  for (int k = 0; k < 100; k++) {
+    ASSERT_EQ(Get(Key(k)), Key(k) + "_val");
+  }
+
+  write_thread.join();
+  SyncPoint::GetInstance()->DisableProcessing();
+
+  // Re-ingest the file just to check the perf context not enabled at and below
+  // kEnableWait.
+  SetPerfLevel(kEnableWait);
+  perf_ctx->Reset();
+  IngestExternalFileOptions opts;
+  opts.allow_global_seqno = true;
+  opts.allow_blocking_flush = true;
+  ASSERT_OK(db_->IngestExternalFile({file1}, opts));
+  ASSERT_EQ(perf_context.file_ingestion_nanos, 0);
+  ASSERT_EQ(perf_context.file_ingestion_blocking_live_writes_nanos, 0);
  DestroyAndRecreateExternalSSTFilesDir();
 }

@@ -347,8 +395,7 @@ class ChecksumVerifyHelper {

  Status GetSingleFileChecksumAndFuncName(
      const std::string& file_path, std::string* file_checksum,
-      std::string* file_checksum_func_name,
-      const std::string& requested_func_name = {}) {
+      std::string* file_checksum_func_name) {
    Status s;
    EnvOptions soptions;
    std::unique_ptr<SequentialFile> file_reader;
@@ -366,8 +413,6 @@ class ChecksumVerifyHelper {
      return Status::OK();
    } else {
      FileChecksumGenContext gen_context;
-      gen_context.file_name = file_path;
-      gen_context.requested_checksum_func_name = requested_func_name;
      std::unique_ptr<FileChecksumGenerator> file_checksum_gen =
          file_checksum_gen_factory->CreateFileChecksumGenerator(gen_context);
      *file_checksum_func_name = file_checksum_gen->Name();
@@ -443,50 +488,10 @@ TEST_F(ExternalSSTFileBasicTest, BasicWithFileChecksumCrc32c) {
  DestroyAndRecreateExternalSSTFilesDir();
 }

-namespace {
-class VariousFileChecksumGenerator : public FileChecksumGenCrc32c {
- public:
-  explicit VariousFileChecksumGenerator(const std::string& name)
-      : FileChecksumGenCrc32c({}), name_(name) {}
-
-  const char* Name() const override { return name_.c_str(); }
-
-  std::string GetChecksum() const override {
-    return FileChecksumGenCrc32c::GetChecksum() + "_" + name_;
-  }
-
- private:
-  const std::string name_;
-};
-
-class VariousFileChecksumGenFactory : public FileChecksumGenFactory {
- public:
-  std::unique_ptr<FileChecksumGenerator> CreateFileChecksumGenerator(
-      const FileChecksumGenContext& context) override {
-    static RelaxedAtomic<int> counter{0};
-    if (Slice(context.requested_checksum_func_name).starts_with("Various")) {
-      return std::make_unique<VariousFileChecksumGenerator>(
-          context.requested_checksum_func_name);
-    } else if (context.requested_checksum_func_name.empty()) {
-      // Lacking a specific request, use a different function name for each
-      // result.
-      return std::make_unique<VariousFileChecksumGenerator>(
-          "Various" + std::to_string(counter.FetchAddRelaxed(1)));
-    } else {
-      return nullptr;
-    }
-  }
-
-  static const char* kClassName() { return "VariousFileChecksumGenFactory"; }
-  const char* Name() const override { return kClassName(); }
-};
-}  // namespace
-
 TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  Options old_options = CurrentOptions();
  Options options = CurrentOptions();
-  options.file_checksum_gen_factory =
-      std::make_shared<VariousFileChecksumGenFactory>();
+  options.file_checksum_gen_factory = GetFileChecksumGenCrc32cFactory();
  const ImmutableCFOptions ioptions(options);
  ChecksumVerifyHelper checksum_helper(options);

@@ -507,8 +512,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file1_info.largest_key, Key(1099));
  std::string file_checksum1, file_checksum_func_name1;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file1, &file_checksum1, &file_checksum_func_name1,
-      file1_info.file_checksum_func_name));
+      file1, &file_checksum1, &file_checksum_func_name1));
  ASSERT_EQ(file1_info.file_checksum, file_checksum1);
  ASSERT_EQ(file1_info.file_checksum_func_name, file_checksum_func_name1);

@@ -527,8 +531,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file2_info.largest_key, Key(1299));
  std::string file_checksum2, file_checksum_func_name2;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file2, &file_checksum2, &file_checksum_func_name2,
-      file2_info.file_checksum_func_name));
+      file2, &file_checksum2, &file_checksum_func_name2));
  ASSERT_EQ(file2_info.file_checksum, file_checksum2);
  ASSERT_EQ(file2_info.file_checksum_func_name, file_checksum_func_name2);

@@ -547,8 +550,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file3_info.largest_key, Key(1499));
  std::string file_checksum3, file_checksum_func_name3;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file3, &file_checksum3, &file_checksum_func_name3,
-      file3_info.file_checksum_func_name));
+      file3, &file_checksum3, &file_checksum_func_name3));
  ASSERT_EQ(file3_info.file_checksum, file_checksum3);
  ASSERT_EQ(file3_info.file_checksum_func_name, file_checksum_func_name3);

@@ -567,8 +569,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file4_info.largest_key, Key(1799));
  std::string file_checksum4, file_checksum_func_name4;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file4, &file_checksum4, &file_checksum_func_name4,
-      file4_info.file_checksum_func_name));
+      file4, &file_checksum4, &file_checksum_func_name4));
  ASSERT_EQ(file4_info.file_checksum, file_checksum4);
  ASSERT_EQ(file4_info.file_checksum_func_name, file_checksum_func_name4);

@@ -587,8 +588,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file5_info.largest_key, Key(1999));
  std::string file_checksum5, file_checksum_func_name5;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file5, &file_checksum5, &file_checksum_func_name5,
-      file5_info.file_checksum_func_name));
+      file5, &file_checksum5, &file_checksum_func_name5));
  ASSERT_EQ(file5_info.file_checksum, file_checksum5);
  ASSERT_EQ(file5_info.file_checksum_func_name, file_checksum_func_name5);

@@ -607,8 +607,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_EQ(file6_info.largest_key, Key(2199));
  std::string file_checksum6, file_checksum_func_name6;
  ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-      file6, &file_checksum6, &file_checksum_func_name6,
-      file6_info.file_checksum_func_name));
+      file6, &file_checksum6, &file_checksum_func_name6));
  ASSERT_EQ(file6_info.file_checksum, file_checksum6);
  ASSERT_EQ(file6_info.file_checksum_func_name, file_checksum_func_name6);

@@ -678,23 +677,18 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  }
  ASSERT_OK(env_->FileExists(file2));

-  // Enable verify_file_checksum option. No checksum information is provided,
-  // so it is generated when ingesting. The configured checksum factory will
-  // use a different function than before.
-  s = AddFileWithFileChecksum({file3}, {}, {}, true, false, false, false);
+  // Enable verify_file_checksum option
+  // No checksum information is provided, generate it when ingesting
+  std::vector<std::string> checksum, checksum_func;
+  s = AddFileWithFileChecksum({file3}, checksum, checksum_func, true, false,
+                              false, false);
  ASSERT_OK(s) << s.ToString();
  std::vector<LiveFileMetaData> live_files2;
  dbfull()->GetLiveFilesMetaData(&live_files2);
  for (const auto& f : live_files2) {
    if (set1.find(f.name) == set1.end()) {
-      // Recomputed checksum, different function
-      EXPECT_NE(f.file_checksum_func_name, file_checksum_func_name3);
-      std::string cur_checksum3, cur_checksum_func_name3;
-      ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-          dbname_ + f.name, &cur_checksum3, &cur_checksum_func_name3,
-          f.file_checksum_func_name));
-      EXPECT_EQ(f.file_checksum, cur_checksum3);
-      EXPECT_EQ(f.file_checksum_func_name, cur_checksum_func_name3);
+      ASSERT_EQ(f.file_checksum, file_checksum3);
+      ASSERT_EQ(f.file_checksum_func_name, file_checksum_func_name3);
      set1.insert(f.name);
    }
  }
@@ -708,9 +702,8 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_NOK(s) << s.ToString();

  // Does not enable verify_file_checksum options
-  // Checksum function name is recognized, so store the checksum being ingested.
-  std::string file_checksum_func_name4alt = "VariousABCD";
-  s = AddFileWithFileChecksum({file4}, {"asd"}, {file_checksum_func_name4alt},
+  // Checksum function name matches, store the checksum being ingested.
+  s = AddFileWithFileChecksum({file4}, {"asd"}, {file_checksum_func_name4},
                              false, false, false, false);
  ASSERT_OK(s) << s.ToString();
  std::vector<LiveFileMetaData> live_files3;
@@ -719,7 +712,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
    if (set1.find(f.name) == set1.end()) {
      ASSERT_FALSE(f.file_checksum == file_checksum4);
      ASSERT_EQ(f.file_checksum, "asd");
-      ASSERT_EQ(f.file_checksum_func_name, file_checksum_func_name4alt);
+      ASSERT_EQ(f.file_checksum_func_name, file_checksum_func_name4);
      set1.insert(f.name);
    }
  }
@@ -728,8 +721,7 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {

  // enable verify_file_checksum options, DB enable checksum, and enable
  // write_global_seq. So the checksum stored is different from the one
-  // ingested due to the sequence number changes. The checksum function name
-  // may also change since the checksum is recomputed.
+  // ingested due to the sequence number changes.
  s = AddFileWithFileChecksum({file5}, {file_checksum5},
                              {file_checksum_func_name5}, true, false, false,
                              true);
@@ -738,14 +730,11 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  dbfull()->GetLiveFilesMetaData(&live_files4);
  for (const auto& f : live_files4) {
    if (set1.find(f.name) == set1.end()) {
-      // Recomputed checksum, different function
-      EXPECT_NE(f.file_checksum_func_name, file_checksum_func_name5);
      std::string cur_checksum5, cur_checksum_func_name5;
      ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-          dbname_ + f.name, &cur_checksum5, &cur_checksum_func_name5,
-          f.file_checksum_func_name));
-      EXPECT_EQ(f.file_checksum, cur_checksum5);
-      EXPECT_EQ(f.file_checksum_func_name, cur_checksum_func_name5);
+          dbname_ + f.name, &cur_checksum5, &cur_checksum_func_name5));
+      ASSERT_EQ(f.file_checksum, cur_checksum5);
+      ASSERT_EQ(f.file_checksum_func_name, file_checksum_func_name5);
      set1.insert(f.name);
    }
  }
@@ -753,22 +742,18 @@ TEST_F(ExternalSSTFileBasicTest, IngestFileWithFileChecksum) {
  ASSERT_OK(env_->FileExists(file5));

  // Does not enable verify_file_checksum options and also the ingested file
-  // checksum information is empty. DB will generate and store file checksum
-  // in Manifest, which could be different from the previous invocation.
-  s = AddFileWithFileChecksum({file6}, {}, {}, false, false, false, false);
+  // checksum information is empty. DB will generate and store the checksum
+  // in Manifest.
+  std::vector<std::string> files_c6, files_name6;
+  s = AddFileWithFileChecksum({file6}, files_c6, files_name6, false, false,
+                              false, false);
  ASSERT_OK(s) << s.ToString();
  std::vector<LiveFileMetaData> live_files6;
  dbfull()->GetLiveFilesMetaData(&live_files6);
  for (const auto& f : live_files6) {
    if (set1.find(f.name) == set1.end()) {
-      // Recomputed checksum, different function
-      EXPECT_NE(f.file_checksum_func_name, file_checksum_func_name6);
-      std::string cur_checksum6, cur_checksum_func_name6;
-      ASSERT_OK(checksum_helper.GetSingleFileChecksumAndFuncName(
-          dbname_ + f.name, &cur_checksum6, &cur_checksum_func_name6,
-          f.file_checksum_func_name));
-      EXPECT_EQ(f.file_checksum, cur_checksum6);
-      EXPECT_EQ(f.file_checksum_func_name, cur_checksum_func_name6);
+      ASSERT_EQ(f.file_checksum, file_checksum6);
+      ASSERT_EQ(f.file_checksum_func_name, file_checksum_func_name6);
      set1.insert(f.name);
    }
  }
@@ -1969,44 +1954,21 @@ TEST_F(ExternalSSTFileBasicTest, OverlappingFiles) {
    SstFileWriter sst_file_writer(EnvOptions(), options);
    std::string file3 = sst_files_dir_ + "file3.sst";
    ASSERT_OK(sst_file_writer.Open(file3));
-    ASSERT_OK(sst_file_writer.Put("k", "k1"));
+    ASSERT_OK(sst_file_writer.Put("j", "j1"));
    ASSERT_OK(sst_file_writer.Put("m", "m1"));
    ExternalSstFileInfo file3_info;
    ASSERT_OK(sst_file_writer.Finish(&file3_info));
    files.push_back(std::move(file3));
  }

-  // This could be ingested to the same level as file3 and file4, but the
-  // greedy/simple overlap check relegates it to a later level
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file4 = sst_files_dir_ + "file4.sst";
-    ASSERT_OK(sst_file_writer.Open(file4));
-    ASSERT_OK(sst_file_writer.Put("j", "j1"));
-    ExternalSstFileInfo file4_info;
-    ASSERT_OK(sst_file_writer.Finish(&file4_info));
-    files.push_back(std::move(file4));
-  }
-
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), options);
-    std::string file5 = sst_files_dir_ + "file5.sst";
-    ASSERT_OK(sst_file_writer.Open(file5));
-    ASSERT_OK(sst_file_writer.Put("i", "i3"));
-    ExternalSstFileInfo file5_info;
-    ASSERT_OK(sst_file_writer.Finish(&file5_info));
-    files.push_back(std::move(file5));
-  }
-
  IngestExternalFileOptions ifo;
  ifo.allow_global_seqno = false;
  ASSERT_NOK(db_->IngestExternalFile(files, ifo));
  ifo.allow_global_seqno = true;
  ASSERT_OK(db_->IngestExternalFile(files, ifo));
  ASSERT_EQ(Get("a"), "a1");
-  ASSERT_EQ(Get("i"), "i3");
+  ASSERT_EQ(Get("i"), "i2");
  ASSERT_EQ(Get("j"), "j1");
-  ASSERT_EQ(Get("k"), "k1");
  ASSERT_EQ(Get("m"), "m1");

  int total_keys = 0;
@@ -2017,11 +1979,10 @@ TEST_F(ExternalSSTFileBasicTest, OverlappingFiles) {
  }
  ASSERT_OK(iter->status());
  delete iter;
-  ASSERT_EQ(total_keys, 5);
+  ASSERT_EQ(total_keys, 4);

  ASSERT_EQ(1, NumTableFilesAtLevel(6));
  ASSERT_EQ(2, NumTableFilesAtLevel(5));
-  ASSERT_EQ(2, NumTableFilesAtLevel(4));
 }

 class CompactionJobStatsCheckerForFilteredFiles : public EventListener {
@@ -2708,81 +2669,6 @@ TEST_F(ExternalSSTFileBasicTest, IngestWithTemperature) {
  }
 }

-// This tests an internal user's exact usage and expectation of the
-// IngestExternalFiles APIs to bulk load and replace files.
-TEST_F(ExternalSSTFileBasicTest,
-       AtomicReplaceColumnFamilyWithIngestedVersionKey) {
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.compaction_style = CompactionStyle::kCompactionStyleUniversal;
-  options.num_levels = 7;
-  options.disallow_memtable_writes = false;
-
-  DestroyAndReopen(options);
-  SstFileWriter sst_file_writer(EnvOptions(), options);
-  std::string data_file_original = sst_files_dir_ + "data_original";
-  ASSERT_OK(sst_file_writer.Open(data_file_original));
-  ASSERT_OK(sst_file_writer.Put("ukey1", "uval1_orig"));
-  ASSERT_OK(sst_file_writer.Put("ukey2", "uval2_orig"));
-  ASSERT_OK(sst_file_writer.Finish());
-  ASSERT_OK(db_->IngestExternalFile(db_->DefaultColumnFamily(),
-                                    {data_file_original},
-                                    IngestExternalFileOptions()));
-
-  ASSERT_OK(Put("data_version", "v_original"));
-  ASSERT_OK(Flush());
-  std::string value;
-  ASSERT_OK(db_->Get(ReadOptions(), "data_version", &value));
-  ASSERT_EQ(value, "v_original");
-  ASSERT_OK(db_->Get(ReadOptions(), "ukey1", &value));
-  ASSERT_EQ(value, "uval1_orig");
-  ASSERT_OK(db_->Get(ReadOptions(), "ukey2", &value));
-  ASSERT_EQ(value, "uval2_orig");
-  // Set up a 1) data version key file on L0, and 2) a user data file on L6
-  // to test the initial transitioning to use `atomic_replace_range`.
-  ASSERT_EQ("1,0,0,0,0,0,1", FilesPerLevel());
-
-  // Test multiple cycles of replacing by atomically ingest a data file and a
-  // version key file while replace the whole range in the column family.
-  for (int i = 0; i < 10; i++) {
-    std::string version_file_path =
-        sst_files_dir_ + "version" + std::to_string(i);
-    ASSERT_OK(sst_file_writer.Open(version_file_path));
-    ASSERT_OK(sst_file_writer.Put("data_version", "v" + std::to_string(i)));
-    ASSERT_OK(sst_file_writer.Finish());
-
-    std::string file_path = sst_files_dir_ + std::to_string(i);
-    ASSERT_OK(sst_file_writer.Open(file_path));
-    ASSERT_OK(sst_file_writer.Put("ukey1", "uval1" + std::to_string(i)));
-    ASSERT_OK(sst_file_writer.Put("ukey2", "uval2" + std::to_string(i)));
-    ASSERT_OK(sst_file_writer.Finish());
-
-    IngestExternalFileArg arg;
-    arg.column_family = db_->DefaultColumnFamily();
-    arg.external_files = {version_file_path, file_path};
-    arg.atomic_replace_range = {{nullptr, nullptr}};
-    // Test both fail_if_not_bottomost_level: true and false
-    arg.options.fail_if_not_bottommost_level = i % 2 == 0;
-    arg.options.snapshot_consistency = false;
-    // Ingest 1) a new data version file and 2) a new user data file while erase
-    // the whole column family
-    Status s = db_->IngestExternalFiles({arg});
-    ASSERT_OK(s);
-
-    // Check ingestion result and the expected LSM shape:
-    // Two files on L6, 1) a data version file 2) a user data file.
-    ASSERT_OK(db_->Get(ReadOptions(), "ukey1", &value));
-    ASSERT_EQ(value, "uval1" + std::to_string(i));
-    ASSERT_OK(db_->Get(ReadOptions(), "ukey2", &value));
-    ASSERT_EQ(value, "uval2" + std::to_string(i));
-    ASSERT_OK(db_->Get(ReadOptions(), "data_version", &value));
-    ASSERT_EQ(value, "v" + std::to_string(i));
-    ASSERT_EQ("0,0,0,0,0,0,2", FilesPerLevel());
-  }
-
-  Close();
-}
-
 TEST_F(ExternalSSTFileBasicTest, FailIfNotBottommostLevelAndDisallowMemtable) {
  for (bool disallow_memtable : {false, true}) {
    Options options = GetDefaultOptions();
@@ -2800,11 +2686,10 @@ TEST_F(ExternalSSTFileBasicTest, FailIfNotBottommostLevelAndDisallowMemtable) {

    // Ingest with snapshot consistency
    std::string file_path = sst_files_dir_ + std::to_string(1);
-    std::string file_path2 = sst_files_dir_ + std::to_string(2);
    SstFileWriter sfw(EnvOptions(), options);

    ASSERT_OK(sfw.Open(file_path));
-    ASSERT_OK(sfw.Put("b", "0"));
+    ASSERT_OK(sfw.Put("b", "dontcare"));
    ASSERT_OK(sfw.Finish());

    {
@@ -2815,7 +2700,6 @@ TEST_F(ExternalSSTFileBasicTest, FailIfNotBottommostLevelAndDisallowMemtable) {
      ifo.snapshot_consistency = true;
      ASSERT_OK(db_->IngestExternalFile(handles_[0], {file_path}, ifo));
    }
-    ASSERT_EQ(Get(0, "b"), "0");

    // Test level compaction
    options.compaction_style = CompactionStyle::kCompactionStyleLevel;
@@ -2837,6 +2721,8 @@ TEST_F(ExternalSSTFileBasicTest, FailIfNotBottommostLevelAndDisallowMemtable) {
      EXPECT_EQ(Put(1, "a", "1").code(), Status::Code::kInvalidArgument);

      // Use ingestion to get to the same state as above
+      std::string file_path2 = sst_files_dir_ + std::to_string(2);
+
      ASSERT_OK(sfw.Open(file_path2));
      ASSERT_OK(sfw.Put("a", "1"));
      ASSERT_OK(sfw.Put("c", "3"));
@@ -2849,216 +2735,16 @@ TEST_F(ExternalSSTFileBasicTest, FailIfNotBottommostLevelAndDisallowMemtable) {
      ASSERT_OK(sfw.Finish());
      ASSERT_OK(db_->IngestExternalFile(handles_[1], {file_path2}, {}));
    }
-    ASSERT_EQ(Get(1, "a"), "1");
-    ASSERT_EQ(Get(1, "b"), "2");
-    ASSERT_EQ(Get(1, "c"), "3");
-    ASSERT_EQ(Get(1, "d"), "4");

    {
-      // Test fail_if_not_bottommost_level, which fails if there's any overlap
-      // anywhere, even with snapshot_consistency=false
-      IngestExternalFileOptions ifo;
-      ASSERT_FALSE(ifo.fail_if_not_bottommost_level);
-      ifo.fail_if_not_bottommost_level = true;
-      ifo.snapshot_consistency = false;
-      // Fails with overlap on earlier level
-      Status s = db_->IngestExternalFile(handles_[1], {file_path}, ifo);
-      ASSERT_EQ(s.code(), Status::Code::kTryAgain);
-
      CompactRangeOptions cro;
      cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
      ASSERT_OK(db_->CompactRange(cro, handles_[1], nullptr, nullptr));

-      // Fails with overlap on last level
-      s = db_->IngestExternalFile(handles_[1], {file_path}, ifo);
-      ASSERT_EQ(s.code(), Status::Code::kTryAgain);
-
-      // No change to data
-      ASSERT_EQ(Get(1, "a"), "1");
-      ASSERT_EQ(Get(1, "b"), "2");
-      ASSERT_EQ(Get(1, "c"), "3");
-      ASSERT_EQ(Get(1, "d"), "4");
-    }
-
-    if (!disallow_memtable) {
-      // Test allow_blocking_flush=false (fail because of memtable overlap)
      IngestExternalFileOptions ifo;
-      ASSERT_TRUE(ifo.allow_blocking_flush);
-      ifo.allow_blocking_flush = false;
-      ASSERT_OK(Put(1, "b", "42"));
-      Status s = db_->IngestExternalFile(handles_[1], {file_path}, ifo);
-      ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-      ASSERT_EQ(Get(1, "a"), "1");
-      ASSERT_EQ(Get(1, "b"), "42");
-      ASSERT_EQ(Get(1, "c"), "3");
-      ASSERT_EQ(Get(1, "d"), "4");
-
-      // Revert state
-      ASSERT_OK(Put(1, "b", "2"));
-      ASSERT_OK(Flush(1));
-    }
-
-    {
-      // Test atomic_replace_range
-      IngestExternalFileArg arg;
-      arg.column_family = handles_[1];
-      arg.external_files = {file_path};
-      arg.atomic_replace_range = {{"a", "zzz"}};
-
-      // start with some failure cases
-      // TODO: support snapshot consistency with tombstone file
-      ASSERT_TRUE(arg.options.snapshot_consistency);
-      Status s = db_->IngestExternalFiles({arg});
-      ASSERT_EQ(s.code(), Status::Code::kNotSupported);
-
-      ASSERT_EQ(Get(1, "a"), "1");
-      ASSERT_EQ(Get(1, "b"), "2");
-      ASSERT_EQ(Get(1, "c"), "3");
-      ASSERT_EQ(Get(1, "d"), "4");
-
-      arg.options.snapshot_consistency = false;
-      // Can usually be used with atomic_replace_range and
-      // snapshot_consistency=false, except it requires no input overlap
-      arg.options.fail_if_not_bottommost_level = true;
-
-      // one-sided ranges not yet supported
-      arg.atomic_replace_range = {{{}, "zzz"}};
-      s = db_->IngestExternalFiles({arg});
-      ASSERT_EQ(s.code(), Status::Code::kNotSupported);
-
-      arg.atomic_replace_range = {{"a", {}}};
-      s = db_->IngestExternalFiles({arg});
-      ASSERT_EQ(s.code(), Status::Code::kNotSupported);
-
-      // rejected because doesn't cover ingested file
-      arg.atomic_replace_range = {{"x", "z"}};
-      s = db_->IngestExternalFiles({arg});
-      ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-      // rejected because of partial file overlap
-      arg.atomic_replace_range = {{"a", "c"}};
-      s = db_->IngestExternalFiles({arg});
-      ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-      if (!disallow_memtable) {
-        // memtable overlap with replace range
-        ASSERT_OK(Put(1, "e", "5"));
-        arg.options.allow_blocking_flush = false;
-
-        // rejected because of memtable overlap
-        arg.atomic_replace_range = {{"a", "z"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // rejected because of memtable overlap
-        arg.atomic_replace_range = {{nullptr, nullptr}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // FIXME: upper bound should be exclusive (DeleteRange semantics).
-        // currently rejected because of documented bug
-        arg.atomic_replace_range = {{"a", "e"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // work-around ensuring no memtable overlap
-        arg.atomic_replace_range = {{"a", "d2"}};
-        ASSERT_OK(db_->IngestExternalFiles({arg}));
-
-        ASSERT_EQ(Get(1, "e"), "5");
-      } else {
-        // rejected because of partial file overlap
-        arg.atomic_replace_range = {{"b", "z"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // no memtable complications
-        arg.atomic_replace_range = {{"a", "z"}};
-        ASSERT_OK(db_->IngestExternalFiles({arg}));
-
-        ASSERT_EQ(Get(1, "e"), "NOT_FOUND");
-      }
-      ASSERT_EQ(Get(1, "a"), "NOT_FOUND");
-      ASSERT_EQ(Get(1, "b"), "0");
-      ASSERT_EQ(Get(1, "c"), "NOT_FOUND");
-      ASSERT_EQ(Get(1, "d"), "NOT_FOUND");
-
-      // The single ingested file replaced everything (except perhaps memtable)
-      std::vector<LiveFileMetaData> live_files;
-      db_->GetLiveFilesMetaData(&live_files);
-      // One file in each CF
-      ASSERT_EQ(live_files.size(), 2);
-
-      ASSERT_OK(sfw.Open(file_path));
-      ASSERT_OK(sfw.Put("f", "6"));
-      ASSERT_OK(sfw.Finish());
-
-      // Another file
-      ASSERT_OK(sfw.Open(file_path2));
-      ASSERT_OK(sfw.Put("f", "7"));
-      ASSERT_OK(sfw.Put("g", "8"));
-      ASSERT_OK(sfw.Finish());
-
-      if (!disallow_memtable) {
-        // rejected because of memtable overlap with range
-        arg.atomic_replace_range = {{"e", "z"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // allow blocking flush of "e" (which is then replaced), and the file
-        // with just "b" is not replaced
-        arg.options.allow_blocking_flush = true;
-        ASSERT_OK(db_->IngestExternalFiles({arg}));
-
-        ASSERT_EQ(Get(1, "b"), "0");
-        ASSERT_EQ(Get(1, "e"), "NOT_FOUND");
-        ASSERT_EQ(Get(1, "f"), "6");
-        ASSERT_EQ(Get(1, "g"), "NOT_FOUND");
-
-        // memtable overlap with replace range
-        ASSERT_OK(Put(1, "e", "5"));
-        arg.options.allow_blocking_flush = false;
-        arg.external_files = {file_path2};
-
-        // rejected because of memtable overlap
-        arg.atomic_replace_range = {{nullptr, nullptr}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // Replace everything, including with memtable flush
-        arg.options.allow_blocking_flush = true;
-        ASSERT_OK(db_->IngestExternalFiles({arg}));
-
-        ASSERT_EQ(Get(1, "b"), "NOT_FOUND");
-        ASSERT_EQ(Get(1, "e"), "NOT_FOUND");
-        ASSERT_EQ(Get(1, "f"), "7");
-        ASSERT_EQ(Get(1, "g"), "8");
-      } else {
-        arg.external_files = {file_path2, file_path};
-
-        // rejected because of overlap in files to ingest with fail_if_ = true
-        arg.atomic_replace_range = {{"e", "z"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kTryAgain);
-
-        arg.options.fail_if_not_bottommost_level = false;
-
-        // rejected because range doesn't cover ingested files
-        // FIXME: upper bound should be exclusive "g" instead
-        arg.atomic_replace_range = {{"e", "f2"}};
-        s = db_->IngestExternalFiles({arg});
-        ASSERT_EQ(s.code(), Status::Code::kInvalidArgument);
-
-        // Loaded into different levels, and the file with just "b" is not
-        // replaced
-        arg.atomic_replace_range = {{"e", "z"}};
-        ASSERT_OK(db_->IngestExternalFiles({arg}));
-
-        ASSERT_EQ(Get(1, "b"), "0");
-        ASSERT_EQ(Get(1, "f"), "6");  // earlier file listed later to ingest
-        ASSERT_EQ(Get(1, "g"), "8");
-      }
+      ifo.fail_if_not_bottommost_level = true;
+      const Status s = db_->IngestExternalFile(handles_[1], {file_path}, ifo);
+      ASSERT_TRUE(s.IsTryAgain());
    }
  }
 }
@@ -29,7 +29,6 @@ Status ExternalSstFileIngestionJob::Prepare(
    const std::vector<std::string>& external_files_paths,
    const std::vector<std::string>& files_checksums,
    const std::vector<std::string>& files_checksum_func_names,
-    const std::optional<RangeOpt>& atomic_replace_range,
    const Temperature& file_temperature, uint64_t next_file_number,
    SuperVersion* sv) {
  Status status;
@@ -81,47 +80,15 @@ Status ExternalSstFileIngestionJob::Prepare(
    std::sort(sorted_files.begin(), sorted_files.end(), file_range_checker_);

    for (size_t i = 0; i + 1 < num_files; i++) {
-      if (file_range_checker_.Overlaps(*sorted_files[i], *sorted_files[i + 1],
-                                       /* known_sorted= */ true)) {
+      if (file_range_checker_.OverlapsWithPrev(sorted_files[i],
+                                               sorted_files[i + 1],
+                                               /* ranges_sorted= */ true)) {
        files_overlap_ = true;
        break;
      }
    }
  }

-  if (atomic_replace_range.has_value()) {
-    atomic_replace_range_.emplace();
-
-    if (atomic_replace_range->start && atomic_replace_range->limit) {
-      // User keys to internal keys (with timestamps)
-      const size_t ts_sz = ucmp_->timestamp_size();
-      std::string start_with_ts, limit_with_ts;
-      auto [start, limit] = MaybeAddTimestampsToRange(
-          atomic_replace_range->start, atomic_replace_range->limit, ts_sz,
-          &start_with_ts, &limit_with_ts);
-      assert(start.has_value());
-      assert(limit.has_value());
-      atomic_replace_range_->smallest_internal_key.Set(
-          *start, kMaxSequenceNumber, kValueTypeForSeek);
-      atomic_replace_range_->largest_internal_key.Set(
-          *limit, kMaxSequenceNumber, kValueTypeForSeek);
-      // Check files to ingest against replace range
-      for (size_t i = 0; i < num_files; i++) {
-        if (!file_range_checker_.Contains(*atomic_replace_range_,
-                                          files_to_ingest_[i])) {
-          return Status::InvalidArgument(
-              "Atomic replace range does not contain all files");
-        }
-      }
-    } else {
-      // Currently if either bound is not present, both must be
-      assert(atomic_replace_range->start.has_value() == false);
-      assert(atomic_replace_range->limit.has_value() == false);
-      assert(atomic_replace_range_->smallest_internal_key.unset());
-      assert(atomic_replace_range_->largest_internal_key.unset());
-    }
-  }
-
  if (ingestion_options_.ingest_behind && files_overlap_) {
    return Status::NotSupported(
        "Files with overlapping ranges cannot be ingested with ingestion "
@@ -156,14 +123,6 @@ Status ExternalSstFileIngestionJob::Prepare(
        // It is unsafe to assume application had sync the file and file
        // directory before ingest the file. For integrity of RocksDB we need
        // to sync the file.
-
-        // TODO(xingbo), We should in general be moving away from production
-        // uses of ReuseWritableFile (except explicitly for WAL recycling),
-        // ReopenWritableFile, and NewRandomRWFile. We should create a
-        // FileSystem::SyncFile/FsyncFile API that by default does the
-        // re-open+sync+close combo but can (a) be reused easily, and (b) be
-        // overridden to do that more cleanly, e.g. in EncryptedEnv.
-        // https://github.com/facebook/rocksdb/issues/13741
        std::unique_ptr<FSWritableFile> file_to_sync;
        Status s = fs_->ReopenWritableFile(path_inside_db, env_options_,
                                           &file_to_sync, nullptr);
@@ -268,6 +227,10 @@ Status ExternalSstFileIngestionJob::Prepare(
    } else {
      need_generate_file_checksum_ = true;
    }
+    FileChecksumGenContext gen_context;
+    std::unique_ptr<FileChecksumGenerator> file_checksum_gen =
+        db_options_.file_checksum_gen_factory->CreateFileChecksumGenerator(
+            gen_context);
    std::vector<std::string> generated_checksums;
    std::vector<std::string> generated_checksum_func_names;
    // Step 1: generate the checksum for ingested sst file.
@@ -275,9 +238,7 @@ Status ExternalSstFileIngestionJob::Prepare(
      for (size_t i = 0; i < files_to_ingest_.size(); i++) {
        std::string generated_checksum;
        std::string generated_checksum_func_name;
-        std::string requested_checksum_func_name =
-            i < files_checksum_func_names.size() ? files_checksum_func_names[i]
-                                                 : "";
+        std::string requested_checksum_func_name;
        // TODO: rate limit file reads for checksum calculation during file
        // ingestion.
        // TODO: plumb Env::IOActivity
@@ -320,50 +281,40 @@ Status ExternalSstFileIngestionJob::Prepare(
            if (files_checksum_func_names[i] !=
                generated_checksum_func_names[i]) {
              status = Status::InvalidArgument(
-                  "DB file checksum gen factory " +
-                  std::string(db_options_.file_checksum_gen_factory->Name()) +
-                  " generated checksum function name " +
-                  generated_checksum_func_names[i] + " for file " +
-                  external_files_paths[i] +
-                  " which does not match requested/provided " +
-                  files_checksum_func_names[i]);
+                  "Checksum function name does not match with the checksum "
+                  "function name of this DB");
+              ROCKS_LOG_WARN(
+                  db_options_.info_log,
+                  "Sst file checksum verification of file: %s failed: %s",
+                  external_files_paths[i].c_str(), status.ToString().c_str());
              break;
            }
            if (files_checksums[i] != generated_checksums[i]) {
              status = Status::Corruption(
-                  "Checksum verification mismatch for ingestion file " +
-                  external_files_paths[i] + " using function " +
-                  generated_checksum_func_names[i] + ". Expected: " +
-                  Slice(files_checksums[i]).ToString(/*hex=*/true) +
-                  " Computed: " +
-                  Slice(generated_checksums[i]).ToString(/*hex=*/true));
+                  "Ingested checksum does not match with the generated "
+                  "checksum");
+              ROCKS_LOG_WARN(
+                  db_options_.info_log,
+                  "Sst file checksum verification of file: %s failed: %s",
+                  files_to_ingest_[i].internal_file_path.c_str(),
+                  status.ToString().c_str());
              break;
            }
          }
        } else {
-          // If verify_file_checksum is not enabled, we only verify the factory
-          // recognizes the checksum function name. If it does not match, fail
-          // the ingestion. If matches, we trust the ingested checksum
-          // information and store in the Manifest.
+          // If verify_file_checksum is not enabled, we only verify the
+          // checksum function name. If it does not match, fail the ingestion.
+          // If matches, we trust the ingested checksum information and store
+          // in the Manifest.
          for (size_t i = 0; i < files_to_ingest_.size(); i++) {
-            FileChecksumGenContext gen_context;
-            gen_context.file_name = files_to_ingest_[i].internal_file_path;
-            gen_context.requested_checksum_func_name =
-                files_checksum_func_names[i];
-            auto file_checksum_gen =
-                db_options_.file_checksum_gen_factory
-                    ->CreateFileChecksumGenerator(gen_context);
-
-            if (file_checksum_gen == nullptr ||
-                files_checksum_func_names[i] != file_checksum_gen->Name()) {
+            if (files_checksum_func_names[i] != file_checksum_gen->Name()) {
              status = Status::InvalidArgument(
-                  "Checksum function name " + files_checksum_func_names[i] +
-                  " for file " + external_files_paths[i] +
-                  " not recognized by DB checksum gen factory" +
-                  db_options_.file_checksum_gen_factory->Name() +
-                  (file_checksum_gen ? (" Returned function " +
-                                        std::string(file_checksum_gen->Name()))
-                                     : ""));
+                  "Checksum function name does not match with the checksum "
+                  "function name of this DB");
+              ROCKS_LOG_WARN(
+                  db_options_.info_log,
+                  "Sst file checksum verification of file: %s failed: %s",
+                  external_files_paths[i].c_str(), status.ToString().c_str());
              break;
            }
            files_to_ingest_[i].file_checksum = files_checksums[i];
@@ -378,11 +329,12 @@ Status ExternalSstFileIngestionJob::Prepare(
        status = Status::InvalidArgument(
            "The checksum information of ingested sst files are nonempty and "
            "the size of checksums or the size of the checksum function "
-            "names does not match with the number of ingested sst files");
-      }
-      if (!status.ok()) {
-        ROCKS_LOG_WARN(db_options_.info_log, "Ingestion failed: %s",
-                       status.ToString().c_str());
+            "names "
+            "does not match with the number of ingested sst files");
+        ROCKS_LOG_WARN(
+            db_options_.info_log,
+            "The ingested sst files checksum information is incomplete: %s",
+            status.ToString().c_str());
      }
    }
  }
@@ -407,9 +359,9 @@ void ExternalSstFileIngestionJob::DivideInputFilesIntoBatches() {

  file_batches_to_ingest_.emplace_back(/* _track_batch_range= */ true);
  for (auto& file : files_to_ingest_) {
-    if (!file_batches_to_ingest_.back().unset() &&
-        file_range_checker_.Overlaps(file_batches_to_ingest_.back(), file,
-                                     /* known_sorted= */ false)) {
+    if (file_range_checker_.OverlapsWithPrev(&file_batches_to_ingest_.back(),
+                                             &file,
+                                             /* ranges_sorted= */ false)) {
      file_batches_to_ingest_.emplace_back(/* _track_batch_range= */ true);
    }
    file_batches_to_ingest_.back().AddFile(&file, file_range_checker_);
@@ -418,32 +370,14 @@ void ExternalSstFileIngestionJob::DivideInputFilesIntoBatches() {

 Status ExternalSstFileIngestionJob::NeedsFlush(bool* flush_needed,
                                               SuperVersion* super_version) {
-  Status status;
-  if (atomic_replace_range_.has_value() && atomic_replace_range_->unset()) {
-    // For replacing whole CF, we can simply check whether memtable is empty
-    *flush_needed = !super_version->mem->IsEmpty();
-  } else {
-    autovector<UserKeyRange> ranges;
-    if (atomic_replace_range_.has_value()) {
-      assert(!atomic_replace_range_->smallest_internal_key.unset());
-      assert(!atomic_replace_range_->largest_internal_key.unset());
-      // NOTE: we already checked in Prepare() that the atomic_replace_range
-      // covers all the files_to_ingest
-      // FIXME: need to make upper bound key exclusive (not easy here because
-      // the existing internal APIs deal in inclusive upper bound user keys)
-      ranges.emplace_back(
-          atomic_replace_range_->smallest_internal_key.user_key(),
-          atomic_replace_range_->largest_internal_key.user_key());
-    } else {
-      ranges.reserve(files_to_ingest_.size());
-      for (const IngestedFileInfo& file_to_ingest : files_to_ingest_) {
-        ranges.emplace_back(file_to_ingest.start_ukey,
-                            file_to_ingest.limit_ukey);
-      }
-    }
-    status = cfd_->RangesOverlapWithMemtables(
-        ranges, super_version, db_options_.allow_data_in_errors, flush_needed);
+  size_t n = files_to_ingest_.size();
+  autovector<UserKeyRange> ranges;
+  ranges.reserve(n);
+  for (const IngestedFileInfo& file_to_ingest : files_to_ingest_) {
+    ranges.emplace_back(file_to_ingest.start_ukey, file_to_ingest.limit_ukey);
  }
+  Status status = cfd_->RangesOverlapWithMemtables(
+      ranges, super_version, db_options_.allow_data_in_errors, flush_needed);
  if (status.ok() && *flush_needed) {
    if (!ingestion_options_.allow_blocking_flush) {
      status = Status::InvalidArgument("External file requires flush");
@@ -496,49 +430,8 @@ Status ExternalSstFileIngestionJob::Run() {
  // the only active writer, and hence they are equal
  SequenceNumber last_seqno = versions_->LastSequence();
  edit_.SetColumnFamily(cfd_->GetID());
+  // The levels that the files will be ingested into

-  if (atomic_replace_range_.has_value()) {
-    auto* vstorage = super_version->current->storage_info();
-    if (atomic_replace_range_->unset()) {
-      if (cfd_->compaction_picker()->IsCompactionInProgress()) {
-        return Status::InvalidArgument(
-            "Atomic replace range (full) overlaps with pending compaction");
-      }
-      for (int lvl = 0; lvl < cfd_->NumberLevels(); lvl++) {
-        for (auto file : vstorage->LevelFiles(lvl)) {
-          // Set up to delete file to be replaced
-          edit_.DeleteFile(lvl, file->fd.GetNumber());
-        }
-      }
-    } else {
-      assert(!atomic_replace_range_->smallest_internal_key.unset());
-      assert(!atomic_replace_range_->largest_internal_key.unset());
-      for (int lvl = 0; lvl < cfd_->NumberLevels(); lvl++) {
-        if (cfd_->RangeOverlapWithCompaction(
-                atomic_replace_range_->smallest_internal_key.user_key(),
-                atomic_replace_range_->largest_internal_key.user_key(), lvl)) {
-          return Status::InvalidArgument(
-              "Atomic replace range overlaps with pending compaction");
-        }
-        for (auto file : vstorage->LevelFiles(lvl)) {
-          if (file_range_checker_.Overlaps(*atomic_replace_range_,
-                                           file->smallest, file->largest)) {
-            if (file_range_checker_.Contains(*atomic_replace_range_,
-                                             file->smallest, file->largest)) {
-              // Set up to delete file to be replaced
-              edit_.DeleteFile(lvl, file->fd.GetNumber());
-            } else {
-              // TODO: generate and ingest a tombstone file also
-              return Status::InvalidArgument(
-                  "Atomic replace range partially overlaps with existing file");
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Find levels to ingest into
  std::optional<int> prev_batch_uppermost_level;
  for (auto& batch : file_batches_to_ingest_) {
    int batch_uppermost_level = 0;
@@ -625,8 +518,16 @@ Status ExternalSstFileIngestionJob::AssignLevelsForOneBatch(
      current_time = oldest_ancester_time =
          static_cast<uint64_t>(temp_current_time);
    }
-    uint64_t tail_size = FileMetaData::CalculateTailSize(
-        file->fd.GetFileSize(), file->table_properties);
+    uint64_t tail_size = 0;
+    bool contain_no_data_blocks = file->table_properties.num_entries > 0 &&
+                                  (file->table_properties.num_entries ==
+                                   file->table_properties.num_range_deletions);
+    if (file->table_properties.tail_start_offset > 0 ||
+        contain_no_data_blocks) {
+      uint64_t file_size = file->fd.GetFileSize();
+      assert(file->table_properties.tail_start_offset <= file_size);
+      tail_size = file_size - file->table_properties.tail_start_offset;
+    }

    bool marked_for_compaction =
        file->table_properties.num_range_deletions == 1 &&
@@ -697,9 +598,10 @@ void ExternalSstFileIngestionJob::CreateEquivalentFileIngestingCompactions() {
        0 /* max_subcompaction, not applicable */,
        {} /* grandparents, not applicable */,
        std::nullopt /* earliest_snapshot */, nullptr /* snapshot_checker */,
-        CompactionReason::kExternalSstIngestion, "" /* trim_ts */,
-        -1 /* score, not applicable */,
-        files_overlap_ /* l0_files_might_overlap, not applicable */));
+        false /* is manual */, "" /* trim_ts */, -1 /* score, not applicable */,
+        false /* is deletion compaction, not applicable */,
+        files_overlap_ /* l0_files_might_overlap, not applicable */,
+        CompactionReason::kExternalSstIngestion));
  }
 }

@@ -848,8 +750,7 @@ Status ExternalSstFileIngestionJob::ResetTableReader(
      ro,
      TableReaderOptions(
          cfd_->ioptions(), sv->mutable_cf_options.prefix_extractor,
-          sv->mutable_cf_options.compression_manager.get(), env_options_,
-          cfd_->internal_comparator(),
+          env_options_, cfd_->internal_comparator(),
          sv->mutable_cf_options.block_protection_bytes_per_key,
          /*skip_filters*/ false, /*immortal*/ false,
          /*force_direct_prefetch*/ false, /*level*/ -1,
@@ -1203,10 +1104,6 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
    if (lvl > 0 && lvl < vstorage->base_level()) {
      continue;
    }
-    if (atomic_replace_range_.has_value()) {
-      target_level = lvl;
-      continue;
-    }
    if (cfd_->RangeOverlapWithCompaction(file_to_ingest->start_ukey,
                                         file_to_ingest->limit_ukey, lvl)) {
      // We must use L0 or any level higher than `lvl` to be able to overwrite
@@ -1275,8 +1172,6 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(

 Status ExternalSstFileIngestionJob::CheckLevelForIngestedBehindFile(
    IngestedFileInfo* file_to_ingest) {
-  assert(!atomic_replace_range_.has_value());
-
  auto* vstorage = cfd_->current()->storage_info();
  // First, check if new files fit in the last level
  int last_lvl = cfd_->NumberLevels() - 1;
@@ -27,77 +27,50 @@ class SystemClock;

 struct KeyRangeInfo {
  // Smallest internal key in an external file or for a batch of external files.
-  // unset() could be either invalid or "before all keys"
  InternalKey smallest_internal_key;
  // Largest internal key in an external file or for a batch of external files.
-  // unset() could be either invalid or "after all keys"
  InternalKey largest_internal_key;

-  bool unset() const {
-    // Legal internal keys are at least 8 bytes.
-    return smallest_internal_key.unset() || largest_internal_key.unset();
+  bool empty() const {
+    return smallest_internal_key.size() == 0 &&
+           largest_internal_key.size() == 0;
  }
 };

 // Helper class to apply SST file key range checks to the external files.
-// XXX: using sstableKeyCompare with user comparator on internal keys is
-// very broken
 class ExternalFileRangeChecker {
 public:
  explicit ExternalFileRangeChecker(const Comparator* ucmp) : ucmp_(ucmp) {}

  // Operator used for sorting ranges.
-  bool operator()(const KeyRangeInfo* range1,
-                  const KeyRangeInfo* range2) const {
-    assert(range1);
-    assert(range2);
-    assert(!range1->unset());
-    assert(!range2->unset());
-    return sstableKeyCompare(ucmp_, range1->smallest_internal_key,
-                             range2->smallest_internal_key) < 0;
+  bool operator()(const KeyRangeInfo* prev_range,
+                  const KeyRangeInfo* range) const {
+    assert(prev_range);
+    assert(range);
+    return sstableKeyCompare(ucmp_, prev_range->smallest_internal_key,
+                             range->smallest_internal_key) < 0;
  }

-  bool Overlaps(const KeyRangeInfo& range1, const KeyRangeInfo& range2,
-                bool known_sorted = false) const {
-    return Overlaps(range1, range2.smallest_internal_key,
-                    range2.largest_internal_key, known_sorted);
-  }
-  bool Overlaps(const KeyRangeInfo& range1, const InternalKey& range2_smallest,
-                const InternalKey& range2_largest,
-                bool known_sorted = false) const {
-    bool any_unset =
-        range1.unset() || range2_smallest.unset() || range2_largest.unset();
-    if (any_unset) {
-      assert(!any_unset);
+  // Check whether `range` overlaps with `prev_range`. `ranges_sorted` can be
+  // set to true when the inputs are already sorted based on the sorting logic
+  // provided by this checker's operator(), which can help simplify the check.
+  bool OverlapsWithPrev(const KeyRangeInfo* prev_range,
+                        const KeyRangeInfo* range,
+                        bool ranges_sorted = false) const {
+    assert(prev_range);
+    assert(range);
+    if (prev_range->empty() || range->empty()) {
      return false;
    }
-    if (known_sorted) {
-      return sstableKeyCompare(ucmp_, range1.largest_internal_key,
-                               range2_smallest) >= 0;
+    if (ranges_sorted) {
+      return sstableKeyCompare(ucmp_, prev_range->largest_internal_key,
+                               range->smallest_internal_key) >= 0;
    }

-    return sstableKeyCompare(ucmp_, range1.largest_internal_key,
-                             range2_smallest) >= 0 &&
-           sstableKeyCompare(ucmp_, range1.smallest_internal_key,
-                             range2_largest) <= 0;
-  }
-
-  bool Contains(const KeyRangeInfo& range1, const KeyRangeInfo& range2) {
-    return Contains(range1, range2.smallest_internal_key,
-                    range2.largest_internal_key);
-  }
-  bool Contains(const KeyRangeInfo& range1, const InternalKey& range2_smallest,
-                const InternalKey& range2_largest) {
-    bool any_unset =
-        range1.unset() || range2_smallest.unset() || range2_largest.unset();
-    if (any_unset) {
-      assert(!any_unset);
-      return false;
-    }
-    return sstableKeyCompare(ucmp_, range1.smallest_internal_key,
-                             range2_smallest) <= 0 &&
-           sstableKeyCompare(ucmp_, range1.largest_internal_key,
-                             range2_largest) >= 0;
+    return sstableKeyCompare(ucmp_, prev_range->largest_internal_key,
+                             range->smallest_internal_key) >= 0 &&
+           sstableKeyCompare(ucmp_, prev_range->smallest_internal_key,
+                             range->largest_internal_key) <= 0;
  }

  void MaybeUpdateRange(const InternalKey& start_key,
@@ -245,7 +218,6 @@ class ExternalSstFileIngestionJob {
  Status Prepare(const std::vector<std::string>& external_files_paths,
                 const std::vector<std::string>& files_checksums,
                 const std::vector<std::string>& files_checksum_func_names,
-                 const std::optional<RangeOpt>& atomic_replace_range,
                 const Temperature& file_temperature, uint64_t next_file_number,
                 SuperVersion* sv);

@@ -390,7 +362,6 @@ class ExternalSstFileIngestionJob {
  autovector<IngestedFileInfo> files_to_ingest_;
  std::vector<FileBatchInfo> file_batches_to_ingest_;
  const IngestExternalFileOptions& ingestion_options_;
-  std::optional<KeyRangeInfo> atomic_replace_range_;
  Directories* directories_;
  EventLogger* event_logger_;
  VersionEdit edit_;
Author	SHA1	Message	Date
Jay Huh	45f7473909	set ignore_unknown_options when parsing options (#13443 ) Summary: In case the primary host has a new option added which isn't available in the remote worker yet, the remote compaction currently fails. In most cases, these new options are not relevant to the remote compaction and the worker should be able to move on by ignoring it. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13443 Test Plan: Verified internally in Meta Infra. Reviewed By: anand1976 Differential Revision: D70744359 Pulled By: jaykorean fbshipit-source-id: eb6a388c2358a7f8089f2e35a378b7017b9e03f3	2025-03-06 17:32:20 -08:00
anand76	884f57ccc1	Fix version numbering from 10.1.0 to 10.0.1	2025-03-06 09:53:11 -08:00
anand76	6fff8f6849	Update HISTORY and version to 10.1.0	2025-03-06 09:51:05 -08:00
Jay Huh	28788c6337	Introduce kAborted Status (#13438 ) Summary: If compaction job needs to be aborted inside `Schedule()` or `Wait()` today (e.g. Primary host is shutting down), the only two options are the following - Handle it as failure by returning `CompactionServiceJobStatus::kFailure` - Return `CompactionServiceJobStatus::kUseLocal` and let the compaction move on locally and eventually succeed or fail depending on the timing In this PR, we are introducing a new status, `CompactionServiceJobStatus::kAborted`, so that the implementation of `Schedule()` and `Wait()` can return it. Just like how `CompactionServiceJobStatus::kFailure` is handled, compaction will not move on and fail, but the status will be returned as `Status::Aborted()` instead of `Status::Incomplete()` Pull Request resolved: https://github.com/facebook/rocksdb/pull/13438 Test Plan: Unit Test added ``` ./compaction_service_test --gtest_filter="CompactionServiceTest.AbortedWhileWait" ``` Reviewed By: anand1976, hx235 Differential Revision: D70655355 Pulled By: jaykorean fbshipit-source-id: 22614ce9c7455cda649b15465625edc93978fe11	2025-03-06 09:48:17 -08:00
Jay Huh	b09612881c	Add Logging for debugging InputFileCheck Failure (#13427 ) Summary: Add detailed log for debugging purpose Pull Request resolved: https://github.com/facebook/rocksdb/pull/13427 Test Plan: CI Reviewed By: cbi42, hx235 Differential Revision: D70274613 Pulled By: jaykorean fbshipit-source-id: de4bc61853136b923aa786717e7979be8886b9bd	2025-03-06 09:48:05 -08:00
anand76	513c8d2f16	Initial implementation of ExternalTableBuilder (#13434 ) Summary: This PR adds the ability to use an ExternalTableBuilder through the SstFileWriter to create external tables. This is a counterpart to https://github.com/facebook/rocksdb/issues/13401 , which adds the ExternalTableReader. The support for external tables is confined to ingestion only DBs, with external table files ingested into the bottommost level only. https://github.com/facebook/rocksdb/issues/13431 enforces ingestion only DBs by adding a disallow_memtable_writes column family option. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13434 Test Plan: New unit tests in table_test.cc Reviewed By: pdillinger Differential Revision: D70532054 Pulled By: anand1976 fbshipit-source-id: a837487eadfabed9627a0eceb403bfc5fc2c427c	2025-03-06 09:47:30 -08:00
anand76	82ada7502d	Add opaque options in ReadOptions for external tables (#13436 ) Summary: Add an unordered_map of name/value pairs in ReadOptions::property_bag, similar to IOOptions::property_bag. It allows users to pass through some custom options to an external table. Pull Request resolved: https://github.com/facebook/rocksdb/pull/13436 Reviewed By: jaykorean Differential Revision: D70649609 Pulled By: anand1976 fbshipit-source-id: 9b14806a9f3599b861827bd4ae6e948861edc51a	2025-03-06 09:47:16 -08:00
Peter Dillinger	20b93e3bf7	New CF option disallow_memtable_writes (#13431 ) Summary: ... to better support "ingestion only" column families such as those using an external file reader as in https://github.com/facebook/rocksdb/issues/13401. It would be possible to implement this by getting rid of the memtable for that CF, but it quickly because clear that such an approach would need to update a lot of places to deal with such a possibility. And we already have logic to optimize reads when a memtable is empty. We put a vector memtable in place to minimize overheads of an empty memtable. There are three layers of defense against writes to the memtable: * WriteBatch ops to a disallowed CF will fail immediately, without waiting for Write(). For this check to work, we need a ColumnFamilyHandle and because of that, we don't support disallow_memtable_writes on the default column family. * MemtableInserter will reject writes to disallowed CFs. This is needed to protect re-open with disallow when there are existing writes in a WAL. * The placeholder memtable is marked immutable. This will cause an assertion failure on attempt to write, such as in case of bug or regression. Suggested follow-up: * Remove the limitation on using the option with the default column family, perhaps by solving https://github.com/facebook/rocksdb/issues/13429 more generally or perhaps with some specific check before the first memtable write of the batch (but potential CPU overhead for such a check - there's likely optimization opportunities around ColumnFamilyMemTables). Pull Request resolved: https://github.com/facebook/rocksdb/pull/13431 Test Plan: unit tests added Performance: A db_bench call designed to realistically focus on the CPU cost of writes: ``` ./db_bench -db=/dev/shm/dbbench1 --benchmarks=fillrandom -num=10000000 -compaction_style=2 -fifo_compaction_max_table_files_size_mb=1000 -fifo_compaction_allow_compaction=0 -num_column_families=20 -disable_wal -write_buffer_size=1234000 ``` Running before & after tests at the same time on the same machine, 40 iterations each, average ops/s, DEBUG_LEVEL=0, remove slowest run of each: Before: 772466 After: 773785 (0.2% faster) Likely within the noise, as if there was any change, we would expect a slight regression. Reviewed By: anand1976 Differential Revision: D70495936 Pulled By: pdillinger fbshipit-source-id: 306f7e737f87c1fbb52c5805f3cadb6e8ced9b40	2025-03-06 09:46:56 -08:00
Changyu Bi	c1f63e16f0	Add missing txn updates to HISTORY.md	2025-02-22 17:44:19 -08:00
Changyu Bi	ba27c3a0f9	Update HISTORY.md for 10.0 release	2025-02-21 20:29:21 -08:00