Update version and HISTORY for 6.21.3

Don't hold DB mutex for block cache entry stat scans (#8538 )
Summary: I previously didn't notice the DB mutex was being held during block cache entry stat scans, probably because I primarily checked for read performance regressions, because they require the block cache and are traditionally latency-sensitive. This change does some refactoring to avoid holding DB mutex and to avoid triggering and waiting for a scan in GetProperty("rocksdb.cfstats"). Some tests have to be updated because now the stats collector is populated in the Cache aggressively on DB startup rather than lazily. (I hope to clean up some of this added complexity in the future.) This change also ensures proper treatment of need_out_of_mutex for non-int DB properties. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8538 Test Plan: Added unit test logic that uses sync points to fail if the DB mutex is held during a scan, covering the various ways that a scan might be triggered. Performance test - the known impact to holding the DB mutex is on TransactionDB, and the easiest way to see the impact is to hack the scan code to almost always miss and take an artificially long time scanning. Here I've injected an unconditional 5s sleep at the call to ApplyToAllEntries. Before (hacked): $ TEST_TMPDIR=/dev/shm ./db_bench.base_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 433.219 micros/op 2308 ops/sec; 0.1 MB/s ( transactions:78999 aborts:0) rocksdb.db.write.micros P50 : 16.135883 P95 : 36.622503 P99 : 66.036115 P100 : 5000614.000000 COUNT : 149677 SUM : 8364856 $ TEST_TMPDIR=/dev/shm ./db_bench.base_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 448.802 micros/op 2228 ops/sec; 0.1 MB/s ( transactions:75999 aborts:0) rocksdb.db.write.micros P50 : 16.629221 P95 : 37.320607 P99 : 72.144341 P100 : 5000871.000000 COUNT : 143995 SUM : 13472323 Notice the 5s P100 write time. After (hacked): $ TEST_TMPDIR=/dev/shm ./db_bench.new_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 303.645 micros/op 3293 ops/sec; 0.1 MB/s ( transactions:98999 aborts:0) rocksdb.db.write.micros P50 : 16.061871 P95 : 33.978834 P99 : 60.018017 P100 : 616315.000000 COUNT : 187619 SUM : 4097407 $ TEST_TMPDIR=/dev/shm ./db_bench.new_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 310.383 micros/op 3221 ops/sec; 0.1 MB/s ( transactions:96999 aborts:0) rocksdb.db.write.micros P50 : 16.270026 P95 : 35.786844 P99 : 64.302878 P100 : 603088.000000 COUNT : 183819 SUM : 4095918 P100 write is now ~0.6s. Not good, but it's the same even if I completely bypass all the scanning code: $ TEST_TMPDIR=/dev/shm ./db_bench.new_skip -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 311.365 micros/op 3211 ops/sec; 0.1 MB/s ( transactions:96999 aborts:0) rocksdb.db.write.micros P50 : 16.274362 P95 : 36.221184 P99 : 68.809783 P100 : 649808.000000 COUNT : 183819 SUM : 4156767 $ TEST_TMPDIR=/dev/shm ./db_bench.new_skip -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 | egrep 'db.db.write.micros|micros/op' randomtransaction : 308.395 micros/op 3242 ops/sec; 0.1 MB/s ( transactions:97999 aborts:0) rocksdb.db.write.micros P50 : 16.106222 P95 : 37.202403 P99 : 67.081875 P100 : 598091.000000 COUNT : 185714 SUM : 4098832 No substantial difference. Reviewed By: siying Differential Revision: D29738847 Pulled By: pdillinger fbshipit-source-id: 1c5c155f5a1b62e4fea0fd4eeb515a8b7474027b
2026-11-07 11:32:34 -05:00 · 2021-07-19 08:30:36 -07:00 · 2021-07-19 08:26:18 -07:00 · 2021-07-19 08:09:13 -07:00 · 2021-07-19 08:05:40 -07:00 · 2021-07-19 08:05:27 -07:00
589 changed files with 10733 additions and 37639 deletions
@@ -5,9 +5,9 @@ orbs:
  slack: circleci/slack@3.4.2

 aliases:
-  - &notify-on-main-failure
+  - &notify-on-master-failure
    fail_only: true
-    only_for_branches: main
+    only_for_branches: master

 commands:
  install-pyenv-on-macos:
@@ -49,9 +49,6 @@ commands:
            echo "export GTEST_OUTPUT=\"xml:/tmp/test-results/\"" >> $BASH_ENV
            echo "export SKIP_FORMAT_BUCK_CHECKS=1" >> $BASH_ENV
            echo "export PRINT_PARALLEL_OUTPUTS=1" >> $BASH_ENV
-            echo "export GTEST_COLOR=1" >> $BASH_ENV
-            echo "export CTEST_OUTPUT_ON_FAILURE=1" >> $BASH_ENV
-            echo "export CTEST_TEST_TIMEOUT=300" >> $BASH_ENV

  pre-steps-macos:
      steps:
@@ -60,7 +57,7 @@ commands:

  post-steps:
    steps:
-      - slack/status: *notify-on-main-failure
+      - slack/status: *notify-on-master-failure
      - store_test_results: # store test result if there's any
          path: /tmp/test-results
      - store_artifacts: # store LOG for debugging if there's any
@@ -91,28 +88,6 @@ commands:
          command: |
            sudo apt-get update -y && sudo apt-get install -y libgflags-dev

-  install-benchmark:
-    steps:
-      - run: # currently doesn't support ubuntu-1604 which doesn't have libbenchmark package, user can still install by building it youself
-          name: Install benchmark
-          command: |
-            sudo apt-get update -y && sudo apt-get install -y libbenchmark-dev
-
-  install-librados:
-    steps:
-      - run:
-          name: Install librados
-          command: |
-            sudo apt-get update -y && sudo apt-get install -y librados-dev
-
-  upgrade-cmake:
-    steps:
-      - run:
-          name: Upgrade cmake
-          command: |
-            sudo apt remove --purge cmake
-            sudo snap install cmake --classic
-
  install-gflags-on-macos:
    steps:
      - run:
@@ -165,12 +140,12 @@ jobs:
      - install-cmake-on-macos
      - install-gflags-on-macos
      - pre-steps-macos
-      - run: ulimit -S -n 1048576 && (mkdir build && cd build && cmake -DWITH_GFLAGS=1 .. && make V=1 -j32 && ctest -j10) | .circleci/cat_ignore_eagain
+      - run: ulimit -S -n 1048576 && (mkdir build && cd build && cmake -DWITH_GFLAGS=1 .. && make V=1 -j32) | .circleci/cat_ignore_eagain
      - post-steps

  build-linux:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -178,20 +153,19 @@ jobs:
      - run: make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
      - post-steps

-  build-linux-mem-env-librados:
+  build-linux-mem-env:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
      - install-gflags
-      - install-librados
-      - run: MEM_ENV=1 ROCKSDB_USE_LIBRADOS=1 make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
+      - run: MEM_ENV=1 make V=1 J=32 -j32 check | .circleci/cat_ignore_eagain
      - post-steps

  build-linux-encrypted-env:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -201,7 +175,7 @@ jobs:

  build-linux-shared_lib-alt_namespace-status_checked:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -211,7 +185,7 @@ jobs:

  build-linux-release:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    steps:
      - checkout # check out the code in the project directory
@@ -238,7 +212,7 @@ jobs:

  build-linux-lite:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -248,7 +222,7 @@ jobs:

  build-linux-lite-release:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    steps:
      - checkout # check out the code in the project directory
@@ -261,7 +235,7 @@ jobs:

  build-linux-clang-no_test_run:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: xlarge
    steps:
      - checkout # check out the code in the project directory
@@ -271,7 +245,7 @@ jobs:

  build-linux-clang10-asan:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -282,7 +256,7 @@ jobs:

  build-linux-clang10-mini-tsan:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -293,7 +267,7 @@ jobs:

  build-linux-clang10-ubsan:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -304,7 +278,7 @@ jobs:

  build-linux-clang10-clang-analyze:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -314,29 +288,16 @@ jobs:
      - run: CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 CLANG_ANALYZER="/usr/bin/clang++-10" CLANG_SCAN_BUILD=scan-build-10 USE_CLANG=1 make V=1 -j32 analyze | .circleci/cat_ignore_eagain # aligned new doesn't work for reason we haven't figured out. For unknown, reason passing "clang++-10" as CLANG_ANALYZER doesn't work, and we need a full path.
      - post-steps

-  build-linux-cmake:
+  build-linux-cmake-no_test_run:
    machine:
-      image: ubuntu-1604:202104-01
-    resource_class: 2xlarge
+      image: ubuntu-1604:202007-01
+    resource_class: large
    steps:
-      - pre-steps
-      - install-gflags
-      - upgrade-cmake
-      - run: (mkdir build && cd build && cmake -DWITH_GFLAGS=1 .. && make V=1 -j20 && ctest -j20) | .circleci/cat_ignore_eagain
+      - checkout # check out the code in the project directory
+      - run: (mkdir build && cd build && cmake -DWITH_GFLAGS=0 .. && make V=1 -j8) | .circleci/cat_ignore_eagain
      - post-steps

-  build-linux-cmake-ubuntu-20:
-    machine:
-      image: ubuntu-2004:202104-01
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - install-gflags
-      - install-benchmark
-      - run: (mkdir build && cd build && cmake -DWITH_GFLAGS=1 -DWITH_BENCHMARK=1 .. && make V=1 -j20 && ctest -j20 && make microbench) | .circleci/cat_ignore_eagain
-      - post-steps
-
-  build-linux-unity-and-headers:
+  build-linux-unity:
    docker: # executor type
      - image: gcc:latest
    resource_class: large
@@ -344,12 +305,11 @@ jobs:
      - checkout # check out the code in the project directory
      - run: apt-get update -y && apt-get install -y libgflags-dev
      - run: TEST_TMPDIR=/dev/shm && make V=1 -j8 unity_test | .circleci/cat_ignore_eagain
-      - run: make V=1 -j8 -k check-headers | .circleci/cat_ignore_eagain # could be moved to a different build
      - post-steps

  build-linux-gcc-4_8-no_test_run:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    steps:
      - pre-steps
@@ -387,17 +347,6 @@ jobs:
      - run: CC=gcc-10 CXX=g++-10 V=1 SKIP_LINK=1 ROCKSDB_CXX_STANDARD=c++20 make -j16 all | .circleci/cat_ignore_eagain # Linking broken because libgflags compiled with newer ABI
      - post-steps

-  # This job is only to make sure the microbench tests are able to run, the benchmark result is not meaningful as the CI host is changing.
-  build-linux-microbench:
-    machine:
-      image: ubuntu-2004:202010-01
-    resource_class: xlarge
-    steps:
-      - pre-steps
-      - install-benchmark
-      - run: DEBUG_LEVEL=0 make microbench | .circleci/cat_ignore_eagain
-      - post-steps
-
  build-windows:
    executor: windows-2xlarge
    parameters:
@@ -468,7 +417,7 @@ jobs:

  build-linux-java:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    environment:
      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
@@ -492,7 +441,7 @@ jobs:

  build-linux-java-static:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    environment:
      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
@@ -563,7 +512,7 @@ jobs:

  build-examples:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: large
    steps:
      - pre-steps
@@ -576,7 +525,7 @@ jobs:

  build-cmake-mingw:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -599,7 +548,7 @@ jobs:

  build-linux-non-shm:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    parameters:
      start_test:
@@ -655,7 +604,6 @@ jobs:
      JAVA_HOME: /usr/lib/jvm/java-8-openjdk-arm64
    steps:
      - pre-steps
-      - install-gflags
      - run:
          name: "Set Java Environment"
          command: |
@@ -668,7 +616,7 @@ jobs:
          command: |
            mkdir build
            cd build
-            cmake -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=0 -DWITH_GFLAGS=1 -DWITH_BENCHMARK_TOOLS=0 -DWITH_TOOLS=0 -DWITH_CORE_TOOLS=1 ..
+            cmake -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=0 -DWITH_GFLAGS=0 -DWITH_BENCHMARK_TOOLS=0 -DWITH_TOOLS=0 -DWITH_CORE_TOOLS=1 ..
            make -j4
      - run:
          name: "Build Java with cmake"
@@ -676,13 +624,13 @@ jobs:
            rm -rf build
            mkdir build
            cd build
-            cmake -DJNI=1 -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=1 ..
+            cmake -DJNI=1 -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=0 ..
            make -j4 rocksdb rocksdbjni
      - post-steps

  build-format-compatible:
    machine:
-      image: ubuntu-1604:202104-01
+      image: ubuntu-1604:202007-01
    resource_class: 2xlarge
    steps:
      - pre-steps
@@ -702,13 +650,9 @@ workflows:
  build-linux:
    jobs:
      - build-linux
-  build-linux-cmake:
+  build-linux-mem-env:
    jobs:
-      - build-linux-cmake
-      - build-linux-cmake-ubuntu-20
-  build-linux-mem-env-librados:
-    jobs:
-      - build-linux-mem-env-librados
+      - build-linux-mem-env
  build-linux-encrypted-env:
    jobs:
      - build-linux-encrypted-env
@@ -739,9 +683,9 @@ workflows:
  build-linux-clang10-clang-analyze:
    jobs:
      - build-linux-clang10-clang-analyze
-  build-linux-unity-and-headers:
+  build-linux-unity:
    jobs:
-      - build-linux-unity-and-headers
+      - build-linux-unity
  build-windows-vs2019:
    jobs:
      - build-windows:
@@ -757,6 +701,12 @@ workflows:
          name: "build-windows-vs2017"
          vs_year: "2017"
          cmake_generator: "Visual Studio 15 Win64"
+#  build-windows-vs2015:
+#    jobs:
+#      - build-windows:
+#          name: "build-windows-vs2015"
+#          vs_year: "2015"
+#          cmake_generator: "Visual Studio 14 Win64"
  build-java:
    jobs:
      - build-linux-java
@@ -783,6 +733,7 @@ workflows:
  build-linux-compilers-no_test_run:
    jobs:
      - build-linux-clang-no_test_run
+      - build-linux-cmake-no_test_run
      - build-linux-gcc-4_8-no_test_run
      - build-linux-gcc-8-no_test_run
      - build-linux-gcc-9-no_test_run
@@ -800,9 +751,6 @@ workflows:
  build-linux-arm:
    jobs:
      - build-linux-arm
-  build-microbench:
-    jobs:
-      - build-linux-microbench
  nightly:
    triggers:
      - schedule:
@@ -810,7 +758,7 @@ workflows:
          filters:
            branches:
              only:
-                - main
+                - master
    jobs:
      - build-format-compatible
      - build-linux-arm-test-full
@@ -39,6 +39,3 @@ jobs:

    - name: Compare buckify output
      run: make check-buck-targets
-
-    - name: Simple source code checks
-      run: make check-sources
@@ -32,11 +32,10 @@
 # 3. cmake ..
 # 4. make -j

-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.5.1)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules/")
 include(ReadVersion)
-include(GoogleTest)
 get_rocksdb_version(rocksdb_VERSION)
 project(rocksdb
  VERSION ${rocksdb_VERSION}
@@ -72,12 +71,6 @@ option(WITH_WINDOWS_UTF8_FILENAMES "use UTF8 as characterset for opening files,
 if (WITH_WINDOWS_UTF8_FILENAMES)
  add_definitions(-DROCKSDB_WINDOWS_UTF8_FILENAMES)
 endif()
-
-if ($ENV{CIRCLECI})
-  message(STATUS "Build for CircieCI env, a few tests may be disabled")
-  add_definitions(-DCIRCLECI)
-endif()
-
 # third-party/folly is only validated to work on Linux and Windows for now.
 # So only turn it on there by default.
 if(CMAKE_SYSTEM_NAME MATCHES "Linux|Windows")
@@ -130,11 +123,11 @@ else()
        set(GFLAGS_LIB ${GFLAGS_TARGET})
      else()
        # Config with GFLAGS_LIBRARIES available since gflags 2.1.0
-        set(GFLAGS_LIB ${gflags_LIBRARIES})
+        set(GFLAGS_LIB ${GFLAGS_LIBRARIES})
      endif()
    else()
      find_package(gflags REQUIRED)
-      set(GFLAGS_LIB gflags::gflags)
+        set(GFLAGS_LIB gflags::gflags)
    endif()
    include_directories(${GFLAGS_INCLUDE_DIR})
    list(APPEND THIRDPARTY_LIBS ${GFLAGS_LIB})
@@ -218,7 +211,7 @@ if(MSVC)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4800 /wd4996 /wd4351 /wd4100 /wd4204 /wd4324")
 else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall -pthread")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing")
  if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
@@ -624,19 +617,16 @@ find_package(Threads REQUIRED)
 set(SOURCES
        cache/cache.cc
        cache/cache_entry_roles.cc
-        cache/cache_reservation_manager.cc
        cache/clock_cache.cc
        cache/lru_cache.cc
        cache/sharded_cache.cc
        db/arena_wrapped_db_iter.cc
-        db/blob/blob_fetcher.cc
        db/blob/blob_file_addition.cc
        db/blob/blob_file_builder.cc
        db/blob/blob_file_cache.cc
        db/blob/blob_file_garbage.cc
        db/blob/blob_file_meta.cc
        db/blob/blob_file_reader.cc
-        db/blob/blob_garbage_meter.cc
        db/blob/blob_log_format.cc
        db/blob/blob_log_sequential_reader.cc
        db/blob/blob_log_writer.cc
@@ -713,7 +703,6 @@ set(SOURCES
        env/file_system_tracer.cc
        env/fs_remap.cc
        env/mock_env.cc
-        env/unique_id.cc
        file/delete_scheduler.cc
        file/file_prefetch_buffer.cc
        file/file_util.cc
@@ -818,12 +807,9 @@ set(SOURCES
        tools/ldb_tool.cc
        tools/sst_dump_tool.cc
        tools/trace_analyzer_tool.cc
+        trace_replay/trace_replay.cc
        trace_replay/block_cache_tracer.cc
        trace_replay/io_tracer.cc
-        trace_replay/trace_record_handler.cc
-        trace_replay/trace_record_result.cc
-        trace_replay/trace_record.cc
-        trace_replay/trace_replay.cc
        util/coding.cc
        util/compaction_job_stats_impl.cc
        util/comparator.cc
@@ -836,7 +822,6 @@ set(SOURCES
        util/random.cc
        util/rate_limiter.cc
        util/ribbon_config.cc
-        util/regex.cc
        util/slice.cc
        util/file_checksum_helper.cc
        util/status.cc
@@ -855,7 +840,6 @@ set(SOURCES
        utilities/cassandra/format.cc
        utilities/cassandra/merge_operator.cc
        utilities/checkpoint/checkpoint_impl.cc
-        utilities/compaction_filters.cc
        utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc
        utilities/debug.cc
        utilities/env_mirror.cc
@@ -864,7 +848,6 @@ set(SOURCES
        utilities/fault_injection_fs.cc
        utilities/leveldb_options/leveldb_options.cc
        utilities/memory/memory_util.cc
-        utilities/merge_operators.cc
        utilities/merge_operators/bytesxor.cc
        utilities/merge_operators/max.cc
        utilities/merge_operators/put.cc
@@ -884,7 +867,6 @@ set(SOURCES
        utilities/simulator_cache/sim_cache.cc
        utilities/table_properties_collectors/compact_on_deletion_collector.cc
        utilities/trace/file_trace_reader_writer.cc
-        utilities/trace/replayer_impl.cc
        utilities/transactions/lock/lock_manager.cc
        utilities/transactions/lock/point/point_lock_tracker.cc
        utilities/transactions/lock/point/point_lock_manager.cc
@@ -943,8 +925,13 @@ if(WIN32)
    port/win/env_win.cc
    port/win/env_default.cc
    port/win/port_win.cc
-    port/win/win_logger.cc
-    port/win/win_thread.cc)
+    port/win/win_logger.cc)
+  if(NOT MINGW)
+    # Mingw only supports std::thread when using
+    # posix threads.
+    list(APPEND SOURCES
+      port/win/win_thread.cc)
+  endif()
 if(WITH_XPRESS)
  list(APPEND SOURCES
    port/win/xpress_win.cc)
@@ -1126,23 +1113,19 @@ if(WITH_TESTS)
  )
  if(WITH_ALL_TESTS)
    list(APPEND TESTS
-        cache/cache_reservation_manager_test.cc
        cache/cache_test.cc
        cache/lru_cache_test.cc
-        db/blob/blob_counting_iterator_test.cc
        db/blob/blob_file_addition_test.cc
        db/blob/blob_file_builder_test.cc
        db/blob/blob_file_cache_test.cc
        db/blob/blob_file_garbage_test.cc
        db/blob/blob_file_reader_test.cc
-        db/blob/blob_garbage_meter_test.cc
        db/blob/db_blob_basic_test.cc
        db/blob/db_blob_compaction_test.cc
        db/blob/db_blob_corruption_test.cc
        db/blob/db_blob_index_test.cc
        db/column_family_test.cc
        db/compact_files_test.cc
-        db/compaction/clipping_iterator_test.cc
        db/compaction/compaction_job_stats_test.cc
        db/compaction/compaction_job_test.cc
        db/compaction/compaction_iterator_test.cc
@@ -1338,21 +1321,21 @@ if(WITH_TESTS)

  foreach(sourcefile ${TESTS})
      get_filename_component(exename ${sourcefile} NAME_WE)
-      add_executable(${exename}${ARTIFACT_SUFFIX} ${sourcefile})
-      set_target_properties(${exename}${ARTIFACT_SUFFIX}
+      add_executable(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} ${sourcefile})
+      set_target_properties(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX}
        PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD_RELEASE 1
        EXCLUDE_FROM_DEFAULT_BUILD_MINRELEASE 1
        EXCLUDE_FROM_DEFAULT_BUILD_RELWITHDEBINFO 1
        OUTPUT_NAME ${exename}${ARTIFACT_SUFFIX}
      )
-      target_link_libraries(${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} testharness gtest ${THIRDPARTY_LIBS} ${ROCKSDB_LIB})
+      target_link_libraries(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} testutillib${ARTIFACT_SUFFIX} testharness gtest ${THIRDPARTY_LIBS} ${ROCKSDB_LIB})
      if(NOT "${exename}" MATCHES "db_sanity_test")
-        gtest_discover_tests(${exename} DISCOVERY_TIMEOUT 120)
-        add_dependencies(check ${exename}${ARTIFACT_SUFFIX})
+        add_test(NAME ${exename} COMMAND ${exename}${ARTIFACT_SUFFIX})
+        add_dependencies(check ${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX})
      endif()
      if("${exename}" MATCHES "env_librados_test")
        # env_librados_test.cc uses librados directly
-        target_link_libraries(${exename}${ARTIFACT_SUFFIX} rados)
+        target_link_libraries(${CMAKE_PROJECT_NAME}_${exename}${ARTIFACT_SUFFIX} rados)
      endif()
  endforeach(sourcefile ${TESTS})

@@ -1432,8 +1415,3 @@ option(WITH_EXAMPLES "build with examples" OFF)
 if(WITH_EXAMPLES)
  add_subdirectory(examples)
 endif()
-
-option(WITH_BENCHMARK "build benchmark tests" OFF)
-if(WITH_BENCHMARK)
-  add_subdirectory(${PROJECT_SOURCE_DIR}/microbench/)
-endif()
@@ -1,141 +1,16 @@
 # Rocksdb Change Log
-## 6.25.3 (2021-10-14)
+## 6.21.3 (2021-07-19)
 ### Bug Fixes
-* Fixed bug in calls to `IngestExternalFiles()` with files for multiple column families. The bug could have introduced a delay in ingested file keys becoming visible after `IngestExternalFiles()` returned. Furthermore, mutations to ingested file keys while they were invisible could have been dropped (not necessarily immediately).
-* Fixed a possible race condition impacting users of `WriteBufferManager` who constructed it with `allow_stall == true`. The race condition led to undefined behavior (in our experience, typically a process crash).
-* Fixed a bug where stalled writes would remain stalled forever after the user calls `WriteBufferManager::SetBufferSize()` with `new_size == 0` to dynamically disable memory limiting.
+* Fixed confusingly duplicated output in LOG for periodic stats ("DUMPING STATS"), including "Compaction Stats" and "File Read Latency Histogram By Level". (Included because the next bug fix built upon this one.)
+* Fixed block cache entry stat scans not to hold the DB mutex, which was a serious performance bug for tail latencies in TransactionDB and likely elsewhere.

-## 6.25.2 (2021-10-11)
+## 6.21.2 (2021-06-14)
 ### Bug Fixes
-* Fix `DisableManualCompaction()` to cancel compactions even when they are waiting on automatic compactions to drain due to `CompactRangeOptions::exclusive_manual_compactions == true`.
-* Fix contract of `Env::ReopenWritableFile()` and `FileSystem::ReopenWritableFile()` to specify any existing file must not be deleted or truncated.
+* Fixed related but less common performance bugs in background gathering of block cache entry statistics.

-## 6.25.1 (2021-09-28)
+## 6.21.1 (2021-06-08)
 ### Bug Fixes
-* Fixes a bug in directed IO mode when calling MultiGet() for blobs in the same blob file. The bug is caused by not sorting the blob read requests by file offsets.
-
-## 6.25.0 (2021-09-20)
-### Bug Fixes
-* Allow secondary instance to refresh iterator. Assign read seq after referencing SuperVersion.
-* Fixed a bug of secondary instance's last_sequence going backward, and reads on the secondary fail to see recent updates from the primary.
-* Fixed a bug that could lead to duplicate DB ID or DB session ID in POSIX environments without /proc/sys/kernel/random/uuid.
-* Fix a race in DumpStats() with column family destruction due to not taking a Ref on each entry while iterating the ColumnFamilySet.
-* Fix a race in item ref counting in LRUCache when promoting an item from the SecondaryCache.
-* Fix a race in BackupEngine if RateLimiter is reconfigured during concurrent Restore operations.
-* Fix a bug on POSIX in which failure to create a lock file (e.g. out of space) can prevent future LockFile attempts in the same process on the same file from succeeding.
-* Fix a bug that backup_rate_limiter and restore_rate_limiter in BackupEngine could not limit read rates.
-* Fix the implementation of `prepopulate_block_cache = kFlushOnly` to only apply to flushes rather than to all generated files.
-* Fix WAL log data corruption when using DBOptions.manual_wal_flush(true) and WriteOptions.sync(true) together. The sync WAL should work with locked log_write_mutex_.
-* Add checks for validity of the IO uring completion queue entries, and fail the BlockBasedTableReader MultiGet sub-batch if there's an invalid completion
-* Add an interface RocksDbIOUringEnable() that, if defined by the user, will allow them to enable/disable the use of IO uring by RocksDB
-* Fix the bug that when direct I/O is used and MultiRead() returns a short result, RandomAccessFileReader::MultiRead() still returns full size buffer, with returned short value together with some data in original buffer. This bug is unlikely cause incorrect results, because (1) since FileSystem layer is expected to retry on short result, returning short results is only possible when asking more bytes in the end of the file, which RocksDB doesn't do when using MultiRead(); (2) checksum is unlikely to match.
-
-### New Features
-* RemoteCompaction's interface now includes `db_name`, `db_id`, `session_id`, which could help the user uniquely identify compaction job between db instances and sessions.
-* Added a ticker statistic, "rocksdb.verify_checksum.read.bytes", reporting how many bytes were read from file to serve `VerifyChecksum()` and `VerifyFileChecksums()` queries.
-* Added ticker statistics, "rocksdb.backup.read.bytes" and "rocksdb.backup.write.bytes", reporting how many bytes were read and written during backup.
-* Added properties for BlobDB: `rocksdb.num-blob-files`, `rocksdb.blob-stats`, `rocksdb.total-blob-file-size`, and `rocksdb.live-blob-file-size`. The existing property `rocksdb.estimate_live-data-size` was also extended to include live bytes residing in blob files.
-* Added two new RateLimiter IOPriorities: `Env::IO_USER`,`Env::IO_MID`. `Env::IO_USER` will have superior priority over all other RateLimiter IOPriorities without being subject to fair scheduling constraint.
-* `SstFileWriter` now supports `Put`s and `Delete`s with user-defined timestamps. Note that the ingestion logic itself is not timestamp-aware yet.
-* Allow a single write batch to include keys from multiple column families whose timestamps' formats can differ. For example, some column families may disable timestamp, while others enable timestamp.
-* Add compaction priority information in RemoteCompaction, which can be used to schedule high priority job first.
-* Added new callback APIs `OnBlobFileCreationStarted`,`OnBlobFileCreated`and `OnBlobFileDeleted` in `EventListener` class of listener.h. It notifies listeners during creation/deletion of individual blob files in Integrated BlobDB. It also log blob file creation finished event and deletion event in LOG file.
-* Batch blob read requests for `DB::MultiGet` using `MultiRead`.
-* Add support for fallback to local compaction, the user can return `CompactionServiceJobStatus::kUseLocal` to instruct RocksDB to run the compaction locally instead of waiting for the remote compaction result.
-* Add built-in rate limiter's implementation of `RateLimiter::GetTotalPendingRequest(int64_t* total_pending_requests, const Env::IOPriority pri)` for the total number of requests that are pending for bytes in the rate limiter.
-* Charge memory usage during data buffering, from which training samples are gathered for dictionary compression, to block cache. Unbuffering data can now be triggered if the block cache becomes full and `strict_capacity_limit=true` for the block cache, in addition to existing conditions that can trigger unbuffering.
-
-### Public API change
-* Remove obsolete implementation details FullKey and ParseFullKey from public API
-* Change `SstFileMetaData::size` from `size_t` to `uint64_t`.
-* Made Statistics extend the Customizable class and added a CreateFromString method.  Implementations of Statistics need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method.
-* Extended `FlushJobInfo` and `CompactionJobInfo` in listener.h to provide information about the blob files generated by a flush/compaction and garbage collected during compaction in Integrated BlobDB. Added struct members `blob_file_addition_infos` and `blob_file_garbage_infos` that contain this information.
-* Extended parameter `output_file_names` of `CompactFiles` API to also include paths of the blob files generated by the compaction in Integrated BlobDB.
-* Most `BackupEngine` functions now return `IOStatus` instead of `Status`. Most existing code should be compatible with this change but some calls might need to be updated.
-
-## 6.24.0 (2021-08-20)
-### Bug Fixes
-* If the primary's CURRENT file is missing or inaccessible, the secondary instance should not hang repeatedly trying to switch to a new MANIFEST. It should instead return the error code encountered while accessing the file.
-* Restoring backups with BackupEngine is now a logically atomic operation, so that if a restore operation is interrupted, DB::Open on it will fail. Using BackupEngineOptions::sync (default) ensures atomicity even in case of power loss or OS crash.
-* Fixed a race related to the destruction of `ColumnFamilyData` objects. The earlier logic unlocked the DB mutex before destroying the thread-local `SuperVersion` pointers, which could result in a process crash if another thread managed to get a reference to the `ColumnFamilyData` object.
-* Removed a call to `RenameFile()` on a non-existent info log file ("LOG") when opening a new DB. Such a call was guaranteed to fail though did not impact applications since we swallowed the error. Now we also stopped swallowing errors in renaming "LOG" file.
-* Fixed an issue where `OnFlushCompleted` was not called for atomic flush.
-* Fixed a bug affecting the batched `MultiGet` API when used with keys spanning multiple column families and `sorted_input == false`.
-* Fixed a potential incorrect result in opt mode and assertion failures caused by releasing snapshot(s) during compaction.
-* Fixed passing of BlobFileCompletionCallback to Compaction job and Atomic flush job which was default paramter (nullptr). BlobFileCompletitionCallback is internal callback that manages addition of blob files to SSTFileManager.
-* Fixed MultiGet not updating the block_read_count and block_read_byte PerfContext counters.
-
-### New Features
-* Made the EventListener extend the Customizable class.
-* EventListeners that have a non-empty Name() and that are registered with the ObjectRegistry can now be serialized to/from the OPTIONS file.
-* Insert warm blocks (data blocks, uncompressed dict blocks, index and filter blocks) in Block cache during flush under option BlockBasedTableOptions.prepopulate_block_cache. Previously it was enabled for only data blocks.
-* BlockBasedTableOptions.prepopulate_block_cache can be dynamically configured using DB::SetOptions.
-* Add CompactionOptionsFIFO.age_for_warm, which allows RocksDB to move old files to warm tier in FIFO compactions. Note that file temperature is still an experimental feature.
-* Add a comment to suggest btrfs user to disable file preallocation by setting `options.allow_fallocate=false`.
-* Fast forward option in Trace replay changed to double type to allow replaying at a lower speed, by settings the value between 0 and 1. This option can be set via `ReplayOptions` in `Replayer::Replay()`, or via `--trace_replay_fast_forward` in db_bench.
-* Add property `LiveSstFilesSizeAtTemperature` to retrieve sst file size at different temperature.
-* Added a stat rocksdb.secondary.cache.hits.
-* Added a PerfContext counter secondary_cache_hit_count.
-* The integrated BlobDB implementation now supports the tickers `BLOB_DB_BLOB_FILE_BYTES_READ`, `BLOB_DB_GC_NUM_KEYS_RELOCATED`, and `BLOB_DB_GC_BYTES_RELOCATED`, as well as the histograms `BLOB_DB_COMPRESSION_MICROS` and `BLOB_DB_DECOMPRESSION_MICROS`.
-* Added hybrid configuration of Ribbon filter and Bloom filter where some LSM levels use Ribbon for memory space efficiency and some use Bloom for speed. See NewRibbonFilterPolicy. This also changes the default behavior of NewRibbonFilterPolicy to use Bloom for flushes under Leveled and Universal compaction and Ribbon otherwise. The C API function `rocksdb_filterpolicy_create_ribbon` is unchanged but adds new `rocksdb_filterpolicy_create_ribbon_hybrid`.
-
-### Public API change
-* Added APIs to decode and replay trace file via Replayer class. Added `DB::NewDefaultReplayer()` to create a default Replayer instance. Added `TraceReader::Reset()` to restart reading a trace file. Created trace_record.h, trace_record_result.h and utilities/replayer.h files to access the decoded Trace records, replay them, and query the actual operation results.
-* Added Configurable::GetOptionsMap to the public API for use in creating new Customizable classes.
-* Generalized bits_per_key parameters in C API from int to double for greater configurability. Although this is a compatible change for existing C source code, anything depending on C API signatures, such as foreign function interfaces, will need to be updated.
-
-### Performance Improvements
-* Try to avoid updating DBOptions if `SetDBOptions()` does not change any option value.
-
-### Behavior Changes
-* `StringAppendOperator` additionally accepts a string as the delimiter.
-* BackupEngineOptions::sync (default true) now applies to restoring backups in addition to creating backups. This could slow down restores, but ensures they are fully persisted before returning OK. (Consider increasing max_background_operations to improve performance.)
-
-## 6.23.0 (2021-07-16)
-### Behavior Changes
-* Obsolete keys in the bottommost level that were preserved for a snapshot will now be cleaned upon snapshot release in all cases. This form of compaction (snapshot release triggered compaction) previously had an artificial limitation that multiple tombstones needed to be present.
-### Bug Fixes
-* Blob file checksums are now printed in hexadecimal format when using the `manifest_dump` `ldb` command.
-* `GetLiveFilesMetaData()` now populates the `temperature`, `oldest_ancester_time`, and `file_creation_time` fields of its `LiveFileMetaData` results when the information is available. Previously these fields always contained zero indicating unknown.
-* Fix mismatches of OnCompaction{Begin,Completed} in case of DisableManualCompaction().
-* Fix continuous logging of an existing background error on every user write
-* Fix a bug that `Get()` return Status::OK() and an empty value for non-existent key when `read_options.read_tier = kBlockCacheTier`.
-* Fix a bug that stat in `get_context` didn't accumulate to statistics when query is failed.
-* Fixed handling of DBOptions::wal_dir with LoadLatestOptions() or ldb --try_load_options on a copied or moved DB. Previously, when the WAL directory is same as DB directory (default), a copied or moved DB would reference the old path of the DB as the WAL directory, potentially corrupting both copies. Under this change, the wal_dir from DB::GetOptions() or LoadLatestOptions() may now be empty, indicating that the current DB directory is used for WALs. This is also a subtle API change.
-
-### New Features
-* ldb has a new feature, `list_live_files_metadata`, that shows the live SST files, as well as their LSM storage level and the column family they belong to.
-* The new BlobDB implementation now tracks the amount of garbage in each blob file in the MANIFEST.
-* Integrated BlobDB now supports Merge with base values (Put/Delete etc.).
-* RemoteCompaction supports sub-compaction, the job_id in the user interface is changed from `int` to `uint64_t` to support sub-compaction id.
-* Expose statistics option in RemoteCompaction worker.
-
-### Public API change
-* Added APIs to the Customizable class to allow developers to create their own Customizable classes.  Created the utilities/customizable_util.h file to contain helper methods for developing new Customizable classes.
-* Change signature of SecondaryCache::Name().  Make SecondaryCache customizable and add SecondaryCache::CreateFromString method.
-
-## 6.22.0 (2021-06-18)
-### Behavior Changes
-* Added two additional tickers, MEMTABLE_PAYLOAD_BYTES_AT_FLUSH and MEMTABLE_GARBAGE_BYTES_AT_FLUSH. These stats can be used to estimate the ratio of "garbage" (outdated) bytes in the memtable that are discarded at flush time.
-* Added API comments clarifying safe usage of Disable/EnableManualCompaction and EventListener callbacks for compaction.
-### Bug Fixes
-* fs_posix.cc GetFreeSpace() always report disk space available to root even when running as non-root.  Linux defaults often have disk mounts with 5 to 10 percent of total space reserved only for root.  Out of space could result for non-root users.
-* Subcompactions are now disabled when user-defined timestamps are used, since the subcompaction boundary picking logic is currently not timestamp-aware, which could lead to incorrect results when different subcompactions process keys that only differ by timestamp.
-* Fix an issue that `DeleteFilesInRange()` may cause ongoing compaction reports corruption exception, or ASSERT for debug build. There's no actual data loss or corruption that we find.
-* Fixed confusingly duplicated output in LOG for periodic stats ("DUMPING STATS"), including "Compaction Stats" and "File Read Latency Histogram By Level".
-* Fixed performance bugs in background gathering of block cache entry statistics, that could consume a lot of CPU when there are many column families with a shared block cache.
-
-### New Features
-* Marked the Ribbon filter and optimize_filters_for_memory features as production-ready, each enabling memory savings for Bloom-like filters. Use `NewRibbonFilterPolicy` in place of `NewBloomFilterPolicy` to use Ribbon filters instead of Bloom, or `ribbonfilter` in place of `bloomfilter` in configuration string.
-* Allow `DBWithTTL` to use `DeleteRange` api just like other DBs. `DeleteRangeCF()` which executes `WriteBatchInternal::DeleteRange()` has been added to the handler in `DBWithTTLImpl::Write()` to implement it.
-* Add BlockBasedTableOptions.prepopulate_block_cache.  If enabled, it prepopulate warm/hot data blocks which are already in memory into block cache at the time of flush. On a flush, the data block that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this data back into memory again, which is avoided by enabling this option and it also helps with Distributed FileSystem. More details in include/rocksdb/table.h.
-* Added a `cancel` field to `CompactRangeOptions`, allowing individual in-process manual range compactions to be cancelled.
-
-### New Features
-* Added BlobMetaData to the ColumnFamilyMetaData to return information about blob files
-
-### Public API change
-* Added GetAllColumnFamilyMetaData API to retrieve the ColumnFamilyMetaData about all column families.
+* Fixed a performance bug in background gathering of block cache entry statistics, that could consume a lot of CPU when there are many column families with a shared block cache.

 ## 6.21.0 (2021-05-21)
 ### Bug Fixes
@@ -1,6 +1,6 @@
 This is the list of all known third-party language bindings for RocksDB. If something is missing, please open a pull request to add it.

-* Java - https://github.com/facebook/rocksdb/tree/main/java
+* Java - https://github.com/facebook/rocksdb/tree/master/java
 * Python
    * http://python-rocksdb.readthedocs.io/en/latest/
    * http://pyrocksdb.readthedocs.org/en/latest/ (unmaintained)
@@ -222,7 +222,6 @@ am__v_AR_1 =

 ifdef ROCKSDB_USE_LIBRADOS
 LIB_SOURCES += utilities/env_librados.cc
-TEST_MAIN_SOURCES += utilities/env_librados_test.cc
 LDFLAGS += -lrados
 endif

@@ -345,12 +344,6 @@ ifdef ROCKSDB_VALGRIND_RUN
 	PLATFORM_CCFLAGS += -DROCKSDB_VALGRIND_RUN
 	PLATFORM_CXXFLAGS += -DROCKSDB_VALGRIND_RUN
 endif
-ifdef ROCKSDB_FULL_VALGRIND_RUN
-	# Some tests are slow when run under valgrind and are only run when
-	# explicitly requested via the ROCKSDB_FULL_VALGRIND_RUN compiler flag.
-	PLATFORM_CCFLAGS += -DROCKSDB_VALGRIND_RUN -DROCKSDB_FULL_VALGRIND_RUN
-	PLATFORM_CXXFLAGS += -DROCKSDB_VALGRIND_RUN -DROCKSDB_FULL_VALGRIND_RUN
-endif

 ifndef DISABLE_JEMALLOC
 	ifdef JEMALLOC
@@ -495,7 +488,6 @@ VALGRIND_ERROR = 2
 VALGRIND_VER := $(join $(VALGRIND_VER),valgrind)

 VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full
-# Not yet supported: --show-leak-kinds=definite,possible,reachable --errors-for-leak-kinds=definite,possible,reachable

 TEST_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(TEST_LIB_SOURCES) $(MOCK_LIB_SOURCES)) $(GTEST)
 BENCH_OBJECTS = $(patsubst %.cc, $(OBJ_DIR)/%.o, $(BENCH_LIB_SOURCES))
@@ -517,29 +509,6 @@ ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
 	ALL_SOURCES += third-party/folly/folly/synchronization/test/DistributedMutexTest.cc
 endif

-# `make check-headers` to very that each header file includes its own
-# dependencies
-ifneq ($(filter check-headers, $(MAKECMDGOALS)),)
-# TODO: add/support JNI headers
-	DEV_HEADER_DIRS := $(sort include/ hdfs/ $(dir $(ALL_SOURCES)))
-# Some headers like in port/ are platform-specific
-	DEV_HEADERS := $(shell $(FIND) $(DEV_HEADER_DIRS) -type f -name '*.h' | egrep -v 'port/|plugin/|lua/|range_tree/|tools/rdb/db_wrapper.h|include/rocksdb/utilities/env_librados.h')
-else
-	DEV_HEADERS :=
-endif
-HEADER_OK_FILES = $(patsubst %.h, %.h.ok, $(DEV_HEADERS))
-
-AM_V_CCH = $(am__v_CCH_$(V))
-am__v_CCH_ = $(am__v_CCH_$(AM_DEFAULT_VERBOSITY))
-am__v_CCH_0 = @echo "  CC.h    " $<;
-am__v_CCH_1 =
-
-%.h.ok: %.h # .h.ok not actually created, so re-checked on each invocation
-# -DROCKSDB_NAMESPACE=42 ensures the namespace header is included
-	$(AM_V_CCH) echo '#include "$<"' | $(CXX) $(CXXFLAGS) -DROCKSDB_NAMESPACE=42 -x c++ -c - -o /dev/null
-
-check-headers: $(HEADER_OK_FILES)
-
 # options_settable_test doesn't pass with UBSAN as we use hack in the test
 ifdef COMPILE_WITH_UBSAN
        TESTS := $(shell echo $(TESTS) | sed 's/\boptions_settable_test\b//g')
@@ -547,9 +516,8 @@ endif
 ifdef ASSERT_STATUS_CHECKED
 	# TODO: finish fixing all tests to pass this check
 	TESTS_FAILING_ASC = \
-		c_test \
 		db_test \
-		env_test \
+		db_test2 \
 		range_locking_test \
 		testutil_test \

@@ -625,8 +593,6 @@ TEST_LIBS = \
 # TODO: add back forward_iterator_bench, after making it build in all environemnts.
 BENCHMARKS = $(patsubst %.cc, %, $(notdir $(BENCH_MAIN_SOURCES)))

-MICROBENCHS = $(patsubst %.cc, %, $(notdir $(MICROBENCH_SOURCES)))
-
 # if user didn't config LIBNAME, set the default
 ifeq ($(LIBNAME),)
  LIBNAME=librocksdb
@@ -740,7 +706,7 @@ endif  # PLATFORM_SHARED_EXT
 .PHONY: blackbox_crash_test check clean coverage crash_test ldb_tests package \
 	release tags tags0 valgrind_check whitebox_crash_test format static_lib shared_lib all \
 	dbg rocksdbjavastatic rocksdbjava gen-pc install install-static install-shared uninstall \
-	analyze tools tools_lib check-headers \
+	analyze tools tools_lib \
 	blackbox_crash_test_with_atomic_flush whitebox_crash_test_with_atomic_flush  \
 	blackbox_crash_test_with_txn whitebox_crash_test_with_txn \
 	blackbox_crash_test_with_best_efforts_recovery \
@@ -765,9 +731,6 @@ test_libs: $(TEST_LIBS)

 benchmarks: $(BENCHMARKS)

-microbench: $(MICROBENCHS)
-	for t in $(MICROBENCHS); do echo "===== Running benchmark $$t (`date`)"; ./$$t || exit 1; done;
-
 dbg: $(LIBRARY) $(BENCHMARKS) tools $(TESTS)

 # creates library and programs
@@ -967,7 +930,6 @@ endif
 ifndef SKIP_FORMAT_BUCK_CHECKS
 	$(MAKE) check-format
 	$(MAKE) check-buck-targets
-	$(MAKE) check-sources
 endif

 # TODO add ldb_tests
@@ -1082,12 +1044,6 @@ ubsan_crash_test_with_best_efforts_recovery: clean
 	COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_best_efforts_recovery
 	$(MAKE) clean

-full_valgrind_test:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
-
-full_valgrind_test_some:
-	ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some
-
 valgrind_test:
 	ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

@@ -1206,7 +1162,7 @@ clean-not-downloaded: clean-ext-libraries-bin clean-rocks clean-not-downloaded-r
 clean-rocks:
 	echo shared=$(ALL_SHARED_LIBS)
 	echo static=$(ALL_STATIC_LIBS)
-	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(PARALLEL_TEST) $(ALL_STATIC_LIBS) $(ALL_SHARED_LIBS) $(MICROBENCHS)
+	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(PARALLEL_TEST) $(ALL_STATIC_LIBS) $(ALL_SHARED_LIBS)
 	rm -rf $(CLEAN_FILES) ios-x86 ios-arm scan_build_report
 	$(FIND) . -name "*.[oda]" -exec rm -f {} \;
 	$(FIND) . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm -f {} \;
@@ -1245,9 +1201,6 @@ check-format:
 check-buck-targets:
 	buckifier/check_buck_targets.sh

-check-sources:
-	build_tools/check-sources.sh
-
 package:
 	bash build_tools/make_package.sh $(SHARED_MAJOR).$(SHARED_MINOR)

@@ -1872,9 +1825,6 @@ block_cache_trace_analyzer_test: $(OBJ_DIR)/tools/block_cache_analyzer/block_cac
 defer_test: $(OBJ_DIR)/util/defer_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

-blob_counting_iterator_test: $(OBJ_DIR)/db/blob/blob_counting_iterator_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 blob_file_addition_test: $(OBJ_DIR)/db/blob/blob_file_addition_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

@@ -1890,9 +1840,6 @@ blob_file_garbage_test: $(OBJ_DIR)/db/blob/blob_file_garbage_test.o $(TEST_LIBRA
 blob_file_reader_test: $(OBJ_DIR)/db/blob/blob_file_reader_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

-blob_garbage_meter_test: $(OBJ_DIR)/db/blob/blob_garbage_meter_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
 timer_test: $(OBJ_DIR)/util/timer_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

@@ -1919,15 +1866,6 @@ db_blob_corruption_test: $(OBJ_DIR)/db/blob/db_blob_corruption_test.o $(TEST_LIB

 db_write_buffer_manager_test: $(OBJ_DIR)/db/db_write_buffer_manager_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
-
-clipping_iterator_test: $(OBJ_DIR)/db/compaction/clipping_iterator_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
-
-ribbon_bench: $(OBJ_DIR)/microbench/ribbon_bench.o $(LIBRARY)
-	$(AM_LINK)
-
-cache_reservation_manager_test: $(OBJ_DIR)/cache/cache_reservation_manager_test.o $(TEST_LIBRARY) $(LIBRARY)
-	$(AM_LINK)
 #-------------------------------------------------
 # make install related stuff
 PREFIX ?= /usr/local
@@ -2392,7 +2330,7 @@ build_subset_tests: $(ROCKSDBTESTS_SUBSET)

 # Remove the rules for which dependencies should not be generated and see if any are left.
 #If so, include the dependencies; if not, do not include the dependency files
-ROCKS_DEP_RULES=$(filter-out clean format check-format check-buck-targets check-headers check-sources jclean jtest package analyze tags rocksdbjavastatic% unity.% unity_test, $(MAKECMDGOALS))
+ROCKS_DEP_RULES=$(filter-out clean format check-format check-buck-targets jclean jtest package analyze tags rocksdbjavastatic% unity.% unity_test, $(MAKECMDGOALS))
 ifneq ("$(ROCKS_DEP_RULES)", "")
 -include $(DEPFILES)
 endif
@@ -1,8 +1,8 @@
 ## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage

 [![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
-[![TravisCI Status](https://api.travis-ci.com/facebook/rocksdb.svg?branch=main)](https://travis-ci.com/github/facebook/rocksdb)
-[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/main?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/main)
+[![TravisCI Status](https://travis-ci.org/facebook/rocksdb.svg?branch=master)](https://travis-ci.org/facebook/rocksdb)
+[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/master?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/master)
 [![PPC64le Build Status](http://140-211-168-68-openstack.osuosl.org:8080/buildStatus/icon?job=rocksdb&style=plastic)](http://140-211-168-68-openstack.osuosl.org:8080/job/rocksdb)

 RocksDB is developed and maintained by Facebook Database Engineering Team.
@@ -17,7 +17,7 @@ and Space-Amplification-Factor (SAF). It has multi-threaded compactions,
 making it especially suitable for storing multiple terabytes of data in a
 single database.

-Start with example usage here: https://github.com/facebook/rocksdb/tree/main/examples
+Start with example usage here: https://github.com/facebook/rocksdb/tree/master/examples

 See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation.

@@ -133,19 +133,16 @@ cpp_library(
    srcs = [
        "cache/cache.cc",
        "cache/cache_entry_roles.cc",
-        "cache/cache_reservation_manager.cc",
        "cache/clock_cache.cc",
        "cache/lru_cache.cc",
        "cache/sharded_cache.cc",
        "db/arena_wrapped_db_iter.cc",
-        "db/blob/blob_fetcher.cc",
        "db/blob/blob_file_addition.cc",
        "db/blob/blob_file_builder.cc",
        "db/blob/blob_file_cache.cc",
        "db/blob/blob_file_garbage.cc",
        "db/blob/blob_file_meta.cc",
        "db/blob/blob_file_reader.cc",
-        "db/blob/blob_garbage_meter.cc",
        "db/blob/blob_log_format.cc",
        "db/blob/blob_log_sequential_reader.cc",
        "db/blob/blob_log_writer.cc",
@@ -225,7 +222,6 @@ cpp_library(
        "env/fs_remap.cc",
        "env/io_posix.cc",
        "env/mock_env.cc",
-        "env/unique_id.cc",
        "file/delete_scheduler.cc",
        "file/file_prefetch_buffer.cc",
        "file/file_util.cc",
@@ -337,9 +333,6 @@ cpp_library(
        "tools/sst_dump_tool.cc",
        "trace_replay/block_cache_tracer.cc",
        "trace_replay/io_tracer.cc",
-        "trace_replay/trace_record.cc",
-        "trace_replay/trace_record_handler.cc",
-        "trace_replay/trace_record_result.cc",
        "trace_replay/trace_replay.cc",
        "util/build_version.cc",
        "util/coding.cc",
@@ -355,7 +348,6 @@ cpp_library(
        "util/murmurhash.cc",
        "util/random.cc",
        "util/rate_limiter.cc",
-        "util/regex.cc",
        "util/ribbon_config.cc",
        "util/slice.cc",
        "util/status.cc",
@@ -374,7 +366,6 @@ cpp_library(
        "utilities/cassandra/format.cc",
        "utilities/cassandra/merge_operator.cc",
        "utilities/checkpoint/checkpoint_impl.cc",
-        "utilities/compaction_filters.cc",
        "utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",
        "utilities/convenience/info_log_finder.cc",
        "utilities/debug.cc",
@@ -384,7 +375,6 @@ cpp_library(
        "utilities/fault_injection_fs.cc",
        "utilities/leveldb_options/leveldb_options.cc",
        "utilities/memory/memory_util.cc",
-        "utilities/merge_operators.cc",
        "utilities/merge_operators/bytesxor.cc",
        "utilities/merge_operators/max.cc",
        "utilities/merge_operators/put.cc",
@@ -404,7 +394,6 @@ cpp_library(
        "utilities/simulator_cache/sim_cache.cc",
        "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
        "utilities/trace/file_trace_reader_writer.cc",
-        "utilities/trace/replayer_impl.cc",
        "utilities/transactions/lock/lock_manager.cc",
        "utilities/transactions/lock/point/point_lock_manager.cc",
        "utilities/transactions/lock/point/point_lock_tracker.cc",
@@ -455,19 +444,16 @@ cpp_library(
    srcs = [
        "cache/cache.cc",
        "cache/cache_entry_roles.cc",
-        "cache/cache_reservation_manager.cc",
        "cache/clock_cache.cc",
        "cache/lru_cache.cc",
        "cache/sharded_cache.cc",
        "db/arena_wrapped_db_iter.cc",
-        "db/blob/blob_fetcher.cc",
        "db/blob/blob_file_addition.cc",
        "db/blob/blob_file_builder.cc",
        "db/blob/blob_file_cache.cc",
        "db/blob/blob_file_garbage.cc",
        "db/blob/blob_file_meta.cc",
        "db/blob/blob_file_reader.cc",
-        "db/blob/blob_garbage_meter.cc",
        "db/blob/blob_log_format.cc",
        "db/blob/blob_log_sequential_reader.cc",
        "db/blob/blob_log_writer.cc",
@@ -547,7 +533,6 @@ cpp_library(
        "env/fs_remap.cc",
        "env/io_posix.cc",
        "env/mock_env.cc",
-        "env/unique_id.cc",
        "file/delete_scheduler.cc",
        "file/file_prefetch_buffer.cc",
        "file/file_util.cc",
@@ -659,9 +644,6 @@ cpp_library(
        "tools/sst_dump_tool.cc",
        "trace_replay/block_cache_tracer.cc",
        "trace_replay/io_tracer.cc",
-        "trace_replay/trace_record.cc",
-        "trace_replay/trace_record_handler.cc",
-        "trace_replay/trace_record_result.cc",
        "trace_replay/trace_replay.cc",
        "util/build_version.cc",
        "util/coding.cc",
@@ -677,7 +659,6 @@ cpp_library(
        "util/murmurhash.cc",
        "util/random.cc",
        "util/rate_limiter.cc",
-        "util/regex.cc",
        "util/ribbon_config.cc",
        "util/slice.cc",
        "util/status.cc",
@@ -696,7 +677,6 @@ cpp_library(
        "utilities/cassandra/format.cc",
        "utilities/cassandra/merge_operator.cc",
        "utilities/checkpoint/checkpoint_impl.cc",
-        "utilities/compaction_filters.cc",
        "utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc",
        "utilities/convenience/info_log_finder.cc",
        "utilities/debug.cc",
@@ -706,7 +686,6 @@ cpp_library(
        "utilities/fault_injection_fs.cc",
        "utilities/leveldb_options/leveldb_options.cc",
        "utilities/memory/memory_util.cc",
-        "utilities/merge_operators.cc",
        "utilities/merge_operators/bytesxor.cc",
        "utilities/merge_operators/max.cc",
        "utilities/merge_operators/put.cc",
@@ -726,7 +705,6 @@ cpp_library(
        "utilities/simulator_cache/sim_cache.cc",
        "utilities/table_properties_collectors/compact_on_deletion_collector.cc",
        "utilities/trace/file_trace_reader_writer.cc",
-        "utilities/trace/replayer_impl.cc",
        "utilities/transactions/lock/lock_manager.cc",
        "utilities/transactions/lock/point/point_lock_manager.cc",
        "utilities/transactions/lock/point/point_lock_tracker.cc",
@@ -926,13 +904,6 @@ ROCKS_TESTS = [
        [],
        [],
    ],
-    [
-        "blob_counting_iterator_test",
-        "db/blob/blob_counting_iterator_test.cc",
-        "parallel",
-        [],
-        [],
-    ],
    [
        "blob_db_test",
        "utilities/blob_db/blob_db_test.cc",
@@ -975,13 +946,6 @@ ROCKS_TESTS = [
        [],
        [],
    ],
-    [
-        "blob_garbage_meter_test",
-        "db/blob/blob_garbage_meter_test.cc",
-        "parallel",
-        [],
-        [],
-    ],
    [
        "block_based_filter_block_test",
        "table/block_based/block_based_filter_block_test.cc",
@@ -1031,13 +995,6 @@ ROCKS_TESTS = [
        [],
        [],
    ],
-    [
-        "cache_reservation_manager_test",
-        "cache/cache_reservation_manager_test.cc",
-        "parallel",
-        [],
-        [],
-    ],
    [
        "cache_simulator_test",
        "utilities/simulator_cache/cache_simulator_test.cc",
@@ -1094,13 +1051,6 @@ ROCKS_TESTS = [
        [],
        [],
    ],
-    [
-        "clipping_iterator_test",
-        "db/compaction/clipping_iterator_test.cc",
-        "parallel",
-        [],
-        [],
-    ],
    [
        "coding_test",
        "util/coding_test.cc",
@@ -115,12 +115,3 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed
 ## ArangoDB
 [ArangoDB](https://www.arangodb.com/) is a native multi-model database with flexible data models for documents, graphs, and key-values, for building high performance applications using a convenient SQL-like query language or JavaScript extensions. It uses RocksDB as its sotrage engine.

-## Milvus
-[Milvus](https://milvus.io/) is an open source vector database for unstructured data. It uses RocksDB not only as one of the supported kv storage engines, but also as a message queue.
-
-## Kafka
-[Kafka](https://kafka.apache.org/) is an open-source distributed event streaming platform, it uses RocksDB to store state in Kafka Streams: https://www.confluent.io/blog/how-to-tune-rocksdb-kafka-streams-state-stores-performance/.
-
-## Others
-More databases using RocksDB can be found at [dbdb.io](https://dbdb.io/browse?embeds=rocksdb).
-
@@ -24,7 +24,7 @@ We strive to achieve the following goals:
 * make all unit test pass both in debug and release builds. 
  * Note: latest introduction of SyncPoint seems to disable running db_test in Release.
 * make performance on par with published benchmarks accounting for HW differences
-* we would like to keep the port code inline with the main branch with no forking
+* we would like to keep the port code inline with the master branch with no forking

 ## Build system
 We have chosen CMake as a widely accepted build system to build the Windows port. It is very fast and convenient. 
@@ -66,7 +66,7 @@ We endeavored to make it functionally on par with posix_env. This means we repli
 Even though Windows provides its own efficient thread-pool implementation we chose to replicate posix logic using `std::thread` primitives. This allows anyone to quickly detect any changes within the posix source code and replicate them within windows env. This has proven to work very well. At the same time for anyone who wishes to replace the built-in thread-pool can do so using RocksDB stackable environments.

 For disk access we implemented all of the functionality present within the posix_env which includes memory mapped files, random access, rate-limiter support etc.
-The `use_os_buffer` flag on Posix platforms currently denotes disabling read-ahead log via `fadvise` mechanism. Windows does not have `fadvise` system call. What is more, it implements disk cache in a way that differs from Linux greatly. It's not an uncommon practice on Windows to perform un-buffered disk access to gain control of the memory consumption. We think that in our use case this may also be a good configuration option at the expense of disk throughput. To compensate one may increase the configured in-memory cache size instead. Thus we have chosen  `use_os_buffer=false` to disable OS disk buffering for `WinWritableFile` and `WinRandomAccessFile`. The OS imposes restrictions on the alignment of the disk offsets, buffers used and the amount of data that is read/written when accessing files in un-buffered mode. When the option is true, the classes behave in a standard way. This allows to perform writes and reads in cases when un-buffered access does not make sense such as WAL and MANIFEST.
+The `use_os_buffer` flag on Posix platforms currently denotes disabling read-ahead log via `fadvise` mechanism. Windows does not have `fadvise` system call. What is more, it implements disk cache in a way that differs from Linux greatly. It’s not an uncommon practice on Windows to perform un-buffered disk access to gain control of the memory consumption. We think that in our use case this may also be a good configuration option at the expense of disk throughput. To compensate one may increase the configured in-memory cache size instead. Thus we have chosen  `use_os_buffer=false` to disable OS disk buffering for `WinWritableFile` and `WinRandomAccessFile`. The OS imposes restrictions on the alignment of the disk offsets, buffers used and the amount of data that is read/written when accessing files in un-buffered mode. When the option is true, the classes behave in a standard way. This allows to perform writes and reads in cases when un-buffered access does not make sense such as WAL and MANIFEST.

 We have replaced `pread/pwrite` with `WriteFile/ReadFile` with `OVERLAPPED` structure so we can atomically seek to the position of the disk operation but still perform the operation synchronously. Thus we able to emulate that functionality of `pread/pwrite` reasonably well. The only difference is that the file pointer is not returned to its original position but that hardly matters given the random nature of access.

@@ -189,6 +189,9 @@ EOF
                COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
            fi
        fi
+        if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
+          USE_FOLLY_DISTRIBUTED_MUTEX=1
+        fi
        # PORT_FILES=port/linux/linux_specific.cc
        ;;
    SunOS)
@@ -593,16 +596,6 @@ EOF
            PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS -faligned-new -DHAVE_ALIGNED_NEW"
        fi
    fi
-    if ! test $ROCKSDB_DISABLE_BENCHMARK; then
-        # Test whether google benchmark is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lbenchmark 2>/dev/null  <<EOF
-          #include <benchmark/benchmark.h>
-          int main() {}
-EOF
-        if [ "$?" = 0 ]; then
-            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbenchmark"
-        fi
-    fi
 fi

 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
@@ -1,28 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-#
-# Check for some simple mistakes that should prevent commit or push
-
-BAD=""
-
-git grep 'namespace rocksdb' -- '*.[ch]*'
-if [ "$?" != "1" ]; then
-  echo "^^^^^ Do not hardcode namespace rocksdb. Use ROCKSDB_NAMESPACE"
-  BAD=1
-fi
-
-git grep -i 'nocommit' -- ':!build_tools/check-sources.sh'
-if [ "$?" != "1" ]; then
-  echo "^^^^^ Code was not intended to be committed"
-  BAD=1
-fi
-
-git grep '<rocksdb/' -- ':!build_tools/check-sources.sh'
-if [ "$?" != "1" ]; then
-  echo '^^^^^ Use double-quotes as in #include "rocksdb/something.h"'
-  BAD=1
-fi
-
-if [ "$BAD" ]; then
-  exit 1
-fi
@@ -167,4 +167,6 @@ VALGRIND_VER="$VALGRIND_BASE/bin/"
 LUA_PATH=
 LUA_LIB=

+USE_FOLLY_DISTRIBUTED_MUTEX=1
+
 export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -102,7 +102,6 @@ export PORTABLE

 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
-AS="$BINUTILS/as"

 DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE"

@@ -151,6 +150,7 @@ CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PR
 CXXFLAGS+=" $CFLAGS"

 EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS"
+EXEC_LDFLAGS+=" -B$BINUTILS"
 EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform009/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
 EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform009/lib"
@@ -159,7 +159,6 @@ EXEC_LDFLAGS+=" -Wl,-rpath=$GCC_BASE/lib64"
 EXEC_LDFLAGS+=" -ldl"

 PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
-PLATFORM_LDFLAGS+=" -B$BINUTILS"

 EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS $LIBURING_LIBS"

@@ -169,4 +168,6 @@ VALGRIND_VER="$VALGRIND_BASE/bin/"
 LUA_PATH=
 LUA_LIB=

-export CC CXX AR AS CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
+USE_FOLLY_DISTRIBUTED_MUTEX=1
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -120,7 +120,7 @@ uncommitted_code=`git diff HEAD`

 # If there's no uncommitted changes, we assume user are doing post-commit
 # format check, in which case we'll try to check the modified lines vs. the
-# facebook/rocksdb.git main branch. Otherwise, we'll check format of the
+# facebook/rocksdb.git master branch. Otherwise, we'll check format of the
 # uncommitted code only.
 if [ -z "$uncommitted_code" ]
 then
@@ -128,8 +128,8 @@ then
  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(git remote -v | grep 'facebook/rocksdb.git' | head -n 1 | cut -f 1)"
  # Fall back on 'origin' if that fails
  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE=origin
-  # Use main branch from that remote
-  [ "$FORMAT_UPSTREAM" ] || FORMAT_UPSTREAM="$FORMAT_REMOTE/$(git remote show $FORMAT_REMOTE | sed -n '/HEAD branch/s/.*: //p')"
+  # Use master branch from that remote
+  [ "$FORMAT_UPSTREAM" ] || FORMAT_UPSTREAM="$FORMAT_REMOTE/master"
  # Get the common ancestor with that remote branch. Everything after that
  # common ancestor would be considered the contents of a pull request, so
  # should be relevant for formatting fixes.
@@ -20,11 +20,26 @@ STAT_FILE=${STAT_FILE:-$(mktemp -t -u rocksdb_test_stats_XXXX)}

 function cleanup {
  rm -rf $DATA_DIR
-  rm -f $STAT_FILE.*
+  rm -f $STAT_FILE.fillseq
+  rm -f $STAT_FILE.readrandom
+  rm -f $STAT_FILE.overwrite
+  rm -f $STAT_FILE.memtablefillreadrandom
 }

 trap cleanup EXIT

+if [ -z $GIT_BRANCH ]; then
+  git_br=`git rev-parse --abbrev-ref HEAD`
+else
+  git_br=$(basename $GIT_BRANCH)
+fi
+
+if [ $git_br == "master" ]; then
+  git_br=""
+else
+  git_br="."$git_br
+fi
+
 make release

 # measure fillseq + fill up the DB for overwrite benchmark
@@ -271,10 +286,12 @@ common_in_mem_args="--db=/dev/shm/rocksdb \
    --sync=0 \
    --verify_checksum=1 \
    --delete_obsolete_files_period_micros=314572800 \
+    --max_grandparent_overlap_factor=10 \
    --use_plain_table=1 \
    --open_files=-1 \
    --mmap_read=1 \
    --mmap_write=0 \
+    --memtablerep=prefix_hash \
    --bloom_bits=10 \
    --bloom_locality=1 \
    --perf_level=0"
@@ -361,7 +378,7 @@ function send_to_ods {
    echo >&2 "ERROR: Key $key doesn't have a value."
    return
  fi
-  curl --silent "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=$key&value=$value" \
+  curl --silent "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build$git_br&key=$key&value=$value" \
    --connect-timeout 60
 }

@@ -106,14 +106,16 @@ NON_SHM="TMPD=/tmp/rocksdb_test_tmp"
 GCC_481="ROCKSDB_FBCODE_BUILD_WITH_481=1"
 ASAN="COMPILE_WITH_ASAN=1"
 CLANG="USE_CLANG=1"
-TSAN="COMPILE_WITH_TSAN=1"
+# in gcc-5 there are known problems with TSAN like https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71090.
+# using platform007 gives us gcc-8 or higher which has that bug fixed.
+TSAN="ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007=1 COMPILE_WITH_TSAN=1"
 UBSAN="COMPILE_WITH_UBSAN=1"
 TSAN_CRASH='CRASH_TEST_EXT_ARGS="--compression_type=zstd --log2_keys_per_lock=22"'
 NON_TSAN_CRASH="CRASH_TEST_EXT_ARGS=--compression_type=zstd"
 DISABLE_JEMALLOC="DISABLE_JEMALLOC=1"
 HTTP_PROXY="https_proxy=http://fwdproxy.29.prn1:8080 http_proxy=http://fwdproxy.29.prn1:8080 ftp_proxy=http://fwdproxy.29.prn1:8080"
 SETUP_JAVA_ENV="export $HTTP_PROXY; export JAVA_HOME=/usr/local/jdk-8u60-64/; export PATH=\$JAVA_HOME/bin:\$PATH"
-PARSER="'parser':'/usr/bin/env python3 build_tools/error_filter.py $1'"
+PARSER="'parser':'python build_tools/error_filter.py $1'"

 CONTRUN_NAME="ROCKSDB_CONTRUN_NAME"
 SKIP_FORMAT_CHECKS="SKIP_FORMAT_BUCK_CHECKS=1"
@@ -379,6 +381,23 @@ LITE_BUILD_COMMANDS="[
    }
 ]"

+#
+# Report RocksDB lite binary size to scuba
+REPORT_LITE_BINARY_SIZE_COMMANDS="[
+    {
+        'name':'Rocksdb Lite Binary Size',
+        'oncall':'$ONCALL',
+        'executeLocal': 'true',
+        'steps': [
+            $CLEANUP_ENV,
+            {
+                'name':'Report RocksDB Lite binary size to scuba',
+                'shell':'cd $WORKING_DIR; tools/report_lite_binary_size.sh',
+                'user':'root',
+            },
+        ],
+]"
+
 #
 # RocksDB stress/crash test
 #
@@ -571,7 +590,7 @@ WRITE_STRESS_COMMANDS="[
            $CLEANUP_ENV,
            {
                'name':'Build and run RocksDB write stress tests',
-                'shell':'cd $WORKING_DIR; make write_stress && /usr/bin/env python3 tools/write_stress_runner.py --runtime_sec=3600 --db=/tmp/rocksdb_write_stress || $CONTRUN_NAME=write_stress $TASK_CREATION_TOOL',
+                'shell':'cd $WORKING_DIR; make write_stress && python tools/write_stress_runner.py --runtime_sec=3600 --db=/tmp/rocksdb_write_stress || $CONTRUN_NAME=write_stress $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            }
@@ -594,7 +613,7 @@ ASAN_TEST_COMMANDS="[
            $CLEANUP_ENV,
            {
                'name':'Test RocksDB debug under ASAN',
-'shell':'cd $WORKING_DIR; set -o pipefail && $SHM $ASAN $DEBUG $SKIP_FORMAT_CHECKS make $PARALLELISM asan_check || $CONTRUN_NAME=asan_check $TASK_CREATION_TOOL',
+'shell':'cd $WORKING_DIR; set -o pipefail && ($SHM $ASAN $DEBUG $SKIP_FORMAT_CHECKS make $PARALLELISM asan_check || $CONTRUN_NAME=asan_check $TASK_CREATION_TOOL) |& /usr/facebook/ops/scripts/asan_symbolize.py -d',
                'user':'root',
                $PARSER
            }
@@ -1103,7 +1122,7 @@ NO_COMPRESSION_COMMANDS="[
 #
 run_regression()
 {
-  time bash -vx ./build_tools/regression_build_test.sh $(mktemp -d  $WORKING_DIR/rocksdb.XXXX) $(mktemp rocksdb_test_stats.XXXX)
+  time -v bash -vx ./build_tools/regression_build_test.sh $(mktemp -d  $WORKSPACE/leveldb.XXXX) $(mktemp leveldb_test_stats.XXXX)

  # ======= report size to ODS ========

@@ -1144,7 +1163,6 @@ REGRESSION_COMMANDS="[
    {
        'name':'Rocksdb regression commands',
        'oncall':'$ONCALL',
-        'executeLocal': 'true',
        'steps': [
            $CLEANUP_ENV,
            {
@@ -1179,40 +1197,6 @@ JAVA_BUILD_TEST_COMMANDS="[
    }
 ]"

-#
-# RocksDB fbcode stress/crash test
-#
-FBCODE_STRESS_CRASH_TEST_COMMANDS="[
-    {
-        'name':'Rocksdb Fbcode Stress and Crash Test',
-        'oncall':'$ONCALL',
-        'executeLocal': 'true',
-        'timeout': 86400,
-        'steps': [
-            {
-                'name':'Copy RocksDB code to fbcode repo',
-                'shell':'cd internal_repo_rocksdb/repo && git init -b main && git add * && git commit -a -m \"Make internal_repo_rocksdb/repo a git repo\" && cd ../.. && echo Y | python3 rocks/release_script/release_to_fbcode.py -u internal_repo_rocksdb/repo main || $CONTRUN_NAME=db_stress_fbcode $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            {
-                'name':'Build RocksDB fbcode stress tests',
-                'shell':'cd $WORKING_DIR; buck build @mode/dbg rocks/tools:rocks_db_stress || $CONTRUN_NAME=db_stress_fbcode $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-            {
-                'name':'Run RocksDB whitebox crash tests',
-                'timeout': 86400,
-                'shell':'cd $WORKING_DIR; mkdir /dev/shm/rocksdb_whitebox_crash_test && TEST_TMPDIR=\$(mktemp -d --tmpdir=/dev/shm/rocksdb_whitebox_crash_test) python3 rocksdb/src/tools/db_crashtest.py --stress_cmd=buck-out/dbg/gen/rocks/tools/rocks_db_stress -secondary_cache_uri=\"$SECONDARY_CACHE_URI\" --env_uri=$ENV_URI -checkpoint_one_in=0 -backup_one_in=0 -cache_size=134217728 -cache_numshardbits=4 $EXTRA_DB_STRESS_ARGS -logtostderr=false whitebox || $CONTRUN_NAME=db_stress_fbcode $TASK_CREATION_TOOL',
-                'user':'root',
-                $PARSER
-            },
-        ],
-        $REPORT
-    }
-]"
-

 case $1 in
  unit)
@@ -1248,6 +1232,9 @@ case $1 in
  lite)
    echo $LITE_BUILD_COMMANDS
    ;;
+  report_lite_binary_size)
+    echo $REPORT_LITE_BINARY_SIZE_COMMANDS
+    ;;
  stress_crash)
    echo $STRESS_CRASH_TEST_COMMANDS
    ;;
@@ -1342,18 +1329,11 @@ case $1 in
    echo $REGRESSION_COMMANDS
    ;;
  run_regression)
-    set -e
    run_regression
-    set +e
    ;;
  java_build)
    echo $JAVA_BUILD_TEST_COMMANDS
    ;;
-  fbcode_stress_crash)
-    set -f
-    echo $FBCODE_STRESS_CRASH_TEST_COMMANDS
-    set +f
-    ;;
  *)
    echo "Invalid determinator command"
    exit 1
@@ -10,8 +10,6 @@
 #include "rocksdb/cache.h"

 #include "cache/lru_cache.h"
-#include "rocksdb/secondary_cache.h"
-#include "rocksdb/utilities/customizable_util.h"
 #include "rocksdb/utilities/options_type.h"
 #include "util/string_util.h"

@@ -36,13 +34,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
 };
 #endif  // ROCKSDB_LITE

-Status SecondaryCache::CreateFromString(
-    const ConfigOptions& config_options, const std::string& value,
-    std::shared_ptr<SecondaryCache>* result) {
-  return LoadSharedObject<SecondaryCache>(config_options, value, nullptr,
-                                          result);
-}
-
 Status Cache::CreateFromString(const ConfigOptions& config_options,
                               const std::string& value,
                               std::shared_ptr<Cache>* result) {
@@ -13,7 +13,7 @@ int main() {
  return 1;
 }
 #else
-#include "rocksdb/cache_bench_tool.h"
+#include <rocksdb/cache_bench_tool.h>
 int main(int argc, char** argv) {
  return ROCKSDB_NAMESPACE::cache_bench_tool(argc, argv);
 }
@@ -13,11 +13,11 @@
 #include "monitoring/histogram.h"
 #include "port/port.h"
 #include "rocksdb/cache.h"
-#include "rocksdb/convenience.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/secondary_cache.h"
 #include "rocksdb/system_clock.h"
+#include "rocksdb/utilities/object_registry.h"
 #include "table/block_based/cachable_entry.h"
 #include "util/coding.h"
 #include "util/gflags_compat.h"
@@ -233,8 +233,9 @@ class CacheBench {
      LRUCacheOptions opts(FLAGS_cache_size, FLAGS_num_shard_bits, false, 0.5);
 #ifndef ROCKSDB_LITE
      if (!FLAGS_secondary_cache_uri.empty()) {
-        Status s = SecondaryCache::CreateFromString(
-            ConfigOptions(), FLAGS_secondary_cache_uri, &secondary_cache);
+        Status s =
+            ObjectRegistry::NewInstance()->NewSharedObject<SecondaryCache>(
+                FLAGS_secondary_cache_uri, &secondary_cache);
        if (secondary_cache == nullptr) {
          fprintf(
              stderr,
@@ -19,7 +19,6 @@ std::array<const char*, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
    "IndexBlock",
    "OtherBlock",
    "WriteBuffer",
-    "CompressionDictionaryBuildingBuffer",
    "Misc",
 }};

@@ -31,7 +30,6 @@ std::array<const char*, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
    "index-block",
    "other-block",
    "write-buffer",
-    "compression-dictionary-building-buffer",
    "misc",
 }};

@@ -14,8 +14,6 @@
 namespace ROCKSDB_NAMESPACE {

 // Classifications of block cache entries, for reporting statistics
-// Adding new enum to this class requires corresponding updates to
-// kCacheEntryRoleToCamelString and kCacheEntryRoleToHyphenString
 enum class CacheEntryRole {
  // Block-based table data block
  kDataBlock,
@@ -29,11 +27,8 @@ enum class CacheEntryRole {
  kIndexBlock,
  // Other kinds of block-based table block
  kOtherBlock,
-  // WriteBufferManager reservations to account for memtable usage
+  // WriteBufferManager resevations to account for memtable usage
  kWriteBuffer,
-  // BlockBasedTableBuilder reservations to account for
-  // compression dictionary building buffer's memory usage
-  kCompressionDictionaryBuildingBuffer,
  // Default bucket, for miscellaneous cache entries. Do not use for
  // entries that could potentially add up to large usage.
  kMisc,
@@ -15,7 +15,6 @@
 #include "rocksdb/cache.h"
 #include "rocksdb/status.h"
 #include "rocksdb/system_clock.h"
-#include "test_util/sync_point.h"
 #include "util/coding_lean.h"

 namespace ROCKSDB_NAMESPACE {
@@ -1,131 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include "cache/cache_reservation_manager.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <memory>
-
-#include "cache/cache_entry_roles.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "table/block_based/block_based_table_reader.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-CacheReservationManager::CacheReservationManager(std::shared_ptr<Cache> cache,
-                                                 bool delayed_decrease)
-    : delayed_decrease_(delayed_decrease), cache_allocated_size_(0) {
-  assert(cache != nullptr);
-  cache_ = cache;
-  std::memset(cache_key_, 0, kCacheKeyPrefixSize + kMaxVarint64Length);
-  EncodeVarint64(cache_key_, cache_->NewId());
-}
-
-CacheReservationManager::~CacheReservationManager() {
-  for (auto* handle : dummy_handles_) {
-    cache_->Release(handle, true);
-  }
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManager::UpdateCacheReservation(
-    std::size_t new_mem_used) {
-  std::size_t cur_cache_allocated_size =
-      cache_allocated_size_.load(std::memory_order_relaxed);
-  if (new_mem_used == cur_cache_allocated_size) {
-    return Status::OK();
-  } else if (new_mem_used > cur_cache_allocated_size) {
-    Status s = IncreaseCacheReservation<R>(new_mem_used);
-    return s;
-  } else {
-    // In delayed decrease mode, we don't decrease cache reservation
-    // untill the memory usage is less than 3/4 of what we reserve
-    // in the cache.
-    // We do this because
-    // (1) Dummy entry insertion is expensive in block cache
-    // (2) Delayed releasing previously inserted dummy entries can save such
-    // expensive dummy entry insertion on memory increase in the near future,
-    // which is likely to happen when the memory usage is greater than or equal
-    // to 3/4 of what we reserve
-    if (delayed_decrease_ && new_mem_used >= cur_cache_allocated_size / 4 * 3) {
-      return Status::OK();
-    } else {
-      Status s = DecreaseCacheReservation(new_mem_used);
-      return s;
-    }
-  }
-}
-
-// Explicitly instantiate templates for "CacheEntryRole" values we use.
-// This makes it possible to keep the template definitions in the .cc file.
-template Status CacheReservationManager::UpdateCacheReservation<
-    CacheEntryRole::kWriteBuffer>(std::size_t new_mem_used);
-template Status CacheReservationManager::UpdateCacheReservation<
-    CacheEntryRole::kCompressionDictionaryBuildingBuffer>(
-    std::size_t new_mem_used);
-// For cache reservation manager unit tests
-template Status CacheReservationManager::UpdateCacheReservation<
-    CacheEntryRole::kMisc>(std::size_t new_mem_used);
-
-template <CacheEntryRole R>
-Status CacheReservationManager::IncreaseCacheReservation(
-    std::size_t new_mem_used) {
-  Status return_status = Status::OK();
-  while (new_mem_used > cache_allocated_size_.load(std::memory_order_relaxed)) {
-    Cache::Handle* handle = nullptr;
-    return_status = cache_->Insert(GetNextCacheKey(), nullptr, kSizeDummyEntry,
-                                   GetNoopDeleterForRole<R>(), &handle);
-
-    if (return_status != Status::OK()) {
-      return return_status;
-    }
-
-    dummy_handles_.push_back(handle);
-    cache_allocated_size_ += kSizeDummyEntry;
-  }
-  return return_status;
-}
-
-Status CacheReservationManager::DecreaseCacheReservation(
-    std::size_t new_mem_used) {
-  Status return_status = Status::OK();
-
-  // Decrease to the smallest multiple of kSizeDummyEntry that is greater than
-  // or equal to new_mem_used We do addition instead of new_mem_used <=
-  // cache_allocated_size_.load(std::memory_order_relaxed) - kSizeDummyEntry to
-  // avoid underflow of size_t when cache_allocated_size_ = 0
-  while (new_mem_used + kSizeDummyEntry <=
-         cache_allocated_size_.load(std::memory_order_relaxed)) {
-    assert(!dummy_handles_.empty());
-    auto* handle = dummy_handles_.back();
-    cache_->Release(handle, true);
-    dummy_handles_.pop_back();
-    cache_allocated_size_ -= kSizeDummyEntry;
-  }
-  return return_status;
-}
-
-std::size_t CacheReservationManager::GetTotalReservedCacheSize() {
-  return cache_allocated_size_.load(std::memory_order_relaxed);
-}
-
-Slice CacheReservationManager::GetNextCacheKey() {
-  // Calling this function will have the side-effect of changing the
-  // underlying cache_key_ that is shared among other keys generated from this
-  // fucntion. Therefore please make sure the previous keys are saved/copied
-  // before calling this function.
-  std::memset(cache_key_ + kCacheKeyPrefixSize, 0, kMaxVarint64Length);
-  char* end =
-      EncodeVarint64(cache_key_ + kCacheKeyPrefixSize, next_cache_key_id_++);
-  return Slice(cache_key_, static_cast<std::size_t>(end - cache_key_));
-}
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,98 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#pragma once
-
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <vector>
-
-#include "cache/cache_entry_roles.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "table/block_based/block_based_table_reader.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// CacheReservationManager is for reserving cache space for the memory used
-// through inserting/releasing dummy entries in the cache.
-// This class is not thread-safe.
-class CacheReservationManager {
- public:
-  // Construct a CacheReservationManager
-  // @param cache The cache where dummy entries are inserted and released for
-  // reserving cache space
-  // @param delayed_decrease If set true, then dummy entries won't be released
-  // immediately when memory usage decreases.
-  //                         Instead, it will be released when the memory usage
-  //                         decreases to 3/4 of what we have reserved so far.
-  //                         This is for saving some future dummy entry
-  //                         insertion when memory usage increases are likely to
-  //                         happen in the near future.
-  explicit CacheReservationManager(std::shared_ptr<Cache> cache,
-                                   bool delayed_decrease = false);
-
-  // no copy constructor, copy assignment, move constructor, move assignment
-  CacheReservationManager(const CacheReservationManager &) = delete;
-  CacheReservationManager &operator=(const CacheReservationManager &) = delete;
-  CacheReservationManager(CacheReservationManager &&) = delete;
-  CacheReservationManager &operator=(CacheReservationManager &&) = delete;
-
-  ~CacheReservationManager();
-
-  template <CacheEntryRole R>
-
-  // Insert and release dummy entries in the cache to
-  // match the size of total dummy entries with the smallest multiple of
-  // kSizeDummyEntry that is greater than or equal to new_mem_used
-  //
-  // Insert dummy entries if new_memory_used > cache_allocated_size_;
-  //
-  // Release dummy entries if new_memory_used < cache_allocated_size_
-  // (and new_memory_used < cache_allocated_size_ * 3/4
-  // when delayed_decrease is set true);
-  //
-  // Keey dummy entries the same if (1) new_memory_used == cache_allocated_size_
-  // or (2) new_memory_used is in the interval of
-  // [cache_allocated_size_ * 3/4, cache_allocated_size) when delayed_decrease
-  // is set true.
-  //
-  // @param new_memory_used The number of bytes used by new memory
-  // @return On inserting dummy entries, it returns Status::OK() if all dummy
-  // entry insertions succeed. Otherwise, it returns the first non-ok status;
-  // On releasing dummy entries, it always returns Status::OK().
-  // On keeping dummy entries the same, it always returns Status::OK().
-  Status UpdateCacheReservation(std::size_t new_memory_used);
-  std::size_t GetTotalReservedCacheSize();
-
- private:
-  static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  // The key will be longer than keys for blocks in SST files so they won't
-  // conflict.
-  static const std::size_t kCacheKeyPrefixSize =
-      BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
-
-  Slice GetNextCacheKey();
-  template <CacheEntryRole R>
-  Status IncreaseCacheReservation(std::size_t new_mem_used);
-  Status DecreaseCacheReservation(std::size_t new_mem_used);
-
-  std::shared_ptr<Cache> cache_;
-  bool delayed_decrease_;
-  std::atomic<std::size_t> cache_allocated_size_;
-  std::vector<Cache::Handle *> dummy_handles_;
-  std::uint64_t next_cache_key_id_ = 0;
-  // The non-prefix part will be updated according to the ID to use.
-  char cache_key_[kCacheKeyPrefixSize + kMaxVarint64Length];
-};
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,411 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include "cache/cache_reservation_manager.h"
-
-#include <cstddef>
-#include <cstring>
-#include <memory>
-
-#include "cache/cache_entry_roles.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/slice.h"
-#include "table/block_based/block_based_table_reader.h"
-#include "test_util/testharness.h"
-#include "util/coding.h"
-
-namespace ROCKSDB_NAMESPACE {
-class CacheReservationManagerTest : public ::testing::Test {
- protected:
-  static constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
-  static constexpr int kNumShardBits = 0;  // 2^0 shard
-
-  static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  static const std::size_t kCacheKeyPrefixSize =
-      BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
-  static constexpr std::size_t kMetaDataChargeOverhead = 10000;
-
-  std::shared_ptr<Cache> cache = NewLRUCache(kOneGigabyte, kNumShardBits);
-  std::unique_ptr<CacheReservationManager> test_cache_rev_mng;
-
-  CacheReservationManagerTest() {
-    test_cache_rev_mng.reset(new CacheReservationManager(cache));
-  }
-};
-
-TEST_F(CacheReservationManagerTest, GenerateCacheKey) {
-  // The first cache reservation manager owning the cache will have
-  // cache->NewId() = 1
-  constexpr std::size_t kCacheNewId = 1;
-  // The first key generated inside of cache reservation manager will have
-  // next_cache_key_id = 0
-  constexpr std::size_t kCacheKeyId = 0;
-
-  char expected_cache_key[kCacheKeyPrefixSize + kMaxVarint64Length];
-  std::memset(expected_cache_key, 0, kCacheKeyPrefixSize + kMaxVarint64Length);
-
-  EncodeVarint64(expected_cache_key, kCacheNewId);
-  char* end =
-      EncodeVarint64(expected_cache_key + kCacheKeyPrefixSize, kCacheKeyId);
-  Slice expected_cache_key_slice(
-      expected_cache_key, static_cast<std::size_t>(end - expected_cache_key));
-
-  std::size_t new_mem_used = 1 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
-  ASSERT_LT(cache->GetPinnedUsage(),
-            1 * kSizeDummyEntry + kMetaDataChargeOverhead);
-
-  Cache::Handle* handle = cache->Lookup(expected_cache_key_slice);
-  EXPECT_NE(handle, nullptr)
-      << "Failed to generate the cache key for the dummy entry correctly";
-  // Clean up the returned handle from Lookup() to prevent memory leak
-  cache->Release(handle);
-}
-
-TEST_F(CacheReservationManagerTest, KeepCacheReservationTheSame) {
-  std::size_t new_mem_used = 1 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry);
-  std::size_t initial_pinned_usage = cache->GetPinnedUsage();
-  ASSERT_GE(initial_pinned_usage, 1 * kSizeDummyEntry);
-  ASSERT_LT(initial_pinned_usage,
-            1 * kSizeDummyEntry + kMetaDataChargeOverhead);
-
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to keep cache reservation the same when new_mem_used equals "
-         "to current cache reservation";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly when new_mem_used equals to current "
-         "cache reservation";
-  EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
-      << "Failed to keep underlying dummy entries the same when new_mem_used "
-         "equals to current cache reservation";
-}
-
-TEST_F(CacheReservationManagerTest,
-       IncreaseCacheReservationByMultiplesOfDummyEntrySize) {
-  std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to increase cache reservation correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            2 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation increase correctly";
-  EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
-      << "Failed to increase underlying dummy entries in cache correctly";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            2 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to increase underlying dummy entries in cache correctly";
-}
-
-TEST_F(CacheReservationManagerTest,
-       IncreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
-  std::size_t new_mem_used = 2 * kSizeDummyEntry + kSizeDummyEntry / 2;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to increase cache reservation correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            3 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation increase correctly";
-  EXPECT_GE(cache->GetPinnedUsage(), 3 * kSizeDummyEntry)
-      << "Failed to increase underlying dummy entries in cache correctly";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            3 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to increase underlying dummy entries in cache correctly";
-}
-
-TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
-     IncreaseCacheReservationOnFullCache) {
-  constexpr std::size_t kOneMegabyte = 1024 * 1024;
-  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
-  constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  constexpr std::size_t kMetaDataChargeOverhead = 10000;
-
-  LRUCacheOptions lo;
-  lo.capacity = kOneMegabyte;
-  lo.num_shard_bits = 0;  // 2^0 shard
-  lo.strict_capacity_limit = true;
-  std::shared_ptr<Cache> cache = NewLRUCache(lo);
-  std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
-      new CacheReservationManager(cache));
-
-  std::size_t new_mem_used = kOneMegabyte + 1;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::Incomplete())
-      << "Failed to return status to indicate failure of dummy entry insertion "
-         "during cache reservation on full cache";
-  EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly before cache resevation failure happens "
-         "due to full cache";
-  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(), kOneMegabyte)
-      << "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
-         "entry insertions) when encountering cache resevation failure due to "
-         "full cache";
-  EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
-      << "Failed to insert underlying dummy entries correctly when "
-         "encountering cache resevation failure due to full cache";
-  EXPECT_LE(cache->GetPinnedUsage(), kOneMegabyte)
-      << "Failed to insert underlying dummy entries correctly when "
-         "encountering cache resevation failure due to full cache";
-
-  new_mem_used = kOneMegabyte / 2;  // 2 dummy entries
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to decrease cache reservation after encountering cache "
-         "reservation failure due to full cache";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            2 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation decrease correctly after "
-         "encountering cache reservation due to full cache";
-  EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
-      << "Failed to release underlying dummy entries correctly on cache "
-         "reservation decrease after encountering cache resevation failure due "
-         "to full cache";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            2 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to release underlying dummy entries correctly on cache "
-         "reservation decrease after encountering cache resevation failure due "
-         "to full cache";
-
-  // Create cache full again for subsequent tests
-  new_mem_used = kOneMegabyte + 1;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::Incomplete())
-      << "Failed to return status to indicate failure of dummy entry insertion "
-         "during cache reservation on full cache";
-  EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly before cache resevation failure happens "
-         "due to full cache";
-  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(), kOneMegabyte)
-      << "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
-         "entry insertions) when encountering cache resevation failure due to "
-         "full cache";
-  EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
-      << "Failed to insert underlying dummy entries correctly when "
-         "encountering cache resevation failure due to full cache";
-  EXPECT_LE(cache->GetPinnedUsage(), kOneMegabyte)
-      << "Failed to insert underlying dummy entries correctly when "
-         "encountering cache resevation failure due to full cache";
-
-  // Increase cache capacity so the previously failed insertion can fully
-  // succeed
-  cache->SetCapacity(kOneGigabyte);
-  new_mem_used = kOneMegabyte + 1;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to increase cache reservation after increasing cache capacity "
-         "and mitigating cache full error";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            5 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation increase correctly after "
-         "increasing cache capacity and mitigating cache full error";
-  EXPECT_GE(cache->GetPinnedUsage(), 5 * kSizeDummyEntry)
-      << "Failed to insert underlying dummy entries correctly after increasing "
-         "cache capacity and mitigating cache full error";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            5 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to insert underlying dummy entries correctly after increasing "
-         "cache capacity and mitigating cache full error";
-}
-
-TEST_F(CacheReservationManagerTest,
-       DecreaseCacheReservationByMultiplesOfDummyEntrySize) {
-  std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            2 * kSizeDummyEntry);
-  ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
-  ASSERT_LT(cache->GetPinnedUsage(),
-            2 * kSizeDummyEntry + kMetaDataChargeOverhead);
-
-  new_mem_used = 1 * kSizeDummyEntry;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to decrease cache reservation correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation decrease correctly";
-  EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
-      << "Failed to decrease underlying dummy entries in cache correctly";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            1 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to decrease underlying dummy entries in cache correctly";
-}
-
-TEST_F(CacheReservationManagerTest,
-       DecreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
-  std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            2 * kSizeDummyEntry);
-  ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
-  ASSERT_LT(cache->GetPinnedUsage(),
-            2 * kSizeDummyEntry + kMetaDataChargeOverhead);
-
-  new_mem_used = kSizeDummyEntry / 2;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to decrease cache reservation correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            1 * kSizeDummyEntry)
-      << "Failed to bookkeep cache reservation decrease correctly";
-  EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
-      << "Failed to decrease underlying dummy entries in cache correctly";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            1 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to decrease underlying dummy entries in cache correctly";
-}
-
-TEST(CacheReservationManagerWithDelayedDecreaseTest,
-     DecreaseCacheReservationWithDelayedDecrease) {
-  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
-  constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  constexpr std::size_t kMetaDataChargeOverhead = 10000;
-
-  LRUCacheOptions lo;
-  lo.capacity = kOneGigabyte;
-  lo.num_shard_bits = 0;
-  std::shared_ptr<Cache> cache = NewLRUCache(lo);
-  std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
-      new CacheReservationManager(cache, true /* delayed_decrease */));
-
-  std::size_t new_mem_used = 8 * kSizeDummyEntry;
-  Status s =
-      test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            8 * kSizeDummyEntry);
-  std::size_t initial_pinned_usage = cache->GetPinnedUsage();
-  ASSERT_GE(initial_pinned_usage, 8 * kSizeDummyEntry);
-  ASSERT_LT(initial_pinned_usage,
-            8 * kSizeDummyEntry + kMetaDataChargeOverhead);
-
-  new_mem_used = 6 * kSizeDummyEntry;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            8 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly when delaying cache reservation "
-         "decrease";
-  EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
-      << "Failed to delay decreasing underlying dummy entries in cache";
-
-  new_mem_used = 7 * kSizeDummyEntry;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            8 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly when delaying cache reservation "
-         "decrease";
-  EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
-      << "Failed to delay decreasing underlying dummy entries in cache";
-
-  new_mem_used = 6 * kSizeDummyEntry - 1;
-  s = test_cache_rev_mng
-          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-              new_mem_used);
-  EXPECT_EQ(s, Status::OK())
-      << "Failed to decrease cache reservation correctly when new_mem_used < "
-         "GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            6 * kSizeDummyEntry)
-      << "Failed to bookkeep correctly when new_mem_used < "
-         "GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
-  EXPECT_GE(cache->GetPinnedUsage(), 6 * kSizeDummyEntry)
-      << "Failed to decrease underlying dummy entries in cache when "
-         "new_mem_used < GetTotalReservedCacheSize() * 3 / 4 on delayed "
-         "decrease mode";
-  EXPECT_LT(cache->GetPinnedUsage(),
-            6 * kSizeDummyEntry + kMetaDataChargeOverhead)
-      << "Failed to decrease underlying dummy entries in cache when "
-         "new_mem_used < GetTotalReservedCacheSize() * 3 / 4 on delayed "
-         "decrease mode";
-}
-
-TEST(CacheReservationManagerDestructorTest,
-     ReleaseRemainingDummyEntriesOnDestruction) {
-  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
-  constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  constexpr std::size_t kMetaDataChargeOverhead = 10000;
-
-  LRUCacheOptions lo;
-  lo.capacity = kOneGigabyte;
-  lo.num_shard_bits = 0;
-  std::shared_ptr<Cache> cache = NewLRUCache(lo);
-  {
-    std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
-        new CacheReservationManager(cache));
-    std::size_t new_mem_used = 1 * kSizeDummyEntry;
-    Status s =
-        test_cache_rev_mng
-            ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
-                new_mem_used);
-    ASSERT_EQ(s, Status::OK());
-    ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
-    ASSERT_LT(cache->GetPinnedUsage(),
-              1 * kSizeDummyEntry + kMetaDataChargeOverhead);
-  }
-  EXPECT_EQ(cache->GetPinnedUsage(), 0 * kSizeDummyEntry)
-      << "Failed to release remaining underlying dummy entries in cache in "
-         "CacheReservationManager's destructor";
-}
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -260,7 +260,7 @@ struct CleanupContext {
 class ClockCacheShard final : public CacheShard {
 public:
  // Hash map type.
-  using HashTable = tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey>;
+  typedef tbb::concurrent_hash_map<CacheKey, CacheHandle*, CacheKey> HashTable;

  ClockCacheShard();
  ~ClockCacheShard() override;
@@ -280,8 +280,7 @@ class ClockCacheShard final : public CacheShard {
  Cache::Handle* Lookup(const Slice& key, uint32_t hash,
                        const Cache::CacheItemHelper* /*helper*/,
                        const Cache::CreateCallback& /*create_cb*/,
-                        Cache::Priority /*priority*/, bool /*wait*/,
-                        Statistics* /*stats*/) override {
+                        Cache::Priority /*priority*/, bool /*wait*/) override {
    return Lookup(key, hash);
  }
  bool Release(Cache::Handle* handle, bool /*useful*/,
@@ -13,8 +13,6 @@
 #include <cstdint>
 #include <cstdio>

-#include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
 #include "util/mutexlock.h"

 namespace ROCKSDB_NAMESPACE {
@@ -311,8 +309,7 @@ void LRUCacheShard::SetStrictCapacityLimit(bool strict_capacity_limit) {
  strict_capacity_limit_ = strict_capacity_limit;
 }

-Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
-                                 bool free_handle_on_fail) {
+Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle) {
  Status s = Status::OK();
  autovector<LRUHandle*> last_reference_list;
  size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
@@ -326,16 +323,14 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,

    if ((usage_ + total_charge) > capacity_ &&
        (strict_capacity_limit_ || handle == nullptr)) {
-      e->SetInCache(false);
      if (handle == nullptr) {
        // Don't insert the entry but still return ok, as if the entry inserted
        // into cache and get evicted immediately.
+        e->SetInCache(false);
        last_reference_list.push_back(e);
      } else {
-        if (free_handle_on_fail) {
-          delete[] reinterpret_cast<char*>(e);
-          *handle = nullptr;
-        }
+        delete[] reinterpret_cast<char*>(e);
+        *handle = nullptr;
        s = Status::Incomplete("Insert failed due to LRU cache being full.");
      }
    } else {
@@ -360,10 +355,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
      if (handle == nullptr) {
        LRU_Insert(e);
      } else {
-        // If caller already holds a ref, no need to take one here
-        if (!e->HasRefs()) {
-          e->Ref();
-        }
+        e->Ref();
        *handle = reinterpret_cast<Cache::Handle*>(e);
      }
    }
@@ -383,43 +375,11 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
  return s;
 }

-void LRUCacheShard::Promote(LRUHandle* e) {
-  SecondaryCacheResultHandle* secondary_handle = e->sec_handle;
-
-  assert(secondary_handle->IsReady());
-  e->SetIncomplete(false);
-  e->SetInCache(true);
-  e->SetPromoted(true);
-  e->value = secondary_handle->Value();
-  e->charge = secondary_handle->Size();
-  delete secondary_handle;
-
-  // This call could fail if the cache is over capacity and
-  // strict_capacity_limit_ is true. In such a case, we don't want
-  // InsertItem() to free the handle, since the item is already in memory
-  // and the caller will most likely just read from disk if we erase it here.
-  if (e->value) {
-    Cache::Handle* handle = reinterpret_cast<Cache::Handle*>(e);
-    Status s = InsertItem(e, &handle, /*free_handle_on_fail=*/false);
-    if (!s.ok()) {
-      // Item is in memory, but not accounted against the cache capacity.
-      // When the handle is released, the item should get deleted
-      assert(!e->InCache());
-    }
-  } else {
-    // Since the secondary cache lookup failed, mark the item as not in cache
-    // Don't charge the cache as its only metadata that'll shortly be released
-    MutexLock l(&mutex_);
-    e->charge = 0;
-    e->SetInCache(false);
-  }
-}
-
 Cache::Handle* LRUCacheShard::Lookup(
    const Slice& key, uint32_t hash,
    const ShardedCache::CacheItemHelper* helper,
    const ShardedCache::CreateCallback& create_cb, Cache::Priority priority,
-    bool wait, Statistics* stats) {
+    bool wait) {
  LRUHandle* e = nullptr;
  {
    MutexLock l(&mutex_);
@@ -439,51 +399,47 @@ Cache::Handle* LRUCacheShard::Lookup(
  // mutex if we're going to lookup in the secondary cache
  // Only support synchronous for now
  // TODO: Support asynchronous lookup in secondary cache
-  if (!e && secondary_cache_ && helper && helper->saveto_cb) {
+  if (!e && secondary_cache_ && helper && helper->saveto_cb && wait) {
    // For objects from the secondary cache, we expect the caller to provide
    // a way to create/delete the primary cache object. The only case where
    // a deleter would not be required is for dummy entries inserted for
    // accounting purposes, which we won't demote to the secondary cache
    // anyway.
    assert(create_cb && helper->del_cb);
-    std::unique_ptr<SecondaryCacheResultHandle> secondary_handle =
+    std::unique_ptr<SecondaryCacheHandle> secondary_handle =
        secondary_cache_->Lookup(key, create_cb, wait);
    if (secondary_handle != nullptr) {
+      void* value = nullptr;
      e = reinterpret_cast<LRUHandle*>(
          new char[sizeof(LRUHandle) - 1 + key.size()]);

      e->flags = 0;
+      e->SetPromoted(true);
      e->SetSecondaryCacheCompatible(true);
      e->info_.helper = helper;
      e->key_length = key.size();
      e->hash = hash;
      e->refs = 0;
      e->next = e->prev = nullptr;
+      e->SetInCache(true);
      e->SetPriority(priority);
      memcpy(e->key_data, key.data(), key.size());
-      e->value = nullptr;
-      e->sec_handle = secondary_handle.release();
-      e->Ref();

-      if (wait) {
-        Promote(e);
-        if (!e->value) {
-          // The secondary cache returned a handle, but the lookup failed
-          e->Unref();
-          e->Free();
-          e = nullptr;
-        } else {
-          PERF_COUNTER_ADD(secondary_cache_hit_count, 1);
-          RecordTick(stats, SECONDARY_CACHE_HITS);
-        }
-      } else {
-        // If wait is false, we always return a handle and let the caller
-        // release the handle after checking for success or failure
-        e->SetIncomplete(true);
-        // This may be slightly inaccurate, if the lookup eventually fails.
-        // But the probability is very low.
-        PERF_COUNTER_ADD(secondary_cache_hit_count, 1);
-        RecordTick(stats, SECONDARY_CACHE_HITS);
+      value = secondary_handle->Value();
+      e->value = value;
+      e->charge = secondary_handle->Size();
+
+      // This call could nullify e if the cache is over capacity and
+      // strict_capacity_limit_ is true. In such a case, the caller will try
+      // to insert later, which might again fail, but its ok as this should
+      // not be common
+      // Being conservative here since there could be lookups that are
+      // actually ok to fail rather than succeed and bloat up the memory
+      // usage (preloading partitioned index blocks, for example).
+      Status s = InsertItem(e, reinterpret_cast<Cache::Handle**>(&e));
+      if (!s.ok()) {
+        assert(e == nullptr);
+        (*helper->del_cb)(key, value);
      }
    }
  }
@@ -529,12 +485,7 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool force_erase) {
        last_reference = false;
      }
    }
-    // If it was the last reference, and the entry is either not secondary
-    // cache compatible (i.e a dummy entry for accounting), or is secondary
-    // cache compatible and has a non-null value, then decrement the cache
-    // usage. If value is null in the latter case, taht means the lookup
-    // failed and we didn't charge the cache.
-    if (last_reference && (!e->IsSecondaryCacheCompatible() || e->value)) {
+    if (last_reference) {
      size_t total_charge = e->CalcTotalCharge(metadata_charge_policy_);
      assert(usage_ >= total_charge);
      usage_ -= total_charge;
@@ -579,7 +530,7 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  e->SetPriority(priority);
  memcpy(e->key_data, key.data(), key.size());

-  return InsertItem(e, handle, /* free_handle_on_fail */ true);
+  return InsertItem(e, handle);
 }

 void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
@@ -609,18 +560,6 @@ void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
  }
 }

-bool LRUCacheShard::IsReady(Cache::Handle* handle) {
-  LRUHandle* e = reinterpret_cast<LRUHandle*>(handle);
-  MutexLock l(&mutex_);
-  bool ready = true;
-  if (e->IsPending()) {
-    assert(secondary_cache_);
-    assert(e->sec_handle);
-    ready = e->sec_handle->IsReady();
-  }
-  return ready;
-}
-
 size_t LRUCacheShard::GetUsage() const {
  MutexLock l(&mutex_);
  return usage_;
@@ -661,7 +600,6 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
        use_adaptive_mutex, metadata_charge_policy,
        /* max_upper_hash_bits */ 32 - num_shard_bits, secondary_cache);
  }
-  secondary_cache_ = secondary_cache;
 }

 LRUCache::~LRUCache() {
@@ -727,36 +665,6 @@ double LRUCache::GetHighPriPoolRatio() {
  return result;
 }

-void LRUCache::WaitAll(std::vector<Handle*>& handles) {
-  if (secondary_cache_) {
-    std::vector<SecondaryCacheResultHandle*> sec_handles;
-    sec_handles.reserve(handles.size());
-    for (Handle* handle : handles) {
-      if (!handle) {
-        continue;
-      }
-      LRUHandle* lru_handle = reinterpret_cast<LRUHandle*>(handle);
-      if (!lru_handle->IsPending()) {
-        continue;
-      }
-      sec_handles.emplace_back(lru_handle->sec_handle);
-    }
-    secondary_cache_->WaitAll(sec_handles);
-    for (Handle* handle : handles) {
-      if (!handle) {
-        continue;
-      }
-      LRUHandle* lru_handle = reinterpret_cast<LRUHandle*>(handle);
-      if (!lru_handle->IsPending()) {
-        continue;
-      }
-      uint32_t hash = GetHash(handle);
-      LRUCacheShard* shard = static_cast<LRUCacheShard*>(GetShard(Shard(hash)));
-      shard->Promote(lru_handle);
-    }
-  }
-}
-
 std::shared_ptr<Cache> NewLRUCache(
    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
    double high_pri_pool_ratio,
@@ -57,12 +57,7 @@ struct LRUHandle {
    Cache::DeleterFn deleter;
    const ShardedCache::CacheItemHelper* helper;
  } info_;
-  // An entry is not added to the LRUHandleTable until the secondary cache
-  // lookup is complete, so its safe to have this union.
-  union {
-    LRUHandle* next_hash;
-    SecondaryCacheResultHandle* sec_handle;
-  };
+  LRUHandle* next_hash;
  LRUHandle* next;
  LRUHandle* prev;
  size_t charge;  // TODO(opt): Only allow uint32_t?
@@ -194,16 +189,7 @@ struct LRUHandle {
    if (!IsSecondaryCacheCompatible() && info_.deleter) {
      (*info_.deleter)(key(), value);
    } else if (IsSecondaryCacheCompatible()) {
-      if (IsPending()) {
-        assert(sec_handle != nullptr);
-        SecondaryCacheResultHandle* tmp_sec_handle = sec_handle;
-        tmp_sec_handle->Wait();
-        value = tmp_sec_handle->Value();
-        delete tmp_sec_handle;
-      }
-      if (value) {
-        (*info_.helper->del_cb)(key(), value);
-      }
+      (*info_.helper->del_cb)(key(), value);
    }
    delete[] reinterpret_cast<char*>(this);
  }
@@ -319,17 +305,16 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
                                const ShardedCache::CacheItemHelper* helper,
                                const ShardedCache::CreateCallback& create_cb,
-                                ShardedCache::Priority priority, bool wait,
-                                Statistics* stats) override;
+                                ShardedCache::Priority priority,
+                                bool wait) override;
  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) override {
-    return Lookup(key, hash, nullptr, nullptr, Cache::Priority::LOW, true,
-                  nullptr);
+    return Lookup(key, hash, nullptr, nullptr, Cache::Priority::LOW, true);
  }
  virtual bool Release(Cache::Handle* handle, bool /*useful*/,
                       bool force_erase) override {
    return Release(handle, force_erase);
  }
-  virtual bool IsReady(Cache::Handle* /*handle*/) override;
+  virtual bool IsReady(Cache::Handle* /*handle*/) override { return true; }
  virtual void Wait(Cache::Handle* /*handle*/) override {}
  virtual bool Ref(Cache::Handle* handle) override;
  virtual bool Release(Cache::Handle* handle,
@@ -362,23 +347,10 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  double GetHighPriPoolRatio();

 private:
-  friend class LRUCache;
-  // Insert an item into the hash table and, if handle is null, insert into
-  // the LRU list. Older items are evicted as necessary. If the cache is full
-  // and free_handle_on_fail is true, the item is deleted and handle is set to.
-  Status InsertItem(LRUHandle* item, Cache::Handle** handle,
-                    bool free_handle_on_fail);
+  Status InsertItem(LRUHandle* item, Cache::Handle** handle);
  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
                DeleterFn deleter, const Cache::CacheItemHelper* helper,
                Cache::Handle** handle, Cache::Priority priority);
-  // Promote an item looked up from the secondary cache to the LRU cache. The
-  // item is only inserted into the hash table and not the LRU list, and only
-  // if the cache is not at full capacity, as is the case during Insert.  The
-  // caller should hold a reference on the LRUHandle. When the caller releases
-  // the last reference, the item is added to the LRU list.
-  // The item is promoted to the high pri or low pri pool as specified by the
-  // caller in Lookup.
-  void Promote(LRUHandle* e);
  void LRU_Remove(LRUHandle* e);
  void LRU_Insert(LRUHandle* e);

@@ -465,7 +437,7 @@ class LRUCache
  virtual uint32_t GetHash(Handle* handle) const override;
  virtual DeleterFn GetDeleter(Handle* handle) const override;
  virtual void DisownData() override;
-  virtual void WaitAll(std::vector<Handle*>& handles) override;
+  virtual void WaitAll(std::vector<Handle*>& /*handles*/) override {}

  //  Retrieves number of elements in LRU, for unit test purpose only
  size_t TEST_GetLRUSize();
@@ -475,7 +447,6 @@ class LRUCache
 private:
  LRUCacheShard* shards_ = nullptr;
  int num_shards_ = 0;
-  std::shared_ptr<SecondaryCache> secondary_cache_;
 };

 }  // namespace ROCKSDB_NAMESPACE
@@ -18,7 +18,6 @@
 #include "test_util/testharness.h"
 #include "util/coding.h"
 #include "util/random.h"
-#include "utilities/fault_injection_fs.h"

 namespace ROCKSDB_NAMESPACE {

@@ -204,19 +203,6 @@ TEST_F(LRUCacheTest, EntriesWithPriority) {

 class TestSecondaryCache : public SecondaryCache {
 public:
-  // Specifies what action to take on a lookup for a particular key
-  enum ResultType {
-    SUCCESS,
-    // Fail lookup immediately
-    FAIL,
-    // Defer the result. It will returned after Wait/WaitAll is called
-    DEFER,
-    // Defer the result and eventually return failure
-    DEFER_AND_FAIL
-  };
-
-  using ResultMap = std::unordered_map<std::string, ResultType>;
-
  explicit TestSecondaryCache(size_t capacity)
      : num_inserts_(0), num_lookups_(0), inject_failure_(false) {
    cache_ = NewLRUCache(capacity, 0, false, 0.5, nullptr,
@@ -224,22 +210,17 @@ class TestSecondaryCache : public SecondaryCache {
  }
  ~TestSecondaryCache() override { cache_.reset(); }

-  const char* Name() const override { return "TestSecondaryCache"; }
+  std::string Name() override { return "TestSecondaryCache"; }

  void InjectFailure() { inject_failure_ = true; }

  void ResetInjectFailure() { inject_failure_ = false; }

-  void SetDbSessionId(const std::string& db_session_id) {
-    db_session_id_ = db_session_id;
-  }
-
  Status Insert(const Slice& key, void* value,
                const Cache::CacheItemHelper* helper) override {
    if (inject_failure_) {
      return Status::Corruption("Insertion Data Corrupted");
    }
-    assert(IsDbSessionIdAsKeyPrefix(key) == true);
    size_t size;
    char* buf;
    Status s;
@@ -259,37 +240,22 @@ class TestSecondaryCache : public SecondaryCache {
                          });
  }

-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
+  std::unique_ptr<SecondaryCacheHandle> Lookup(
      const Slice& key, const Cache::CreateCallback& create_cb,
      bool /*wait*/) override {
-    std::string key_str = key.ToString();
-    TEST_SYNC_POINT_CALLBACK("TestSecondaryCache::Lookup", &key_str);
-
-    std::unique_ptr<SecondaryCacheResultHandle> secondary_handle;
-    ResultType type = ResultType::SUCCESS;
-    auto iter = result_map_.find(key.ToString());
-    if (iter != result_map_.end()) {
-      type = iter->second;
-    }
-    if (type == ResultType::FAIL) {
-      return secondary_handle;
-    }
-
+    std::unique_ptr<SecondaryCacheHandle> secondary_handle;
    Cache::Handle* handle = cache_->Lookup(key);
    num_lookups_++;
    if (handle) {
-      void* value = nullptr;
-      size_t charge = 0;
-      Status s;
-      if (type != ResultType::DEFER_AND_FAIL) {
-        char* ptr = (char*)cache_->Value(handle);
-        size_t size = DecodeFixed64(ptr);
-        ptr += sizeof(uint64_t);
-        s = create_cb(ptr, size, &value, &charge);
-      }
+      void* value;
+      size_t charge;
+      char* ptr = (char*)cache_->Value(handle);
+      size_t size = DecodeFixed64(ptr);
+      ptr += sizeof(uint64_t);
+      Status s = create_cb(ptr, size, &value, &charge);
      if (s.ok()) {
-        secondary_handle.reset(new TestSecondaryCacheResultHandle(
-            cache_.get(), handle, value, charge, type));
+        secondary_handle.reset(
+            new TestSecondaryCacheHandle(cache_.get(), handle, value, charge));
      } else {
        cache_->Release(handle);
      }
@@ -299,92 +265,47 @@ class TestSecondaryCache : public SecondaryCache {

  void Erase(const Slice& /*key*/) override {}

-  void WaitAll(std::vector<SecondaryCacheResultHandle*> handles) override {
-    for (SecondaryCacheResultHandle* handle : handles) {
-      TestSecondaryCacheResultHandle* sec_handle =
-          static_cast<TestSecondaryCacheResultHandle*>(handle);
-      sec_handle->SetReady();
-    }
-  }
+  void WaitAll(std::vector<SecondaryCacheHandle*> /*handles*/) override {}

  std::string GetPrintableOptions() const override { return ""; }

-  void SetResultMap(ResultMap&& map) { result_map_ = std::move(map); }
-
  uint32_t num_inserts() { return num_inserts_; }

  uint32_t num_lookups() { return num_lookups_; }

-  bool IsDbSessionIdAsKeyPrefix(const Slice& key) {
-    if (db_session_id_.size() == 0) {
-      return true;
-    }
-    if (key.size() < 20) {
-      return false;
-    }
-    std::string s_key = key.ToString();
-    if (s_key.substr(0, 20) != db_session_id_) {
-      return false;
-    }
-    return true;
-  }
-
 private:
-  class TestSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
+  class TestSecondaryCacheHandle : public SecondaryCacheHandle {
   public:
-    TestSecondaryCacheResultHandle(Cache* cache, Cache::Handle* handle,
-                                   void* value, size_t size, ResultType type)
-        : cache_(cache),
-          handle_(handle),
-          value_(value),
-          size_(size),
-          is_ready_(true) {
-      if (type != ResultType::SUCCESS) {
-        is_ready_ = false;
-      }
-    }
+    TestSecondaryCacheHandle(Cache* cache, Cache::Handle* handle, void* value,
+                             size_t size)
+        : cache_(cache), handle_(handle), value_(value), size_(size) {}
+    ~TestSecondaryCacheHandle() override { cache_->Release(handle_); }

-    ~TestSecondaryCacheResultHandle() override { cache_->Release(handle_); }
-
-    bool IsReady() override { return is_ready_; }
+    bool IsReady() override { return true; }

    void Wait() override {}

-    void* Value() override {
-      assert(is_ready_);
-      return value_;
-    }
+    void* Value() override { return value_; }

-    size_t Size() override { return Value() ? size_ : 0; }
-
-    void SetReady() { is_ready_ = true; }
+    size_t Size() override { return size_; }

   private:
    Cache* cache_;
    Cache::Handle* handle_;
    void* value_;
    size_t size_;
-    bool is_ready_;
  };

  std::shared_ptr<Cache> cache_;
  uint32_t num_inserts_;
  uint32_t num_lookups_;
  bool inject_failure_;
-  std::string db_session_id_;
-  ResultMap result_map_;
 };

 class DBSecondaryCacheTest : public DBTestBase {
 public:
  DBSecondaryCacheTest()
-      : DBTestBase("db_secondary_cache_test", /*env_do_fsync=*/true) {
-    fault_fs_.reset(new FaultInjectionTestFS(env_->GetFileSystem()));
-    fault_env_.reset(new CompositeEnvWrapper(env_, fault_fs_));
-  }
-
-  std::shared_ptr<FaultInjectionTestFS> fault_fs_;
-  std::unique_ptr<Env> fault_env_;
+      : DBTestBase("/db_secondary_cache_test", /*env_do_fsync=*/true) {}
 };

 class LRUSecondaryCacheTest : public LRUCacheTest {
@@ -402,7 +323,6 @@ class LRUSecondaryCacheTest : public LRUCacheTest {

    char* Buf() { return buf_.get(); }
    size_t Size() { return size_; }
-    std::string ToString() { return std::string(Buf(), Size()); }

   private:
    std::unique_ptr<char[]> buf_;
@@ -468,7 +388,6 @@ TEST_F(LRUSecondaryCacheTest, BasicTest) {
      std::make_shared<TestSecondaryCache>(2048);
  opts.secondary_cache = secondary_cache;
  std::shared_ptr<Cache> cache = NewLRUCache(opts);
-  std::shared_ptr<Statistics> stats = CreateDBStatistics();

  Random rnd(301);
  std::string str1 = rnd.RandomString(1020);
@@ -477,29 +396,22 @@ TEST_F(LRUSecondaryCacheTest, BasicTest) {
                          str1.length()));
  std::string str2 = rnd.RandomString(1020);
  TestItem* item2 = new TestItem(str2.data(), str2.length());
-  // k1 should be demoted to NVM
+  // k2 should be demoted to NVM
  ASSERT_OK(cache->Insert("k2", item2, &LRUSecondaryCacheTest::helper_,
                          str2.length()));

-  get_perf_context()->Reset();
  Cache::Handle* handle;
-  handle =
-      cache->Lookup("k2", &LRUSecondaryCacheTest::helper_, test_item_creator,
-                    Cache::Priority::LOW, true, stats.get());
+  handle = cache->Lookup("k2", &LRUSecondaryCacheTest::helper_,
+                         test_item_creator, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  // This lookup should promote k1 and demote k2
-  handle =
-      cache->Lookup("k1", &LRUSecondaryCacheTest::helper_, test_item_creator,
-                    Cache::Priority::LOW, true, stats.get());
+  handle = cache->Lookup("k1", &LRUSecondaryCacheTest::helper_,
+                         test_item_creator, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  ASSERT_EQ(secondary_cache->num_inserts(), 2u);
  ASSERT_EQ(secondary_cache->num_lookups(), 1u);
-  ASSERT_EQ(stats->getTickerCount(SECONDARY_CACHE_HITS),
-            secondary_cache->num_lookups());
-  PerfContext perf_ctx = *get_perf_context();
-  ASSERT_EQ(perf_ctx.secondary_cache_hit_count, secondary_cache->num_lookups());

  cache.reset();
  secondary_cache.reset();
@@ -636,15 +548,14 @@ TEST_F(LRUSecondaryCacheTest, FullCapacityTest) {
  handle = cache->Lookup("k2", &LRUSecondaryCacheTest::helper_,
                         test_item_creator, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
-  // k1 promotion should fail due to the block cache being at capacity,
-  // but the lookup should still succeed
+  // This lookup should fail, since k1 promotion would have failed due to
+  // the block cache being at capacity
  Cache::Handle* handle2;
  handle2 = cache->Lookup("k1", &LRUSecondaryCacheTest::helper_,
                          test_item_creator, Cache::Priority::LOW, true);
-  ASSERT_NE(handle2, nullptr);
-  // Since k1 didn't get inserted, k2 should still be in cache
+  ASSERT_EQ(handle2, nullptr);
+  // Since k1 didn't get promoted, k2 should still be in cache
  cache->Release(handle);
-  cache->Release(handle2);
  handle = cache->Lookup("k2", &LRUSecondaryCacheTest::helper_,
                         test_item_creator, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
@@ -675,16 +586,11 @@ TEST_F(DBSecondaryCacheTest, TestSecondaryCacheCorrectness1) {
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.env = fault_env_.get();
-  fault_fs_->SetFailGetUniqueId(true);

  // Set the file paranoid check, so after flush, the file will be read
  // all the blocks will be accessed.
  options.paranoid_file_checks = true;
  DestroyAndReopen(options);
-  std::string session_id;
-  ASSERT_OK(db_->GetDbSessionId(session_id));
-  secondary_cache->SetDbSessionId(session_id);
  Random rnd(301);
  const int N = 6;
  for (int i = 0; i < N; i++) {
@@ -773,12 +679,7 @@ TEST_F(DBSecondaryCacheTest, TestSecondaryCacheCorrectness2) {
  options.create_if_missing = true;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  options.paranoid_file_checks = true;
-  options.env = fault_env_.get();
-  fault_fs_->SetFailGetUniqueId(true);
  DestroyAndReopen(options);
-  std::string session_id;
-  ASSERT_OK(db_->GetDbSessionId(session_id));
-  secondary_cache->SetDbSessionId(session_id);
  Random rnd(301);
  const int N = 6;
  for (int i = 0; i < N; i++) {
@@ -866,13 +767,7 @@ TEST_F(DBSecondaryCacheTest, NoSecondaryCacheInsertion) {
  options.create_if_missing = true;
  options.paranoid_file_checks = true;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.env = fault_env_.get();
-  fault_fs_->SetFailGetUniqueId(true);
-
  DestroyAndReopen(options);
-  std::string session_id;
-  ASSERT_OK(db_->GetDbSessionId(session_id));
-  secondary_cache->SetDbSessionId(session_id);
  Random rnd(301);
  const int N = 6;
  for (int i = 0; i < N; i++) {
@@ -919,12 +814,7 @@ TEST_F(DBSecondaryCacheTest, SecondaryCacheIntensiveTesting) {
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.env = fault_env_.get();
-  fault_fs_->SetFailGetUniqueId(true);
  DestroyAndReopen(options);
-  std::string session_id;
-  ASSERT_OK(db_->GetDbSessionId(session_id));
-  secondary_cache->SetDbSessionId(session_id);
  Random rnd(301);
  const int N = 256;
  for (int i = 0; i < N; i++) {
@@ -969,12 +859,7 @@ TEST_F(DBSecondaryCacheTest, SecondaryCacheFailureTest) {
  options.create_if_missing = true;
  options.paranoid_file_checks = true;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.env = fault_env_.get();
-  fault_fs_->SetFailGetUniqueId(true);
  DestroyAndReopen(options);
-  std::string session_id;
-  ASSERT_OK(db_->GetDbSessionId(session_id));
-  secondary_cache->SetDbSessionId(session_id);
  Random rnd(301);
  const int N = 6;
  for (int i = 0; i < N; i++) {
@@ -1047,141 +932,6 @@ TEST_F(DBSecondaryCacheTest, SecondaryCacheFailureTest) {
  Destroy(options);
 }

-TEST_F(LRUSecondaryCacheTest, BasicWaitAllTest) {
-  LRUCacheOptions opts(1024, 2, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
-                       kDontChargeCacheMetadata);
-  std::shared_ptr<TestSecondaryCache> secondary_cache =
-      std::make_shared<TestSecondaryCache>(32 * 1024);
-  opts.secondary_cache = secondary_cache;
-  std::shared_ptr<Cache> cache = NewLRUCache(opts);
-  const int num_keys = 32;
-
-  Random rnd(301);
-  std::vector<std::string> values;
-  for (int i = 0; i < num_keys; ++i) {
-    std::string str = rnd.RandomString(1020);
-    values.emplace_back(str);
-    TestItem* item = new TestItem(str.data(), str.length());
-    ASSERT_OK(cache->Insert("k" + std::to_string(i), item,
-                            &LRUSecondaryCacheTest::helper_, str.length()));
-  }
-  // Force all entries to be evicted to the secondary cache
-  cache->SetCapacity(0);
-  ASSERT_EQ(secondary_cache->num_inserts(), 32u);
-  cache->SetCapacity(32 * 1024);
-
-  secondary_cache->SetResultMap(
-      {{"k3", TestSecondaryCache::ResultType::DEFER},
-       {"k4", TestSecondaryCache::ResultType::DEFER_AND_FAIL},
-       {"k5", TestSecondaryCache::ResultType::FAIL}});
-  std::vector<Cache::Handle*> results;
-  for (int i = 0; i < 6; ++i) {
-    results.emplace_back(
-        cache->Lookup("k" + std::to_string(i), &LRUSecondaryCacheTest::helper_,
-                      test_item_creator, Cache::Priority::LOW, false));
-  }
-  cache->WaitAll(results);
-  for (int i = 0; i < 6; ++i) {
-    if (i == 4) {
-      ASSERT_EQ(cache->Value(results[i]), nullptr);
-    } else if (i == 5) {
-      ASSERT_EQ(results[i], nullptr);
-      continue;
-    } else {
-      TestItem* item = static_cast<TestItem*>(cache->Value(results[i]));
-      ASSERT_EQ(item->ToString(), values[i]);
-    }
-    cache->Release(results[i]);
-  }
-
-  cache.reset();
-  secondary_cache.reset();
-}
-
-// In this test, we have one KV pair per data block. We indirectly determine
-// the cache key associated with each data block (and thus each KV) by using
-// a sync point callback in TestSecondaryCache::Lookup. We then control the
-// lookup result by setting the ResultMap.
-TEST_F(DBSecondaryCacheTest, TestSecondaryCacheMultiGet) {
-  LRUCacheOptions opts(1 << 20, 0, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
-                       kDontChargeCacheMetadata);
-  std::shared_ptr<TestSecondaryCache> secondary_cache(
-      new TestSecondaryCache(2048 * 1024));
-  opts.secondary_cache = secondary_cache;
-  std::shared_ptr<Cache> cache = NewLRUCache(opts);
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = cache;
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.paranoid_file_checks = true;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 8;
-  std::vector<std::string> keys;
-  for (int i = 0; i < N; i++) {
-    std::string p_v = rnd.RandomString(4000);
-    keys.emplace_back(p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-  // After Flush is successful, RocksDB does the paranoid check for the new
-  // SST file. This will try to lookup all data blocks in the secondary
-  // cache.
-  ASSERT_EQ(secondary_cache->num_inserts(), 0u);
-  ASSERT_EQ(secondary_cache->num_lookups(), 8u);
-
-  cache->SetCapacity(0);
-  ASSERT_EQ(secondary_cache->num_inserts(), 8u);
-  cache->SetCapacity(1 << 20);
-
-  std::vector<std::string> cache_keys;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "TestSecondaryCache::Lookup", [&cache_keys](void* key) -> void {
-        cache_keys.emplace_back(*(static_cast<std::string*>(key)));
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  for (int i = 0; i < N; ++i) {
-    std::string v = Get(Key(i));
-    ASSERT_EQ(4000, v.size());
-    ASSERT_EQ(v, keys[i]);
-  }
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  ASSERT_EQ(secondary_cache->num_lookups(), 16u);
-  cache->SetCapacity(0);
-  cache->SetCapacity(1 << 20);
-
-  ASSERT_EQ(Get(Key(2)), keys[2]);
-  ASSERT_EQ(Get(Key(7)), keys[7]);
-  secondary_cache->SetResultMap(
-      {{cache_keys[3], TestSecondaryCache::ResultType::DEFER},
-       {cache_keys[4], TestSecondaryCache::ResultType::DEFER_AND_FAIL},
-       {cache_keys[5], TestSecondaryCache::ResultType::FAIL}});
-
-  std::vector<std::string> mget_keys(
-      {Key(0), Key(1), Key(2), Key(3), Key(4), Key(5), Key(6), Key(7)});
-  std::vector<PinnableSlice> values(mget_keys.size());
-  std::vector<Status> s(keys.size());
-  std::vector<Slice> key_slices;
-  for (const std::string& key : mget_keys) {
-    key_slices.emplace_back(key);
-  }
-  uint32_t num_lookups = secondary_cache->num_lookups();
-  dbfull()->MultiGet(ReadOptions(), dbfull()->DefaultColumnFamily(),
-                     key_slices.size(), key_slices.data(), values.data(),
-                     s.data(), false);
-  ASSERT_EQ(secondary_cache->num_lookups(), num_lookups + 5);
-  for (int i = 0; i < N; ++i) {
-    ASSERT_OK(s[i]);
-    ASSERT_EQ(values[i].ToString(), keys[i]);
-    values[i].Reset();
-  }
-  Destroy(options);
-}
-
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -83,10 +83,10 @@ Cache::Handle* ShardedCache::Lookup(const Slice& key,
                                    const CacheItemHelper* helper,
                                    const CreateCallback& create_cb,
                                    Priority priority, bool wait,
-                                    Statistics* stats) {
+                                    Statistics* /*stats*/) {
  uint32_t hash = HashSlice(key);
  return GetShard(Shard(hash))
-      ->Lookup(key, hash, helper, create_cb, priority, wait, stats);
+      ->Lookup(key, hash, helper, create_cb, priority, wait);
 }

 bool ShardedCache::IsReady(Handle* handle) {
@@ -34,8 +34,7 @@ class CacheShard {
  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
                                const Cache::CacheItemHelper* helper,
                                const Cache::CreateCallback& create_cb,
-                                Cache::Priority priority, bool wait,
-                                Statistics* stats) = 0;
+                                Cache::Priority priority, bool wait) = 0;
  virtual bool Release(Cache::Handle* handle, bool useful,
                       bool force_erase) = 0;
  virtual bool IsReady(Cache::Handle* handle) = 0;
@@ -116,10 +115,9 @@ class ShardedCache : public Cache {
  int GetNumShardBits() const;
  uint32_t GetNumShards() const;

- protected:
+ private:
  inline uint32_t Shard(uint32_t hash) { return hash & shard_mask_; }

- private:
  const uint32_t shard_mask_;
  mutable port::Mutex capacity_mutex_;
  size_t capacity_;
@@ -24,7 +24,7 @@ mkdir -p $COVERAGE_DIR

 # Find all gcno files to generate the coverage report

-PYTHON=${1:-`which python3`}
+PYTHON=${1:-`which python`}
 echo -e "Using $PYTHON"
 GCNO_FILES=`find $ROOT -name "*.gcno"`
 $GCOV --preserve-paths --relative-only --no-output $GCNO_FILES 2>/dev/null |
@@ -31,15 +31,16 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
 }

 void ArenaWrappedDBIter::Init(
-    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    Env* env, const ReadOptions& read_options,
+    const ImmutableOptions& cf_options,
    const MutableCFOptions& mutable_cf_options, const Version* version,
    const SequenceNumber& sequence, uint64_t max_sequential_skip_in_iteration,
    uint64_t version_number, ReadCallback* read_callback, DBImpl* db_impl,
    ColumnFamilyData* cfd, bool expose_blob_index, bool allow_refresh) {
  auto mem = arena_.AllocateAligned(sizeof(DBIter));
  db_iter_ =
-      new (mem) DBIter(env, read_options, ioptions, mutable_cf_options,
-                       ioptions.user_comparator, /* iter */ nullptr, version,
+      new (mem) DBIter(env, read_options, cf_options, mutable_cf_options,
+                       cf_options.user_comparator, /* iter */ nullptr, version,
                       sequence, true, max_sequential_skip_in_iteration,
                       read_callback, db_impl, cfd, expose_blob_index);
  sv_number_ = version_number;
@@ -87,15 +88,16 @@ Status ArenaWrappedDBIter::Refresh() {
 }

 ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    Env* env, const ReadOptions& read_options,
+    const ImmutableOptions& cf_options,
    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, DBImpl* db_impl,
    ColumnFamilyData* cfd, 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,
-             db_impl, cfd, expose_blob_index, allow_refresh);
+  iter->Init(env, read_options, cf_options, mutable_cf_options, version,
+             sequence, max_sequential_skip_in_iterations, version_number,
+             read_callback, db_impl, cfd, expose_blob_index, allow_refresh);
  if (db_impl != nullptr && cfd != nullptr && allow_refresh) {
    iter->StoreRefreshInfo(db_impl, cfd, read_callback, expose_blob_index);
  }
@@ -34,13 +34,7 @@ class Version;
 // the same as the inner DBIter.
 class ArenaWrappedDBIter : public Iterator {
 public:
-  virtual ~ArenaWrappedDBIter() {
-    if (db_iter_ != nullptr) {
-      db_iter_->~DBIter();
-    } else {
-      assert(false);
-    }
-  }
+  virtual ~ArenaWrappedDBIter() { db_iter_->~DBIter(); }

  // Get the arena to be used to allocate memory for DBIter to be wrapped,
  // as well as child iterators in it.
@@ -78,7 +72,7 @@ class ArenaWrappedDBIter : public Iterator {
  Status Refresh() override;

  void Init(Env* env, const ReadOptions& read_options,
-            const ImmutableOptions& ioptions,
+            const ImmutableOptions& cf_options,
            const MutableCFOptions& mutable_cf_options, const Version* version,
            const SequenceNumber& sequence,
            uint64_t max_sequential_skip_in_iterations, uint64_t version_number,
@@ -96,7 +90,7 @@ class ArenaWrappedDBIter : public Iterator {
  }

 private:
-  DBIter* db_iter_ = nullptr;
+  DBIter* db_iter_;
  Arena arena_;
  uint64_t sv_number_;
  ColumnFamilyData* cfd_ = nullptr;
@@ -111,7 +105,8 @@ class ArenaWrappedDBIter : public Iterator {
 // `db_impl` and `cfd` are used for reneweal. If left null, renewal will not
 // be supported.
 extern ArenaWrappedDBIter* NewArenaWrappedDbIterator(
-    Env* env, const ReadOptions& read_options, const ImmutableOptions& ioptions,
+    Env* env, const ReadOptions& read_options,
+    const ImmutableOptions& cf_options,
    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,
@@ -1,146 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cassert>
-
-#include "db/blob/blob_garbage_meter.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/status.h"
-#include "table/internal_iterator.h"
-#include "test_util/sync_point.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// An internal iterator that passes each key-value encountered to
-// BlobGarbageMeter as inflow in order to measure the total number and size of
-// blobs in the compaction input on a per-blob file basis.
-class BlobCountingIterator : public InternalIterator {
- public:
-  BlobCountingIterator(InternalIterator* iter,
-                       BlobGarbageMeter* blob_garbage_meter)
-      : iter_(iter), blob_garbage_meter_(blob_garbage_meter) {
-    assert(iter_);
-    assert(blob_garbage_meter_);
-
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  bool Valid() const override { return iter_->Valid() && status_.ok(); }
-
-  void SeekToFirst() override {
-    iter_->SeekToFirst();
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  void SeekToLast() override {
-    iter_->SeekToLast();
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  void Seek(const Slice& target) override {
-    iter_->Seek(target);
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  void SeekForPrev(const Slice& target) override {
-    iter_->SeekForPrev(target);
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  void Next() override {
-    assert(Valid());
-
-    iter_->Next();
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  bool NextAndGetResult(IterateResult* result) override {
-    assert(Valid());
-
-    const bool res = iter_->NextAndGetResult(result);
-    UpdateAndCountBlobIfNeeded();
-    return res;
-  }
-
-  void Prev() override {
-    assert(Valid());
-
-    iter_->Prev();
-    UpdateAndCountBlobIfNeeded();
-  }
-
-  Slice key() const override {
-    assert(Valid());
-    return iter_->key();
-  }
-
-  Slice user_key() const override {
-    assert(Valid());
-    return iter_->user_key();
-  }
-
-  Slice value() const override {
-    assert(Valid());
-    return iter_->value();
-  }
-
-  Status status() const override { return status_; }
-
-  bool PrepareValue() override {
-    assert(Valid());
-    return iter_->PrepareValue();
-  }
-
-  bool MayBeOutOfLowerBound() override {
-    assert(Valid());
-    return iter_->MayBeOutOfLowerBound();
-  }
-
-  IterBoundCheck UpperBoundCheckResult() override {
-    assert(Valid());
-    return iter_->UpperBoundCheckResult();
-  }
-
-  void SetPinnedItersMgr(PinnedIteratorsManager* pinned_iters_mgr) override {
-    iter_->SetPinnedItersMgr(pinned_iters_mgr);
-  }
-
-  bool IsKeyPinned() const override {
-    assert(Valid());
-    return iter_->IsKeyPinned();
-  }
-
-  bool IsValuePinned() const override {
-    assert(Valid());
-    return iter_->IsValuePinned();
-  }
-
-  Status GetProperty(std::string prop_name, std::string* prop) override {
-    return iter_->GetProperty(prop_name, prop);
-  }
-
- private:
-  void UpdateAndCountBlobIfNeeded() {
-    assert(!iter_->Valid() || iter_->status().ok());
-
-    if (!iter_->Valid()) {
-      status_ = iter_->status();
-      return;
-    }
-
-    TEST_SYNC_POINT(
-        "BlobCountingIterator::UpdateAndCountBlobIfNeeded:ProcessInFlow");
-
-    status_ = blob_garbage_meter_->ProcessInFlow(key(), value());
-  }
-
-  InternalIterator* iter_;
-  BlobGarbageMeter* blob_garbage_meter_;
-  Status status_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,325 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_counting_iterator.h"
-
-#include <string>
-#include <vector>
-
-#include "db/blob/blob_garbage_meter.h"
-#include "db/blob/blob_index.h"
-#include "db/blob/blob_log_format.h"
-#include "db/dbformat.h"
-#include "test_util/testharness.h"
-#include "test_util/testutil.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-void CheckInFlow(const BlobGarbageMeter& blob_garbage_meter,
-                 uint64_t blob_file_number, uint64_t count, uint64_t bytes) {
-  const auto& flows = blob_garbage_meter.flows();
-
-  const auto it = flows.find(blob_file_number);
-  if (it == flows.end()) {
-    ASSERT_EQ(count, 0);
-    ASSERT_EQ(bytes, 0);
-    return;
-  }
-
-  const auto& in = it->second.GetInFlow();
-
-  ASSERT_EQ(in.GetCount(), count);
-  ASSERT_EQ(in.GetBytes(), bytes);
-}
-
-TEST(BlobCountingIteratorTest, CountBlobs) {
-  // Note: the input consists of three key-values: two are blob references to
-  // different blob files, while the third one is a plain value.
-  constexpr char user_key0[] = "key0";
-  constexpr char user_key1[] = "key1";
-  constexpr char user_key2[] = "key2";
-
-  const std::vector<std::string> keys{
-      test::KeyStr(user_key0, 1, kTypeBlobIndex),
-      test::KeyStr(user_key1, 2, kTypeBlobIndex),
-      test::KeyStr(user_key2, 3, kTypeValue)};
-
-  constexpr uint64_t first_blob_file_number = 4;
-  constexpr uint64_t first_offset = 1000;
-  constexpr uint64_t first_size = 2000;
-
-  std::string first_blob_index;
-  BlobIndex::EncodeBlob(&first_blob_index, first_blob_file_number, first_offset,
-                        first_size, kNoCompression);
-
-  constexpr uint64_t second_blob_file_number = 6;
-  constexpr uint64_t second_offset = 2000;
-  constexpr uint64_t second_size = 4000;
-
-  std::string second_blob_index;
-  BlobIndex::EncodeBlob(&second_blob_index, second_blob_file_number,
-                        second_offset, second_size, kNoCompression);
-
-  const std::vector<std::string> values{first_blob_index, second_blob_index,
-                                        "raw_value"};
-
-  assert(keys.size() == values.size());
-
-  test::VectorIterator input(keys, values);
-  BlobGarbageMeter blob_garbage_meter;
-
-  BlobCountingIterator blob_counter(&input, &blob_garbage_meter);
-
-  constexpr uint64_t first_expected_bytes =
-      first_size +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(user_key0) - 1);
-  constexpr uint64_t second_expected_bytes =
-      second_size +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(user_key1) - 1);
-
-  // Call SeekToFirst and iterate forward
-  blob_counter.SeekToFirst();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[0]);
-  ASSERT_EQ(blob_counter.user_key(), user_key0);
-  ASSERT_EQ(blob_counter.value(), values[0]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 1,
-              first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 0, 0);
-
-  blob_counter.Next();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[1]);
-  ASSERT_EQ(blob_counter.user_key(), user_key1);
-  ASSERT_EQ(blob_counter.value(), values[1]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 1,
-              first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 1,
-              second_expected_bytes);
-
-  blob_counter.Next();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[2]);
-  ASSERT_EQ(blob_counter.user_key(), user_key2);
-  ASSERT_EQ(blob_counter.value(), values[2]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 1,
-              first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 1,
-              second_expected_bytes);
-
-  blob_counter.Next();
-  ASSERT_FALSE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 1,
-              first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 1,
-              second_expected_bytes);
-
-  // Do it again using NextAndGetResult
-  blob_counter.SeekToFirst();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[0]);
-  ASSERT_EQ(blob_counter.user_key(), user_key0);
-  ASSERT_EQ(blob_counter.value(), values[0]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-              2 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 1,
-              second_expected_bytes);
-
-  {
-    IterateResult result;
-    ASSERT_TRUE(blob_counter.NextAndGetResult(&result));
-    ASSERT_EQ(result.key, keys[1]);
-    ASSERT_EQ(blob_counter.user_key(), user_key1);
-    ASSERT_TRUE(blob_counter.Valid());
-    ASSERT_OK(blob_counter.status());
-    ASSERT_EQ(blob_counter.key(), keys[1]);
-    ASSERT_EQ(blob_counter.value(), values[1]);
-    CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-                2 * first_expected_bytes);
-    CheckInFlow(blob_garbage_meter, second_blob_file_number, 2,
-                2 * second_expected_bytes);
-  }
-
-  {
-    IterateResult result;
-    ASSERT_TRUE(blob_counter.NextAndGetResult(&result));
-    ASSERT_EQ(result.key, keys[2]);
-    ASSERT_EQ(blob_counter.user_key(), user_key2);
-    ASSERT_TRUE(blob_counter.Valid());
-    ASSERT_OK(blob_counter.status());
-    ASSERT_EQ(blob_counter.key(), keys[2]);
-    ASSERT_EQ(blob_counter.value(), values[2]);
-    CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-                2 * first_expected_bytes);
-    CheckInFlow(blob_garbage_meter, second_blob_file_number, 2,
-                2 * second_expected_bytes);
-  }
-
-  {
-    IterateResult result;
-    ASSERT_FALSE(blob_counter.NextAndGetResult(&result));
-    ASSERT_FALSE(blob_counter.Valid());
-    ASSERT_OK(blob_counter.status());
-    CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-                2 * first_expected_bytes);
-    CheckInFlow(blob_garbage_meter, second_blob_file_number, 2,
-                2 * second_expected_bytes);
-  }
-
-  // Call SeekToLast and iterate backward
-  blob_counter.SeekToLast();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[2]);
-  ASSERT_EQ(blob_counter.user_key(), user_key2);
-  ASSERT_EQ(blob_counter.value(), values[2]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-              2 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 2,
-              2 * second_expected_bytes);
-
-  blob_counter.Prev();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[1]);
-  ASSERT_EQ(blob_counter.user_key(), user_key1);
-  ASSERT_EQ(blob_counter.value(), values[1]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 2,
-              2 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 3,
-              3 * second_expected_bytes);
-
-  blob_counter.Prev();
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[0]);
-  ASSERT_EQ(blob_counter.user_key(), user_key0);
-  ASSERT_EQ(blob_counter.value(), values[0]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 3,
-              3 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 3,
-              3 * second_expected_bytes);
-
-  blob_counter.Prev();
-  ASSERT_FALSE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 3,
-              3 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 3,
-              3 * second_expected_bytes);
-
-  // Call Seek for all keys (plus one that's greater than all of them)
-  blob_counter.Seek(keys[0]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[0]);
-  ASSERT_EQ(blob_counter.user_key(), user_key0);
-  ASSERT_EQ(blob_counter.value(), values[0]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 4,
-              4 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 3,
-              3 * second_expected_bytes);
-
-  blob_counter.Seek(keys[1]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[1]);
-  ASSERT_EQ(blob_counter.user_key(), user_key1);
-  ASSERT_EQ(blob_counter.value(), values[1]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 4,
-              4 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 4,
-              4 * second_expected_bytes);
-
-  blob_counter.Seek(keys[2]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[2]);
-  ASSERT_EQ(blob_counter.user_key(), user_key2);
-  ASSERT_EQ(blob_counter.value(), values[2]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 4,
-              4 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 4,
-              4 * second_expected_bytes);
-
-  blob_counter.Seek("zzz");
-  ASSERT_FALSE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 4,
-              4 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 4,
-              4 * second_expected_bytes);
-
-  // Call SeekForPrev for all keys (plus one that's less than all of them)
-  blob_counter.SeekForPrev("aaa");
-  ASSERT_FALSE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 4,
-              4 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 4,
-              4 * second_expected_bytes);
-
-  blob_counter.SeekForPrev(keys[0]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[0]);
-  ASSERT_EQ(blob_counter.user_key(), user_key0);
-  ASSERT_EQ(blob_counter.value(), values[0]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 5,
-              5 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 4,
-              4 * second_expected_bytes);
-
-  blob_counter.SeekForPrev(keys[1]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[1]);
-  ASSERT_EQ(blob_counter.user_key(), user_key1);
-  ASSERT_EQ(blob_counter.value(), values[1]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 5,
-              5 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 5,
-              5 * second_expected_bytes);
-
-  blob_counter.SeekForPrev(keys[2]);
-  ASSERT_TRUE(blob_counter.Valid());
-  ASSERT_OK(blob_counter.status());
-  ASSERT_EQ(blob_counter.key(), keys[2]);
-  ASSERT_EQ(blob_counter.user_key(), user_key2);
-  ASSERT_EQ(blob_counter.value(), values[2]);
-  CheckInFlow(blob_garbage_meter, first_blob_file_number, 5,
-              5 * first_expected_bytes);
-  CheckInFlow(blob_garbage_meter, second_blob_file_number, 5,
-              5 * second_expected_bytes);
-}
-
-TEST(BlobCountingIteratorTest, CorruptBlobIndex) {
-  const std::vector<std::string> keys{
-      test::KeyStr("user_key", 1, kTypeBlobIndex)};
-  const std::vector<std::string> values{"i_am_not_a_blob_index"};
-
-  assert(keys.size() == values.size());
-
-  test::VectorIterator input(keys, values);
-  BlobGarbageMeter blob_garbage_meter;
-
-  BlobCountingIterator blob_counter(&input, &blob_garbage_meter);
-
-  blob_counter.SeekToFirst();
-  ASSERT_FALSE(blob_counter.Valid());
-  ASSERT_NOK(blob_counter.status());
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -1,22 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_fetcher.h"
-
-#include "db/version_set.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-Status BlobFetcher::FetchBlob(const Slice& user_key, const Slice& blob_index,
-                              PinnableSlice* blob_value) {
-  Status s;
-  assert(version_);
-  constexpr uint64_t* bytes_read = nullptr;
-  s = version_->GetBlob(read_options_, user_key, blob_index, blob_value,
-                        bytes_read);
-  return s;
-}
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,26 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include "rocksdb/options.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-class Version;
-
-class BlobFetcher {
- public:
-  BlobFetcher(Version* version, const ReadOptions& read_options)
-      : version_(version), read_options_(read_options) {}
-
-  Status FetchBlob(const Slice& user_key, const Slice& blob_index,
-                   PinnableSlice* blob_value);
-
- private:
-  Version* version_;
-  ReadOptions read_options_;
-};
-}  // namespace ROCKSDB_NAMESPACE
@@ -135,8 +135,7 @@ std::ostream& operator<<(std::ostream& os,
     << " total_blob_count: " << blob_file_addition.GetTotalBlobCount()
     << " total_blob_bytes: " << blob_file_addition.GetTotalBlobBytes()
     << " checksum_method: " << blob_file_addition.GetChecksumMethod()
-     << " checksum_value: "
-     << Slice(blob_file_addition.GetChecksumValue()).ToString(/* hex */ true);
+     << " checksum_value: " << blob_file_addition.GetChecksumValue();

  return os;
 }
@@ -147,8 +146,7 @@ JSONWriter& operator<<(JSONWriter& jw,
     << "TotalBlobCount" << blob_file_addition.GetTotalBlobCount()
     << "TotalBlobBytes" << blob_file_addition.GetTotalBlobBytes()
     << "ChecksumMethod" << blob_file_addition.GetChecksumMethod()
-     << "ChecksumValue"
-     << Slice(blob_file_addition.GetChecksumValue()).ToString(/* hex */ true);
+     << "ChecksumValue" << blob_file_addition.GetChecksumValue();

  return jw;
 }
@@ -46,9 +46,7 @@ TEST_F(BlobFileAdditionTest, NonEmpty) {
  constexpr uint64_t total_blob_count = 2;
  constexpr uint64_t total_blob_bytes = 123456;
  const std::string checksum_method("SHA1");
-  const std::string checksum_value(
-      "\xbd\xb7\xf3\x4a\x59\xdf\xa1\x59\x2c\xe7\xf5\x2e\x99\xf9\x8c\x57\x0c\x52"
-      "\x5c\xbd");
+  const std::string checksum_value("bdb7f34a59dfa1592ce7f52e99f98c570c525cbd");

  BlobFileAddition blob_file_addition(blob_file_number, total_blob_count,
                                      total_blob_bytes, checksum_method,
@@ -115,9 +113,7 @@ TEST_F(BlobFileAdditionTest, DecodeErrors) {
    ASSERT_TRUE(std::strstr(s.getState(), "checksum value"));
  }

-  constexpr char checksum_value[] =
-      "\xbd\xb7\xf3\x4a\x59\xdf\xa1\x59\x2c\xe7\xf5\x2e\x99\xf9\x8c\x57\x0c\x52"
-      "\x5c\xbd";
+  constexpr char checksum_value[] = "bdb7f34a59dfa1592ce7f52e99f98c570c525cbd";
  PutLengthPrefixedSlice(&str, checksum_value);
  slice = str;

@@ -154,7 +150,7 @@ TEST_F(BlobFileAdditionTest, ForwardCompatibleCustomField) {
  constexpr uint64_t total_blob_count = 9999;
  constexpr uint64_t total_blob_bytes = 100000000;
  const std::string checksum_method("CRC32");
-  const std::string checksum_value("\x3d\x87\xff\x57");
+  const std::string checksum_value("3d87ff57");

  BlobFileAddition blob_file_addition(blob_file_number, total_blob_count,
                                      total_blob_bytes, checksum_method,
@@ -182,7 +178,7 @@ TEST_F(BlobFileAdditionTest, ForwardIncompatibleCustomField) {
  constexpr uint64_t total_blob_count = 100;
  constexpr uint64_t total_blob_bytes = 2000000;
  const std::string checksum_method("CRC32B");
-  const std::string checksum_value("\x6d\xbd\xf2\x3a");
+  const std::string checksum_value("6dbdf23a");

  BlobFileAddition blob_file_addition(blob_file_number, total_blob_count,
                                      total_blob_bytes, checksum_method,
@@ -12,7 +12,6 @@
 #include "db/blob/blob_index.h"
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
-#include "db/event_helpers.h"
 #include "db/version_set.h"
 #include "file/filename.h"
 #include "file/read_write_util.h"
@@ -30,37 +29,35 @@ namespace ROCKSDB_NAMESPACE {

 BlobFileBuilder::BlobFileBuilder(
    VersionSet* versions, FileSystem* fs,
-    const ImmutableOptions* immutable_options,
+    const ImmutableOptions* immutable_cf_options,
    const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
    int job_id, uint32_t column_family_id,
    const std::string& column_family_name, Env::IOPriority io_priority,
    Env::WriteLifeTimeHint write_hint,
    const std::shared_ptr<IOTracer>& io_tracer,
    BlobFileCompletionCallback* blob_callback,
-    BlobFileCreationReason creation_reason,
    std::vector<std::string>* blob_file_paths,
    std::vector<BlobFileAddition>* blob_file_additions)
    : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs,
-                      immutable_options, mutable_cf_options, file_options,
+                      immutable_cf_options, mutable_cf_options, file_options,
                      job_id, column_family_id, column_family_name, io_priority,
-                      write_hint, io_tracer, blob_callback, creation_reason,
-                      blob_file_paths, blob_file_additions) {}
+                      write_hint, io_tracer, blob_callback, blob_file_paths,
+                      blob_file_additions) {}

 BlobFileBuilder::BlobFileBuilder(
    std::function<uint64_t()> file_number_generator, FileSystem* fs,
-    const ImmutableOptions* immutable_options,
+    const ImmutableOptions* immutable_cf_options,
    const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
    int job_id, uint32_t column_family_id,
    const std::string& column_family_name, Env::IOPriority io_priority,
    Env::WriteLifeTimeHint write_hint,
    const std::shared_ptr<IOTracer>& io_tracer,
    BlobFileCompletionCallback* blob_callback,
-    BlobFileCreationReason creation_reason,
    std::vector<std::string>* blob_file_paths,
    std::vector<BlobFileAddition>* blob_file_additions)
    : file_number_generator_(std::move(file_number_generator)),
      fs_(fs),
-      immutable_options_(immutable_options),
+      immutable_cf_options_(immutable_cf_options),
      min_blob_size_(mutable_cf_options->min_blob_size),
      blob_file_size_(mutable_cf_options->blob_file_size),
      blob_compression_type_(mutable_cf_options->blob_compression_type),
@@ -72,14 +69,13 @@ BlobFileBuilder::BlobFileBuilder(
      write_hint_(write_hint),
      io_tracer_(io_tracer),
      blob_callback_(blob_callback),
-      creation_reason_(creation_reason),
      blob_file_paths_(blob_file_paths),
      blob_file_additions_(blob_file_additions),
      blob_count_(0),
      blob_bytes_(0) {
  assert(file_number_generator_);
  assert(fs_);
-  assert(immutable_options_);
+  assert(immutable_cf_options_);
  assert(file_options_);
  assert(blob_file_paths_);
  assert(blob_file_paths_->empty());
@@ -160,15 +156,10 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
  assert(file_number_generator_);
  const uint64_t blob_file_number = file_number_generator_();

-  assert(immutable_options_);
-  assert(!immutable_options_->cf_paths.empty());
-  std::string blob_file_path =
-      BlobFileName(immutable_options_->cf_paths.front().path, blob_file_number);
-
-  if (blob_callback_) {
-    blob_callback_->OnBlobFileCreationStarted(
-        blob_file_path, column_family_name_, job_id_, creation_reason_);
-  }
+  assert(immutable_cf_options_);
+  assert(!immutable_cf_options_->cf_paths.empty());
+  std::string blob_file_path = BlobFileName(
+      immutable_cf_options_->cf_paths.front().path, blob_file_number);

  std::unique_ptr<FSWritableFile> file;

@@ -193,20 +184,20 @@ Status BlobFileBuilder::OpenBlobFileIfNeeded() {
  assert(file);
  file->SetIOPriority(io_priority_);
  file->SetWriteLifeTimeHint(write_hint_);
-  FileTypeSet tmp_set = immutable_options_->checksum_handoff_file_types;
-  Statistics* const statistics = immutable_options_->stats;
+  FileTypeSet tmp_set = immutable_cf_options_->checksum_handoff_file_types;
+  Statistics* const statistics = immutable_cf_options_->stats;
  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
      std::move(file), blob_file_paths_->back(), *file_options_,
-      immutable_options_->clock, io_tracer_, statistics,
-      immutable_options_->listeners,
-      immutable_options_->file_checksum_gen_factory.get(),
-      tmp_set.Contains(FileType::kBlobFile), false));
+      immutable_cf_options_->clock, io_tracer_, statistics,
+      immutable_cf_options_->listeners,
+      immutable_cf_options_->file_checksum_gen_factory.get(),
+      tmp_set.Contains(FileType::kBlobFile)));

  constexpr bool do_flush = false;

  std::unique_ptr<BlobLogWriter> blob_log_writer(new BlobLogWriter(
-      std::move(file_writer), immutable_options_->clock, statistics,
-      blob_file_number, immutable_options_->use_fsync, do_flush));
+      std::move(file_writer), immutable_cf_options_->clock, statistics,
+      blob_file_number, immutable_cf_options_->use_fsync, do_flush));

  constexpr bool has_ttl = false;
  constexpr ExpirationRange expiration_range;
@@ -237,7 +228,6 @@ Status BlobFileBuilder::CompressBlobIfNeeded(
  assert(blob);
  assert(compressed_blob);
  assert(compressed_blob->empty());
-  assert(immutable_options_);

  if (blob_compression_type_ == kNoCompression) {
    return Status::OK();
@@ -252,16 +242,7 @@ Status BlobFileBuilder::CompressBlobIfNeeded(

  constexpr uint32_t compression_format_version = 2;

-  bool success = false;
-
-  {
-    StopWatch stop_watch(immutable_options_->clock, immutable_options_->stats,
-                         BLOB_DB_COMPRESSION_MICROS);
-    success =
-        CompressData(*blob, info, compression_format_version, compressed_blob);
-  }
-
-  if (!success) {
+  if (!CompressData(*blob, info, compression_format_version, compressed_blob)) {
    return Status::Corruption("Error compressing blob");
  }

@@ -314,24 +295,20 @@ Status BlobFileBuilder::CloseBlobFile() {

  const uint64_t blob_file_number = writer_->get_log_number();

-  if (blob_callback_) {
-    s = blob_callback_->OnBlobFileCompleted(
-        blob_file_paths_->back(), column_family_name_, job_id_,
-        blob_file_number, creation_reason_, s, checksum_value, checksum_method,
-        blob_count_, blob_bytes_);
-  }
-
  assert(blob_file_additions_);
  blob_file_additions_->emplace_back(blob_file_number, blob_count_, blob_bytes_,
                                     std::move(checksum_method),
                                     std::move(checksum_value));

-  assert(immutable_options_);
-  ROCKS_LOG_INFO(immutable_options_->logger,
+  assert(immutable_cf_options_);
+  ROCKS_LOG_INFO(immutable_cf_options_->logger,
                 "[%s] [JOB %d] Generated blob file #%" PRIu64 ": %" PRIu64
                 " total blobs, %" PRIu64 " total bytes",
                 column_family_name_.c_str(), job_id_, blob_file_number,
                 blob_count_, blob_bytes_);
+  if (blob_callback_) {
+    s = blob_callback_->OnBlobFileCompleted(blob_file_paths_->back());
+  }

  writer_.reset();
  blob_count_ = 0;
@@ -353,18 +330,15 @@ Status BlobFileBuilder::CloseBlobFileIfNeeded() {
  return CloseBlobFile();
 }

-void BlobFileBuilder::Abandon(const Status& s) {
+void BlobFileBuilder::Abandon() {
  if (!IsBlobFileOpen()) {
    return;
  }
+
  if (blob_callback_) {
    // BlobFileBuilder::Abandon() is called because of error while writing to
    // Blob files. So we can ignore the below error.
-    blob_callback_
-        ->OnBlobFileCompleted(blob_file_paths_->back(), column_family_name_,
-                              job_id_, writer_->get_log_number(),
-                              creation_reason_, s, "", "", blob_count_,
-                              blob_bytes_)
+    blob_callback_->OnBlobFileCompleted(blob_file_paths_->back())
        .PermitUncheckedError();
  }

@@ -13,7 +13,6 @@
 #include "rocksdb/compression_type.h"
 #include "rocksdb/env.h"
 #include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/types.h"

 namespace ROCKSDB_NAMESPACE {

@@ -42,7 +41,6 @@ class BlobFileBuilder {
                  Env::WriteLifeTimeHint write_hint,
                  const std::shared_ptr<IOTracer>& io_tracer,
                  BlobFileCompletionCallback* blob_callback,
-                  BlobFileCreationReason creation_reason,
                  std::vector<std::string>* blob_file_paths,
                  std::vector<BlobFileAddition>* blob_file_additions);

@@ -56,7 +54,6 @@ class BlobFileBuilder {
                  Env::WriteLifeTimeHint write_hint,
                  const std::shared_ptr<IOTracer>& io_tracer,
                  BlobFileCompletionCallback* blob_callback,
-                  BlobFileCreationReason creation_reason,
                  std::vector<std::string>* blob_file_paths,
                  std::vector<BlobFileAddition>* blob_file_additions);

@@ -67,7 +64,7 @@ class BlobFileBuilder {

  Status Add(const Slice& key, const Slice& value, std::string* blob_index);
  Status Finish();
-  void Abandon(const Status& s);
+  void Abandon();

 private:
  bool IsBlobFileOpen() const;
@@ -80,7 +77,7 @@ class BlobFileBuilder {

  std::function<uint64_t()> file_number_generator_;
  FileSystem* fs_;
-  const ImmutableOptions* immutable_options_;
+  const ImmutableOptions* immutable_cf_options_;
  uint64_t min_blob_size_;
  uint64_t blob_file_size_;
  CompressionType blob_compression_type_;
@@ -92,7 +89,6 @@ class BlobFileBuilder {
  Env::WriteLifeTimeHint write_hint_;
  std::shared_ptr<IOTracer> io_tracer_;
  BlobFileCompletionCallback* blob_callback_;
-  BlobFileCreationReason creation_reason_;
  std::vector<std::string>* blob_file_paths_;
  std::vector<BlobFileAddition>* blob_file_additions_;
  std::unique_ptr<BlobLogWriter> writer_;
@@ -129,7 +129,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
  options.enable_blob_files = true;
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -141,11 +141,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
      number_of_blobs);
@@ -177,9 +178,9 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {

  const std::string& blob_file_path = blob_file_paths[0];

-  ASSERT_EQ(
-      blob_file_path,
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
+  ASSERT_EQ(blob_file_path,
+            BlobFileName(immutable_cf_options.cf_paths.front().path,
+                         blob_file_number));

  ASSERT_EQ(blob_file_additions.size(), 1);

@@ -213,7 +214,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
  options.blob_file_size = value_size;
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -225,11 +226,12 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
      number_of_blobs);
@@ -262,7 +264,7 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
    const uint64_t blob_file_number = i + 2;

    ASSERT_EQ(blob_file_paths[i],
-              BlobFileName(immutable_options.cf_paths.front().path,
+              BlobFileName(immutable_cf_options.cf_paths.front().path,
                           blob_file_number));

    const auto& blob_file_addition = blob_file_additions[i];
@@ -299,7 +301,7 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
  options.min_blob_size = 1024;
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -311,11 +313,12 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  for (size_t i = 0; i < number_of_blobs; ++i) {
    const std::string key = std::to_string(i);
@@ -352,7 +355,7 @@ TEST_F(BlobFileBuilderTest, Compression) {
  options.blob_compression_type = kSnappyCompression;
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -364,11 +367,12 @@ TEST_F(BlobFileBuilderTest, Compression) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  const std::string key("1");
  const std::string uncompressed_value(value_size, 'x');
@@ -387,9 +391,9 @@ TEST_F(BlobFileBuilderTest, Compression) {

  const std::string& blob_file_path = blob_file_paths[0];

-  ASSERT_EQ(
-      blob_file_path,
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
+  ASSERT_EQ(blob_file_path,
+            BlobFileName(immutable_cf_options.cf_paths.front().path,
+                         blob_file_number));

  ASSERT_EQ(blob_file_additions.size(), 1);

@@ -434,7 +438,7 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
  options.enable_blob_files = true;
  options.blob_compression_type = kSnappyCompression;
  options.env = &mock_env_;
-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -446,11 +450,12 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue",
                                        [](void* arg) {
@@ -472,9 +477,9 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
  constexpr uint64_t blob_file_number = 2;

  ASSERT_EQ(blob_file_paths.size(), 1);
-  ASSERT_EQ(
-      blob_file_paths[0],
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
+  ASSERT_EQ(blob_file_paths[0],
+            BlobFileName(immutable_cf_options.cf_paths.front().path,
+                         blob_file_number));

  ASSERT_TRUE(blob_file_additions.empty());
 }
@@ -512,7 +517,7 @@ TEST_F(BlobFileBuilderTest, Checksum) {
      std::make_shared<DummyFileChecksumGenFactory>();
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -524,11 +529,12 @@ TEST_F(BlobFileBuilderTest, Checksum) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  const std::string key("1");
  const std::string value("deadbeef");
@@ -547,9 +553,9 @@ TEST_F(BlobFileBuilderTest, Checksum) {

  const std::string& blob_file_path = blob_file_paths[0];

-  ASSERT_EQ(
-      blob_file_path,
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number));
+  ASSERT_EQ(blob_file_path,
+            BlobFileName(immutable_cf_options.cf_paths.front().path,
+                         blob_file_number));

  ASSERT_EQ(blob_file_additions.size(), 1);

@@ -608,7 +614,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
  options.blob_file_size = value_size;
  options.env = &mock_env_;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  MutableCFOptions mutable_cf_options(options);

  constexpr int job_id = 1;
@@ -620,11 +626,12 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
  std::vector<std::string> blob_file_paths;
  std::vector<BlobFileAddition> blob_file_additions;

-  BlobFileBuilder builder(
-      TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, job_id, column_family_id, column_family_name, io_priority,
-      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
-      BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
+  BlobFileBuilder builder(TestFileNumberGenerator(), fs_, &immutable_cf_options,
+                          &mutable_cf_options, &file_options_, job_id,
+                          column_family_id, column_family_name, io_priority,
+                          write_hint, nullptr /*IOTracer*/,
+                          nullptr /*BlobFileCompletionCallback*/,
+                          &blob_file_paths, &blob_file_additions);

  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) {
    Status* const s = static_cast<Status*>(arg);
@@ -651,7 +658,7 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {

    ASSERT_EQ(blob_file_paths.size(), 1);
    ASSERT_EQ(blob_file_paths[0],
-              BlobFileName(immutable_options.cf_paths.front().path,
+              BlobFileName(immutable_cf_options.cf_paths.front().path,
                           blob_file_number));
  }

@@ -26,13 +26,13 @@ BlobFileCache::BlobFileCache(Cache* cache,
                             const std::shared_ptr<IOTracer>& io_tracer)
    : cache_(cache),
      mutex_(kNumberOfMutexStripes, kGetSliceNPHash64UnseededFnPtr),
-      immutable_options_(immutable_options),
+      immutable_cf_options_(immutable_options),
      file_options_(file_options),
      column_family_id_(column_family_id),
      blob_file_read_hist_(blob_file_read_hist),
      io_tracer_(io_tracer) {
  assert(cache_);
-  assert(immutable_options_);
+  assert(immutable_cf_options_);
  assert(file_options_);
 }

@@ -63,8 +63,8 @@ Status BlobFileCache::GetBlobFileReader(
    return Status::OK();
  }

-  assert(immutable_options_);
-  Statistics* const statistics = immutable_options_->stats;
+  assert(immutable_cf_options_);
+  Statistics* const statistics = immutable_cf_options_->stats;

  RecordTick(statistics, NO_FILE_OPENS);

@@ -73,7 +73,7 @@ Status BlobFileCache::GetBlobFileReader(
  {
    assert(file_options_);
    const Status s = BlobFileReader::Create(
-        *immutable_options_, *file_options_, column_family_id_,
+        *immutable_cf_options_, *file_options_, column_family_id_,
        blob_file_read_hist_, blob_file_number, io_tracer_, &reader);
    if (!s.ok()) {
      RecordTick(statistics, NO_FILE_ERRORS);
@@ -40,7 +40,7 @@ class BlobFileCache {
  // Note: mutex_ below is used to guard against multiple threads racing to open
  // the same file.
  Striped<port::Mutex, Slice> mutex_;
-  const ImmutableOptions* immutable_options_;
+  const ImmutableOptions* immutable_cf_options_;
  const FileOptions* file_options_;
  uint32_t column_family_id_;
  HistogramImpl* blob_file_read_hist_;
@@ -29,27 +29,28 @@ namespace {

 // Creates a test blob file with a single blob in it.
 void WriteBlobFile(uint32_t column_family_id,
-                   const ImmutableOptions& immutable_options,
+                   const ImmutableOptions& immutable_cf_options,
                   uint64_t blob_file_number) {
-  assert(!immutable_options.cf_paths.empty());
+  assert(!immutable_cf_options.cf_paths.empty());

-  const std::string blob_file_path =
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
+  const std::string blob_file_path = BlobFileName(
+      immutable_cf_options.cf_paths.front().path, blob_file_number);

  std::unique_ptr<FSWritableFile> file;
-  ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
-                            FileOptions()));
+  ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path,
+                            &file, FileOptions()));

-  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-      std::move(file), blob_file_path, FileOptions(), immutable_options.clock));
+  std::unique_ptr<WritableFileWriter> file_writer(
+      new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
+                             immutable_cf_options.clock));

  constexpr Statistics* statistics = nullptr;
  constexpr bool use_fsync = false;
  constexpr bool do_flush = false;

-  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+  BlobLogWriter blob_log_writer(std::move(file_writer),
+                                immutable_cf_options.clock, statistics,
+                                blob_file_number, use_fsync, do_flush);

  constexpr bool has_ttl = false;
  constexpr ExpirationRange expiration_range;
@@ -99,10 +100,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) {
  options.enable_blob_files = true;

  constexpr uint32_t column_family_id = 1;
-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  constexpr uint64_t blob_file_number = 123;

-  WriteBlobFile(column_family_id, immutable_options, blob_file_number);
+  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);

  constexpr size_t capacity = 10;
  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
@@ -110,7 +111,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader) {
  FileOptions file_options;
  constexpr HistogramImpl* blob_file_read_hist = nullptr;

-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
+  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
                                &file_options, column_family_id,
                                blob_file_read_hist, nullptr /*IOTracer*/);

@@ -144,10 +145,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) {
  options.enable_blob_files = true;

  constexpr uint32_t column_family_id = 1;
-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  constexpr uint64_t blob_file_number = 123;

-  WriteBlobFile(column_family_id, immutable_options, blob_file_number);
+  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);

  constexpr size_t capacity = 10;
  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
@@ -155,7 +156,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_Race) {
  FileOptions file_options;
  constexpr HistogramImpl* blob_file_read_hist = nullptr;

-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
+  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
                                &file_options, column_family_id,
                                blob_file_read_hist, nullptr /*IOTracer*/);

@@ -198,12 +199,12 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_IOError) {
  constexpr size_t capacity = 10;
  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  FileOptions file_options;
  constexpr uint32_t column_family_id = 1;
  constexpr HistogramImpl* blob_file_read_hist = nullptr;

-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
+  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
                                &file_options, column_family_id,
                                blob_file_read_hist, nullptr /*IOTracer*/);

@@ -230,10 +231,10 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
  options.enable_blob_files = true;

  constexpr uint32_t column_family_id = 1;
-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);
  constexpr uint64_t blob_file_number = 123;

-  WriteBlobFile(column_family_id, immutable_options, blob_file_number);
+  WriteBlobFile(column_family_id, immutable_cf_options, blob_file_number);

  constexpr size_t capacity = 0;
  constexpr int num_shard_bits = -1;  // determined automatically
@@ -244,7 +245,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
  FileOptions file_options;
  constexpr HistogramImpl* blob_file_read_hist = nullptr;

-  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_options,
+  BlobFileCache blob_file_cache(backing_cache.get(), &immutable_cf_options,
                                &file_options, column_family_id,
                                blob_file_read_hist, nullptr /*IOTracer*/);

@@ -9,7 +9,6 @@
 #pragma once

 #include "db/error_handler.h"
-#include "db/event_helpers.h"
 #include "file/sst_file_manager_impl.h"
 #include "rocksdb/status.h"

@@ -17,46 +16,23 @@ namespace ROCKSDB_NAMESPACE {

 class BlobFileCompletionCallback {
 public:
-  BlobFileCompletionCallback(
-      SstFileManager* sst_file_manager, InstrumentedMutex* mutex,
-      ErrorHandler* error_handler, EventLogger* event_logger,
-      const std::vector<std::shared_ptr<EventListener>>& listeners,
-      const std::string& dbname)
+#ifdef ROCKSDB_LITE
+  BlobFileCompletionCallback(SstFileManager* /*sst_file_manager*/,
+                             InstrumentedMutex* /*mutex*/,
+                             ErrorHandler* /*error_handler*/) {}
+  Status OnBlobFileCompleted(const std::string& /*file_name*/) {
+    return Status::OK();
+  }
+#else
+  BlobFileCompletionCallback(SstFileManager* sst_file_manager,
+                             InstrumentedMutex* mutex,
+                             ErrorHandler* error_handler)
      : sst_file_manager_(sst_file_manager),
        mutex_(mutex),
-        error_handler_(error_handler),
-        event_logger_(event_logger),
-        listeners_(listeners),
-        dbname_(dbname) {}
+        error_handler_(error_handler) {}

-  void OnBlobFileCreationStarted(const std::string& file_name,
-                                 const std::string& column_family_name,
-                                 int job_id,
-                                 BlobFileCreationReason creation_reason) {
-#ifndef ROCKSDB_LITE
-    // Notify the listeners.
-    EventHelpers::NotifyBlobFileCreationStarted(listeners_, dbname_,
-                                                column_family_name, file_name,
-                                                job_id, creation_reason);
-#else
-    (void)file_name;
-    (void)column_family_name;
-    (void)job_id;
-    (void)creation_reason;
-#endif
-  }
-
-  Status OnBlobFileCompleted(const std::string& file_name,
-                             const std::string& column_family_name, int job_id,
-                             uint64_t file_number,
-                             BlobFileCreationReason creation_reason,
-                             const Status& report_status,
-                             const std::string& checksum_value,
-                             const std::string& checksum_method,
-                             uint64_t blob_count, uint64_t blob_bytes) {
+  Status OnBlobFileCompleted(const std::string& file_name) {
    Status s;
-
-#ifndef ROCKSDB_LITE
    auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager_);
    if (sfm) {
      // Report new blob files to SstFileManagerImpl
@@ -69,17 +45,6 @@ class BlobFileCompletionCallback {
        error_handler_->SetBGError(s, BackgroundErrorReason::kFlush);
      }
    }
-#endif  // !ROCKSDB_LITE
-
-    // Notify the listeners.
-    EventHelpers::LogAndNotifyBlobFileCreationFinished(
-        event_logger_, listeners_, dbname_, column_family_name, file_name,
-        job_id, file_number, creation_reason,
-        (!report_status.ok() ? report_status : s),
-        (checksum_value.empty() ? kUnknownFileChecksum : checksum_value),
-        (checksum_method.empty() ? kUnknownFileChecksumFuncName
-                                 : checksum_method),
-        blob_count, blob_bytes);
    return s;
  }

@@ -87,8 +52,6 @@ class BlobFileCompletionCallback {
  SstFileManager* sst_file_manager_;
  InstrumentedMutex* mutex_;
  ErrorHandler* error_handler_;
-  EventLogger* event_logger_;
-  std::vector<std::shared_ptr<EventListener>> listeners_;
-  std::string dbname_;
+#endif  // ROCKSDB_LITE
 };
 }  // namespace ROCKSDB_NAMESPACE
@@ -8,13 +8,7 @@
 #include <ostream>
 #include <sstream>

-#include "db/blob/blob_log_format.h"
-#include "rocksdb/slice.h"
-
 namespace ROCKSDB_NAMESPACE {
-uint64_t SharedBlobFileMetaData::GetBlobFileSize() const {
-  return BlobLogHeader::kSize + total_blob_bytes_ + BlobLogFooter::kSize;
-}

 std::string SharedBlobFileMetaData::DebugString() const {
  std::ostringstream oss;
@@ -29,8 +23,7 @@ std::ostream& operator<<(std::ostream& os,
     << " total_blob_count: " << shared_meta.GetTotalBlobCount()
     << " total_blob_bytes: " << shared_meta.GetTotalBlobBytes()
     << " checksum_method: " << shared_meta.GetChecksumMethod()
-     << " checksum_value: "
-     << Slice(shared_meta.GetChecksumValue()).ToString(/* hex */ true);
+     << " checksum_value: " << shared_meta.GetChecksumValue();

  return os;
 }
@@ -51,7 +51,6 @@ class SharedBlobFileMetaData {
  SharedBlobFileMetaData(SharedBlobFileMetaData&&) = delete;
  SharedBlobFileMetaData& operator=(SharedBlobFileMetaData&&) = delete;

-  uint64_t GetBlobFileSize() const;
  uint64_t GetBlobFileNumber() const { return blob_file_number_; }
  uint64_t GetTotalBlobCount() const { return total_blob_count_; }
  uint64_t GetTotalBlobBytes() const { return total_blob_bytes_; }
@@ -113,11 +112,6 @@ class BlobFileMetaData {
    return shared_meta_;
  }

-  uint64_t GetBlobFileSize() const {
-    assert(shared_meta_);
-    return shared_meta_->GetBlobFileSize();
-  }
-
  uint64_t GetBlobFileNumber() const {
    assert(shared_meta_);
    return shared_meta_->GetBlobFileNumber();
@@ -10,7 +10,6 @@

 #include "db/blob/blob_log_format.h"
 #include "file/filename.h"
-#include "monitoring/statistics.h"
 #include "options/cf_options.h"
 #include "rocksdb/file_system.h"
 #include "rocksdb/slice.h"
@@ -18,14 +17,14 @@
 #include "test_util/sync_point.h"
 #include "util/compression.h"
 #include "util/crc32c.h"
-#include "util/stop_watch.h"

 namespace ROCKSDB_NAMESPACE {

 Status BlobFileReader::Create(
-    const ImmutableOptions& immutable_options, const FileOptions& file_options,
-    uint32_t column_family_id, HistogramImpl* blob_file_read_hist,
-    uint64_t blob_file_number, const std::shared_ptr<IOTracer>& io_tracer,
+    const ImmutableOptions& immutable_cf_options,
+    const FileOptions& file_options, uint32_t column_family_id,
+    HistogramImpl* blob_file_read_hist, uint64_t blob_file_number,
+    const std::shared_ptr<IOTracer>& io_tracer,
    std::unique_ptr<BlobFileReader>* blob_file_reader) {
  assert(blob_file_reader);
  assert(!*blob_file_reader);
@@ -35,7 +34,7 @@ Status BlobFileReader::Create(

  {
    const Status s =
-        OpenFile(immutable_options, file_options, blob_file_read_hist,
+        OpenFile(immutable_cf_options, file_options, blob_file_read_hist,
                 blob_file_number, io_tracer, &file_size, &file_reader);
    if (!s.ok()) {
      return s;
@@ -44,47 +43,44 @@ Status BlobFileReader::Create(

  assert(file_reader);

-  Statistics* const statistics = immutable_options.stats;
-
  CompressionType compression_type = kNoCompression;

  {
-    const Status s = ReadHeader(file_reader.get(), column_family_id, statistics,
-                                &compression_type);
+    const Status s =
+        ReadHeader(file_reader.get(), column_family_id, &compression_type);
    if (!s.ok()) {
      return s;
    }
  }

  {
-    const Status s = ReadFooter(file_reader.get(), file_size, statistics);
+    const Status s = ReadFooter(file_size, file_reader.get());
    if (!s.ok()) {
      return s;
    }
  }

  blob_file_reader->reset(
-      new BlobFileReader(std::move(file_reader), file_size, compression_type,
-                         immutable_options.clock, statistics));
+      new BlobFileReader(std::move(file_reader), file_size, compression_type));

  return Status::OK();
 }

 Status BlobFileReader::OpenFile(
-    const ImmutableOptions& immutable_options, const FileOptions& file_opts,
+    const ImmutableOptions& immutable_cf_options, const FileOptions& file_opts,
    HistogramImpl* blob_file_read_hist, uint64_t blob_file_number,
    const std::shared_ptr<IOTracer>& io_tracer, uint64_t* file_size,
    std::unique_ptr<RandomAccessFileReader>* file_reader) {
  assert(file_size);
  assert(file_reader);

-  const auto& cf_paths = immutable_options.cf_paths;
+  const auto& cf_paths = immutable_cf_options.cf_paths;
  assert(!cf_paths.empty());

  const std::string blob_file_path =
      BlobFileName(cf_paths.front().path, blob_file_number);

-  FileSystem* const fs = immutable_options.fs.get();
+  FileSystem* const fs = immutable_cf_options.fs.get();
  assert(fs);

  constexpr IODebugContext* dbg = nullptr;
@@ -117,22 +113,21 @@ Status BlobFileReader::OpenFile(

  assert(file);

-  if (immutable_options.advise_random_on_open) {
+  if (immutable_cf_options.advise_random_on_open) {
    file->Hint(FSRandomAccessFile::kRandom);
  }

  file_reader->reset(new RandomAccessFileReader(
-      std::move(file), blob_file_path, immutable_options.clock, io_tracer,
-      immutable_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS,
-      blob_file_read_hist, immutable_options.rate_limiter.get(),
-      immutable_options.listeners));
+      std::move(file), blob_file_path, immutable_cf_options.clock, io_tracer,
+      immutable_cf_options.stats, BLOB_DB_BLOB_FILE_READ_MICROS,
+      blob_file_read_hist, immutable_cf_options.rate_limiter.get(),
+      immutable_cf_options.listeners));

  return Status::OK();
 }

 Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
                                  uint32_t column_family_id,
-                                  Statistics* statistics,
                                  CompressionType* compression_type) {
  assert(file_reader);
  assert(compression_type);
@@ -147,9 +142,8 @@ Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
    constexpr uint64_t read_offset = 0;
    constexpr size_t read_size = BlobLogHeader::kSize;

-    const Status s =
-        ReadFromFile(file_reader, read_offset, read_size, statistics,
-                     &header_slice, &buf, &aligned_buf);
+    const Status s = ReadFromFile(file_reader, read_offset, read_size,
+                                  &header_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
    }
@@ -182,8 +176,8 @@ Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
  return Status::OK();
 }

-Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
-                                  uint64_t file_size, Statistics* statistics) {
+Status BlobFileReader::ReadFooter(uint64_t file_size,
+                                  const RandomAccessFileReader* file_reader) {
  assert(file_size >= BlobLogHeader::kSize + BlobLogFooter::kSize);
  assert(file_reader);

@@ -197,9 +191,8 @@ Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
    const uint64_t read_offset = file_size - BlobLogFooter::kSize;
    constexpr size_t read_size = BlobLogFooter::kSize;

-    const Status s =
-        ReadFromFile(file_reader, read_offset, read_size, statistics,
-                     &footer_slice, &buf, &aligned_buf);
+    const Status s = ReadFromFile(file_reader, read_offset, read_size,
+                                  &footer_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
    }
@@ -228,16 +221,14 @@ Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,

 Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
                                    uint64_t read_offset, size_t read_size,
-                                    Statistics* statistics, Slice* slice,
-                                    Buffer* buf, AlignedBuf* aligned_buf) {
+                                    Slice* slice, Buffer* buf,
+                                    AlignedBuf* aligned_buf) {
  assert(slice);
  assert(buf);
  assert(aligned_buf);

  assert(file_reader);

-  RecordTick(statistics, BLOB_DB_BLOB_FILE_BYTES_READ, read_size);
-
  Status s;

  if (file_reader->use_direct_io()) {
@@ -266,13 +257,10 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,

 BlobFileReader::BlobFileReader(
    std::unique_ptr<RandomAccessFileReader>&& file_reader, uint64_t file_size,
-    CompressionType compression_type, SystemClock* clock,
-    Statistics* statistics)
+    CompressionType compression_type)
    : file_reader_(std::move(file_reader)),
      file_size_(file_size),
-      compression_type_(compression_type),
-      clock_(clock),
-      statistics_(statistics) {
+      compression_type_(compression_type) {
  assert(file_reader_);
 }

@@ -317,7 +305,7 @@ Status BlobFileReader::GetBlob(const ReadOptions& read_options,
    TEST_SYNC_POINT("BlobFileReader::GetBlob:ReadFromFile");

    const Status s = ReadFromFile(file_reader_.get(), record_offset,
-                                  static_cast<size_t>(record_size), statistics_,
+                                  static_cast<size_t>(record_size),
                                  &record_slice, &buf, &aligned_buf);
    if (!s.ok()) {
      return s;
@@ -337,8 +325,8 @@ Status BlobFileReader::GetBlob(const ReadOptions& read_options,
  const Slice value_slice(record_slice.data() + adjustment, value_size);

  {
-    const Status s = UncompressBlobIfNeeded(value_slice, compression_type,
-                                            clock_, statistics_, value);
+    const Status s =
+        UncompressBlobIfNeeded(value_slice, compression_type, value);
    if (!s.ok()) {
      return s;
    }
@@ -351,117 +339,6 @@ Status BlobFileReader::GetBlob(const ReadOptions& read_options,
  return Status::OK();
 }

-void BlobFileReader::MultiGetBlob(
-    const ReadOptions& read_options,
-    const autovector<std::reference_wrapper<const Slice>>& user_keys,
-    const autovector<uint64_t>& offsets,
-    const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
-    autovector<PinnableSlice*>& values, uint64_t* bytes_read) const {
-  const size_t num_blobs = user_keys.size();
-  assert(num_blobs == offsets.size());
-  assert(num_blobs == value_sizes.size());
-  assert(num_blobs == statuses.size());
-  assert(num_blobs == values.size());
-
-  std::vector<FSReadRequest> read_reqs(num_blobs);
-  autovector<uint64_t> adjustments;
-  uint64_t total_len = 0;
-  for (size_t i = 0; i < num_blobs; ++i) {
-    const size_t key_size = user_keys[i].get().size();
-    assert(IsValidBlobOffset(offsets[i], key_size, value_sizes[i], file_size_));
-    const uint64_t adjustment =
-        read_options.verify_checksums
-            ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
-            : 0;
-    assert(offsets[i] >= adjustment);
-    adjustments.push_back(adjustment);
-    read_reqs[i].offset = offsets[i] - adjustment;
-    read_reqs[i].len = value_sizes[i] + adjustment;
-    total_len += read_reqs[i].len;
-  }
-
-  RecordTick(statistics_, BLOB_DB_BLOB_FILE_BYTES_READ, total_len);
-
-  Buffer buf;
-  AlignedBuf aligned_buf;
-
-  Status s;
-  bool direct_io = file_reader_->use_direct_io();
-  if (direct_io) {
-    for (size_t i = 0; i < read_reqs.size(); ++i) {
-      read_reqs[i].scratch = nullptr;
-    }
-  } else {
-    buf.reset(new char[total_len]);
-    std::ptrdiff_t pos = 0;
-    for (size_t i = 0; i < read_reqs.size(); ++i) {
-      read_reqs[i].scratch = buf.get() + pos;
-      pos += read_reqs[i].len;
-    }
-  }
-  TEST_SYNC_POINT("BlobFileReader::MultiGetBlob:ReadFromFile");
-  s = file_reader_->MultiRead(IOOptions(), read_reqs.data(), read_reqs.size(),
-                              direct_io ? &aligned_buf : nullptr);
-  if (!s.ok()) {
-    for (auto& req : read_reqs) {
-      req.status.PermitUncheckedError();
-    }
-    for (size_t i = 0; i < num_blobs; ++i) {
-      assert(statuses[i]);
-      *statuses[i] = s;
-    }
-    return;
-  }
-
-  assert(s.ok());
-  for (size_t i = 0; i < num_blobs; ++i) {
-    auto& req = read_reqs[i];
-    assert(statuses[i]);
-    if (req.status.ok() && req.result.size() != req.len) {
-      req.status = IOStatus::Corruption("Failed to read data from blob file");
-    }
-    *statuses[i] = req.status;
-  }
-
-  if (read_options.verify_checksums) {
-    for (size_t i = 0; i < num_blobs; ++i) {
-      assert(statuses[i]);
-      if (!statuses[i]->ok()) {
-        continue;
-      }
-      const Slice& record_slice = read_reqs[i].result;
-      s = VerifyBlob(record_slice, user_keys[i], value_sizes[i]);
-      if (!s.ok()) {
-        assert(statuses[i]);
-        *statuses[i] = s;
-      }
-    }
-  }
-
-  for (size_t i = 0; i < num_blobs; ++i) {
-    assert(statuses[i]);
-    if (!statuses[i]->ok()) {
-      continue;
-    }
-    const Slice& record_slice = read_reqs[i].result;
-    const Slice value_slice(record_slice.data() + adjustments[i],
-                            value_sizes[i]);
-    s = UncompressBlobIfNeeded(value_slice, compression_type_, clock_,
-                               statistics_, values[i]);
-    if (!s.ok()) {
-      *statuses[i] = s;
-    }
-  }
-
-  if (bytes_read) {
-    uint64_t total_bytes = 0;
-    for (const auto& req : read_reqs) {
-      total_bytes += req.result.size();
-    }
-    *bytes_read = total_bytes;
-  }
-}
-
 Status BlobFileReader::VerifyBlob(const Slice& record_slice,
                                  const Slice& user_key, uint64_t value_size) {
  BlobLogRecord record;
@@ -506,8 +383,6 @@ Status BlobFileReader::VerifyBlob(const Slice& record_slice,

 Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
                                              CompressionType compression_type,
-                                              SystemClock* clock,
-                                              Statistics* statistics,
                                              PinnableSlice* value) {
  assert(value);

@@ -525,14 +400,9 @@ Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
  constexpr uint32_t compression_format_version = 2;
  constexpr MemoryAllocator* allocator = nullptr;

-  CacheAllocationPtr output;
-
-  {
-    StopWatch stop_watch(clock, statistics, BLOB_DB_DECOMPRESSION_MICROS);
-    output = UncompressData(info, value_slice.data(), value_slice.size(),
-                            &uncompressed_size, compression_format_version,
-                            allocator);
-  }
+  CacheAllocationPtr output =
+      UncompressData(info, value_slice.data(), value_slice.size(),
+                     &uncompressed_size, compression_format_version, allocator);

  TEST_SYNC_POINT_CALLBACK(
      "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", &output);
@@ -11,7 +11,6 @@
 #include "file/random_access_file_reader.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/rocksdb_namespace.h"
-#include "util/autovector.h"

 namespace ROCKSDB_NAMESPACE {

@@ -22,7 +21,6 @@ class HistogramImpl;
 struct ReadOptions;
 class Slice;
 class PinnableSlice;
-class Statistics;

 class BlobFileReader {
 public:
@@ -44,21 +42,9 @@ class BlobFileReader {
                 CompressionType compression_type, PinnableSlice* value,
                 uint64_t* bytes_read) const;

-  void MultiGetBlob(
-      const ReadOptions& read_options,
-      const autovector<std::reference_wrapper<const Slice>>& user_keys,
-      const autovector<uint64_t>& offsets,
-      const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
-      autovector<PinnableSlice*>& values, uint64_t* bytes_read) const;
-
-  CompressionType GetCompressionType() const { return compression_type_; }
-
-  uint64_t GetFileSize() const { return file_size_; }
-
 private:
  BlobFileReader(std::unique_ptr<RandomAccessFileReader>&& file_reader,
-                 uint64_t file_size, CompressionType compression_type,
-                 SystemClock* clock, Statistics* statistics);
+                 uint64_t file_size, CompressionType compression_type);

  static Status OpenFile(const ImmutableOptions& immutable_options,
                         const FileOptions& file_opts,
@@ -69,17 +55,17 @@ class BlobFileReader {
                         std::unique_ptr<RandomAccessFileReader>* file_reader);

  static Status ReadHeader(const RandomAccessFileReader* file_reader,
-                           uint32_t column_family_id, Statistics* statistics,
+                           uint32_t column_family_id,
                           CompressionType* compression_type);

-  static Status ReadFooter(const RandomAccessFileReader* file_reader,
-                           uint64_t file_size, Statistics* statistics);
+  static Status ReadFooter(uint64_t file_size,
+                           const RandomAccessFileReader* file_reader);

  using Buffer = std::unique_ptr<char[]>;

  static Status ReadFromFile(const RandomAccessFileReader* file_reader,
                             uint64_t read_offset, size_t read_size,
-                             Statistics* statistics, Slice* slice, Buffer* buf,
+                             Slice* slice, Buffer* buf,
                             AlignedBuf* aligned_buf);

  static Status VerifyBlob(const Slice& record_slice, const Slice& user_key,
@@ -87,8 +73,6 @@ class BlobFileReader {

  static Status UncompressBlobIfNeeded(const Slice& value_slice,
                                       CompressionType compression_type,
-                                       SystemClock* clock,
-                                       Statistics* statistics,
                                       PinnableSlice* value);

  static void SaveValue(const Slice& src, PinnableSlice* dst);
@@ -96,8 +80,6 @@ class BlobFileReader {
  std::unique_ptr<RandomAccessFileReader> file_reader_;
  uint64_t file_size_;
  CompressionType compression_type_;
-  SystemClock* clock_;
-  Statistics* statistics_;
 };

 }  // namespace ROCKSDB_NAMESPACE
@@ -27,109 +27,83 @@ namespace ROCKSDB_NAMESPACE {

 namespace {

-// Creates a test blob file with `num` blobs in it.
-void WriteBlobFile(const ImmutableOptions& immutable_options,
+// Creates a test blob file with a single blob in it. Note: this method
+// makes it possible to test various corner cases by allowing the caller
+// to specify the contents of various blob file header/footer fields.
+void WriteBlobFile(const ImmutableOptions& immutable_cf_options,
                   uint32_t column_family_id, bool has_ttl,
                   const ExpirationRange& expiration_range_header,
                   const ExpirationRange& expiration_range_footer,
-                   uint64_t blob_file_number, const std::vector<Slice>& keys,
-                   const std::vector<Slice>& blobs, CompressionType compression,
-                   std::vector<uint64_t>& blob_offsets,
-                   std::vector<uint64_t>& blob_sizes) {
-  assert(!immutable_options.cf_paths.empty());
-  size_t num = keys.size();
-  assert(num == blobs.size());
-  assert(num == blob_offsets.size());
-  assert(num == blob_sizes.size());
+                   uint64_t blob_file_number, const Slice& key,
+                   const Slice& blob, CompressionType compression_type,
+                   uint64_t* blob_offset, uint64_t* blob_size) {
+  assert(!immutable_cf_options.cf_paths.empty());
+  assert(blob_offset);
+  assert(blob_size);
+
+  const std::string blob_file_path = BlobFileName(
+      immutable_cf_options.cf_paths.front().path, blob_file_number);

-  const std::string blob_file_path =
-      BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
  std::unique_ptr<FSWritableFile> file;
-  ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
-                            FileOptions()));
+  ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path,
+                            &file, FileOptions()));

-  std::unique_ptr<WritableFileWriter> file_writer(new WritableFileWriter(
-      std::move(file), blob_file_path, FileOptions(), immutable_options.clock));
+  std::unique_ptr<WritableFileWriter> file_writer(
+      new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
+                             immutable_cf_options.clock));

  constexpr Statistics* statistics = nullptr;
  constexpr bool use_fsync = false;
  constexpr bool do_flush = false;

-  BlobLogWriter blob_log_writer(std::move(file_writer), immutable_options.clock,
-                                statistics, blob_file_number, use_fsync,
-                                do_flush);
+  BlobLogWriter blob_log_writer(std::move(file_writer),
+                                immutable_cf_options.clock, statistics,
+                                blob_file_number, use_fsync, do_flush);

-  BlobLogHeader header(column_family_id, compression, has_ttl,
+  BlobLogHeader header(column_family_id, compression_type, has_ttl,
                       expiration_range_header);

  ASSERT_OK(blob_log_writer.WriteHeader(header));

-  std::vector<std::string> compressed_blobs(num);
-  std::vector<Slice> blobs_to_write(num);
-  if (kNoCompression == compression) {
-    for (size_t i = 0; i < num; ++i) {
-      blobs_to_write[i] = blobs[i];
-      blob_sizes[i] = blobs[i].size();
-    }
+  std::string compressed_blob;
+  Slice blob_to_write;
+
+  if (compression_type == kNoCompression) {
+    blob_to_write = blob;
+    *blob_size = blob.size();
  } else {
    CompressionOptions opts;
-    CompressionContext context(compression);
+    CompressionContext context(compression_type);
    constexpr uint64_t sample_for_compression = 0;
+
    CompressionInfo info(opts, context, CompressionDict::GetEmptyDict(),
-                         compression, sample_for_compression);
+                         compression_type, sample_for_compression);

    constexpr uint32_t compression_format_version = 2;

-    for (size_t i = 0; i < num; ++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();
-    }
+    ASSERT_TRUE(
+        CompressData(blob, info, compression_format_version, &compressed_blob));
+
+    blob_to_write = compressed_blob;
+    *blob_size = compressed_blob.size();
  }

-  for (size_t i = 0; i < num; ++i) {
-    uint64_t key_offset = 0;
-    ASSERT_OK(blob_log_writer.AddRecord(keys[i], blobs_to_write[i], &key_offset,
-                                        &blob_offsets[i]));
-  }
+  uint64_t key_offset = 0;
+
+  ASSERT_OK(
+      blob_log_writer.AddRecord(key, blob_to_write, &key_offset, blob_offset));

  BlobLogFooter footer;
-  footer.blob_count = num;
+  footer.blob_count = 1;
  footer.expiration_range = expiration_range_footer;

  std::string checksum_method;
  std::string checksum_value;
+
  ASSERT_OK(
      blob_log_writer.AppendFooter(footer, &checksum_method, &checksum_value));
 }

-// Creates a test blob file with a single blob in it. Note: this method
-// makes it possible to test various corner cases by allowing the caller
-// to specify the contents of various blob file header/footer fields.
-void WriteBlobFile(const ImmutableOptions& immutable_options,
-                   uint32_t column_family_id, bool has_ttl,
-                   const ExpirationRange& expiration_range_header,
-                   const ExpirationRange& expiration_range_footer,
-                   uint64_t blob_file_number, const Slice& key,
-                   const Slice& blob, CompressionType compression,
-                   uint64_t* blob_offset, uint64_t* blob_size) {
-  std::vector<Slice> keys{key};
-  std::vector<Slice> blobs{blob};
-  std::vector<uint64_t> blob_offsets{0};
-  std::vector<uint64_t> blob_sizes{0};
-  WriteBlobFile(immutable_options, column_family_id, has_ttl,
-                expiration_range_header, expiration_range_footer,
-                blob_file_number, keys, blobs, compression, blob_offsets,
-                blob_sizes);
-  if (blob_offset) {
-    *blob_offset = blob_offsets[0];
-  }
-  if (blob_size) {
-    *blob_size = blob_sizes[0];
-  }
-}
-
 }  // anonymous namespace

 class BlobFileReaderTest : public testing::Test {
@@ -148,33 +122,29 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
  constexpr ExpirationRange expiration_range;
  constexpr uint64_t blob_file_number = 1;
-  constexpr size_t num_blobs = 3;
-  const std::vector<std::string> key_strs = {"key1", "key2", "key3"};
-  const std::vector<std::string> blob_strs = {"blob1", "blob2", "blob3"};
+  constexpr char key[] = "key";
+  constexpr char blob[] = "blob";

-  const std::vector<Slice> keys = {key_strs[0], key_strs[1], key_strs[2]};
-  const std::vector<Slice> blobs = {blob_strs[0], blob_strs[1], blob_strs[2]};
+  uint64_t blob_offset = 0;
+  uint64_t blob_size = 0;

-  std::vector<uint64_t> blob_offsets(keys.size());
-  std::vector<uint64_t> blob_sizes(keys.size());
-
-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, keys, blobs, kNoCompression,
-                blob_offsets, blob_sizes);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;

  std::unique_ptr<BlobFileReader> reader;

  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader));
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader));

  // Make sure the blob can be retrieved with and without checksum verification
  ReadOptions read_options;
@@ -184,36 +154,10 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    PinnableSlice value;
    uint64_t bytes_read = 0;

-    ASSERT_OK(reader->GetBlob(read_options, keys[0], blob_offsets[0],
-                              blob_sizes[0], kNoCompression, &value,
-                              &bytes_read));
-    ASSERT_EQ(value, blobs[0]);
-    ASSERT_EQ(bytes_read, blob_sizes[0]);
-
-    // MultiGetBlob
-    bytes_read = 0;
-    size_t total_size = 0;
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    for (const auto& key_ref : keys) {
-      key_refs.emplace_back(std::cref(key_ref));
-    }
-    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
-                                 blob_offsets[2]};
-    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
-    std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
-                                 &statuses_buf[2]};
-    std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
-                                      &value_buf[2]};
-    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
-                         values, &bytes_read);
-    for (size_t i = 0; i < num_blobs; ++i) {
-      ASSERT_OK(statuses_buf[i]);
-      ASSERT_EQ(value_buf[i], blobs[i]);
-      total_size += blob_sizes[i];
-    }
-    ASSERT_EQ(bytes_read, total_size);
+    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
+                              kNoCompression, &value, &bytes_read));
+    ASSERT_EQ(value, blob);
+    ASSERT_EQ(bytes_read, blob_size);
  }

  read_options.verify_checksums = true;
@@ -222,15 +166,14 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    PinnableSlice value;
    uint64_t bytes_read = 0;

-    ASSERT_OK(reader->GetBlob(read_options, keys[1], blob_offsets[1],
-                              blob_sizes[1], kNoCompression, &value,
-                              &bytes_read));
-    ASSERT_EQ(value, blobs[1]);
+    ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
+                              kNoCompression, &value, &bytes_read));
+    ASSERT_EQ(value, blob);

-    const uint64_t key_size = keys[1].size();
+    constexpr uint64_t key_size = sizeof(key) - 1;
    ASSERT_EQ(bytes_read,
              BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size) +
-                  blob_sizes[1]);
+                  blob_size);
  }

  // Invalid offset (too close to start of file)
@@ -239,9 +182,8 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    uint64_t bytes_read = 0;

    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, keys[0], blob_offsets[0] - 1,
-                              blob_sizes[0], kNoCompression, &value,
-                              &bytes_read)
+                    ->GetBlob(read_options, key, blob_offset - 1, blob_size,
+                              kNoCompression, &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
  }
@@ -252,9 +194,8 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    uint64_t bytes_read = 0;

    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, keys[2], blob_offsets[2] + 1,
-                              blob_sizes[2], kNoCompression, &value,
-                              &bytes_read)
+                    ->GetBlob(read_options, key, blob_offset + 1, blob_size,
+                              kNoCompression, &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
  }
@@ -265,8 +206,8 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    uint64_t bytes_read = 0;

    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, keys[0], blob_offsets[0],
-                              blob_sizes[0], kZSTD, &value, &bytes_read)
+                    ->GetBlob(read_options, key, blob_offset, blob_size, kZSTD,
+                              &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
  }
@@ -279,82 +220,23 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {

    ASSERT_TRUE(reader
                    ->GetBlob(read_options, shorter_key,
-                              blob_offsets[0] -
-                                  (keys[0].size() - sizeof(shorter_key) + 1),
-                              blob_sizes[0], kNoCompression, &value,
-                              &bytes_read)
+                              blob_offset - (sizeof(key) - sizeof(shorter_key)),
+                              blob_size, kNoCompression, &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
-
-    // MultiGetBlob
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    for (const auto& key_ref : keys) {
-      key_refs.emplace_back(std::cref(key_ref));
-    }
-    Slice shorter_key_slice(shorter_key, sizeof(shorter_key) - 1);
-    key_refs[1] = std::cref(shorter_key_slice);
-
-    autovector<uint64_t> offsets{
-        blob_offsets[0],
-        blob_offsets[1] - (keys[1].size() - key_refs[1].get().size()),
-        blob_offsets[2]};
-    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
-    std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
-                                 &statuses_buf[2]};
-    std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
-                                      &value_buf[2]};
-    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
-                         values, &bytes_read);
-    for (size_t i = 0; i < num_blobs; ++i) {
-      if (i == 1) {
-        ASSERT_TRUE(statuses_buf[i].IsCorruption());
-      } else {
-        ASSERT_OK(statuses_buf[i]);
-      }
-    }
  }

  // Incorrect key
  {
-    constexpr char incorrect_key[] = "foo1";
+    constexpr char incorrect_key[] = "foo";
    PinnableSlice value;
    uint64_t bytes_read = 0;

    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, incorrect_key, blob_offsets[0],
-                              blob_sizes[0], kNoCompression, &value,
-                              &bytes_read)
+                    ->GetBlob(read_options, incorrect_key, blob_offset,
+                              blob_size, kNoCompression, &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
-
-    // MultiGetBlob
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    for (const auto& key_ref : keys) {
-      key_refs.emplace_back(std::cref(key_ref));
-    }
-    Slice wrong_key_slice(incorrect_key, sizeof(incorrect_key) - 1);
-    key_refs[2] = std::cref(wrong_key_slice);
-
-    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
-                                 blob_offsets[2]};
-    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
-    std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
-                                 &statuses_buf[2]};
-    std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
-                                      &value_buf[2]};
-    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
-                         values, &bytes_read);
-    for (size_t i = 0; i < num_blobs; ++i) {
-      if (i == num_blobs - 1) {
-        ASSERT_TRUE(statuses_buf[i].IsCorruption());
-      } else {
-        ASSERT_OK(statuses_buf[i]);
-      }
-    }
  }

  // Incorrect value size
@@ -363,35 +245,10 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
    uint64_t bytes_read = 0;

    ASSERT_TRUE(reader
-                    ->GetBlob(read_options, keys[1], blob_offsets[1],
-                              blob_sizes[1] + 1, kNoCompression, &value,
-                              &bytes_read)
+                    ->GetBlob(read_options, key, blob_offset, blob_size + 1,
+                              kNoCompression, &value, &bytes_read)
                    .IsCorruption());
    ASSERT_EQ(bytes_read, 0);
-
-    // MultiGetBlob
-    autovector<std::reference_wrapper<const Slice>> key_refs;
-    for (const auto& key_ref : keys) {
-      key_refs.emplace_back(std::cref(key_ref));
-    }
-    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
-                                 blob_offsets[2]};
-    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1] + 1, blob_sizes[2]};
-    std::array<Status, num_blobs> statuses_buf;
-    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
-                                 &statuses_buf[2]};
-    std::array<PinnableSlice, num_blobs> value_buf;
-    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
-                                      &value_buf[2]};
-    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
-                         values, &bytes_read);
-    for (size_t i = 0; i < num_blobs; ++i) {
-      if (i != 1) {
-        ASSERT_OK(statuses_buf[i]);
-      } else {
-        ASSERT_TRUE(statuses_buf[i].IsCorruption());
-      }
-    }
  }
 }

@@ -405,7 +262,7 @@ TEST_F(BlobFileReaderTest, Malformed) {
      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Malformed"), 0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr uint64_t blob_file_number = 1;
@@ -414,23 +271,23 @@ TEST_F(BlobFileReaderTest, Malformed) {
    constexpr bool has_ttl = false;
    constexpr ExpirationRange expiration_range;

-    const std::string blob_file_path =
-        BlobFileName(immutable_options.cf_paths.front().path, blob_file_number);
+    const std::string blob_file_path = BlobFileName(
+        immutable_cf_options.cf_paths.front().path, blob_file_number);

    std::unique_ptr<FSWritableFile> file;
-    ASSERT_OK(NewWritableFile(immutable_options.fs.get(), blob_file_path, &file,
-                              FileOptions()));
+    ASSERT_OK(NewWritableFile(immutable_cf_options.fs.get(), blob_file_path,
+                              &file, FileOptions()));

    std::unique_ptr<WritableFileWriter> file_writer(
        new WritableFileWriter(std::move(file), blob_file_path, FileOptions(),
-                               immutable_options.clock));
+                               immutable_cf_options.clock));

    constexpr Statistics* statistics = nullptr;
    constexpr bool use_fsync = false;
    constexpr bool do_flush = false;

    BlobLogWriter blob_log_writer(std::move(file_writer),
-                                  immutable_options.clock, statistics,
+                                  immutable_cf_options.clock, statistics,
                                  blob_file_number, use_fsync, do_flush);

    BlobLogHeader header(column_family_id, kNoCompression, has_ttl,
@@ -443,7 +300,7 @@ TEST_F(BlobFileReaderTest, Malformed) {

  std::unique_ptr<BlobFileReader> reader;

-  ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
+  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
                                     column_family_id, blob_file_read_hist,
                                     blob_file_number, nullptr /*IOTracer*/,
                                     &reader)
@@ -457,7 +314,7 @@ TEST_F(BlobFileReaderTest, TTL) {
      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_TTL"), 0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = true;
@@ -469,15 +326,15 @@ TEST_F(BlobFileReaderTest, TTL) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;

  std::unique_ptr<BlobFileReader> reader;

-  ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
+  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
                                     column_family_id, blob_file_read_hist,
                                     blob_file_number, nullptr /*IOTracer*/,
                                     &reader)
@@ -493,7 +350,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -507,7 +364,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl,
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
                expiration_range_header, expiration_range_footer,
                blob_file_number, key, blob, kNoCompression, &blob_offset,
                &blob_size);
@@ -516,7 +373,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInHeader) {

  std::unique_ptr<BlobFileReader> reader;

-  ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
+  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
                                     column_family_id, blob_file_read_hist,
                                     blob_file_number, nullptr /*IOTracer*/,
                                     &reader)
@@ -532,7 +389,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -546,7 +403,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl,
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
                expiration_range_header, expiration_range_footer,
                blob_file_number, key, blob, kNoCompression, &blob_offset,
                &blob_size);
@@ -555,7 +412,7 @@ TEST_F(BlobFileReaderTest, ExpirationRangeInFooter) {

  std::unique_ptr<BlobFileReader> reader;

-  ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
+  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
                                     column_family_id, blob_file_read_hist,
                                     blob_file_number, nullptr /*IOTracer*/,
                                     &reader)
@@ -571,7 +428,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -583,9 +440,9 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;

@@ -593,7 +450,7 @@ TEST_F(BlobFileReaderTest, IncorrectColumnFamily) {

  constexpr uint32_t incorrect_column_family_id = 2;

-  ASSERT_TRUE(BlobFileReader::Create(immutable_options, FileOptions(),
+  ASSERT_TRUE(BlobFileReader::Create(immutable_cf_options, FileOptions(),
                                     incorrect_column_family_id,
                                     blob_file_read_hist, blob_file_number,
                                     nullptr /*IOTracer*/, &reader)
@@ -607,7 +464,7 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_BlobCRCError"), 0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -619,17 +476,17 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;

  std::unique_ptr<BlobFileReader> reader;

  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader));
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader));

  SyncPoint::GetInstance()->SetCallBack(
      "BlobFileReader::VerifyBlob:CheckBlobCRC", [](void* arg) {
@@ -665,7 +522,7 @@ TEST_F(BlobFileReaderTest, Compression) {
      test::PerThreadDBPath(&mock_env_, "BlobFileReaderTest_Compression"), 0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -677,8 +534,8 @@ TEST_F(BlobFileReaderTest, Compression) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob,
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
                kSnappyCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;
@@ -686,8 +543,8 @@ TEST_F(BlobFileReaderTest, Compression) {
  std::unique_ptr<BlobFileReader> reader;

  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader));
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader));

  // Make sure the blob can be retrieved with and without checksum verification
  ReadOptions read_options;
@@ -733,7 +590,7 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -745,8 +602,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob,
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
                kSnappyCompression, &blob_offset, &blob_size);

  constexpr HistogramImpl* blob_file_read_hist = nullptr;
@@ -754,8 +611,8 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
  std::unique_ptr<BlobFileReader> reader;

  ASSERT_OK(BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader));
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader));

  SyncPoint::GetInstance()->SetCallBack(
      "BlobFileReader::UncompressBlobIfNeeded:TamperWithResult", [](void* arg) {
@@ -814,7 +671,7 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -826,9 +683,9 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* /* arg */) {
    fault_injection_env_.SetFilesystemActive(false,
@@ -841,8 +698,8 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
  std::unique_ptr<BlobFileReader> reader;

  const Status s = BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader);
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader);

  const bool fail_during_create =
      (sync_point_ != "BlobFileReader::GetBlob:ReadFromFile");
@@ -892,7 +749,7 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
      0);
  options.enable_blob_files = true;

-  ImmutableOptions immutable_options(options);
+  ImmutableOptions immutable_cf_options(options);

  constexpr uint32_t column_family_id = 1;
  constexpr bool has_ttl = false;
@@ -904,9 +761,9 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
  uint64_t blob_offset = 0;
  uint64_t blob_size = 0;

-  WriteBlobFile(immutable_options, column_family_id, has_ttl, expiration_range,
-                expiration_range, blob_file_number, key, blob, kNoCompression,
-                &blob_offset, &blob_size);
+  WriteBlobFile(immutable_cf_options, column_family_id, has_ttl,
+                expiration_range, expiration_range, blob_file_number, key, blob,
+                kNoCompression, &blob_offset, &blob_size);

  SyncPoint::GetInstance()->SetCallBack(sync_point_, [](void* arg) {
    Slice* const slice = static_cast<Slice*>(arg);
@@ -923,8 +780,8 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
  std::unique_ptr<BlobFileReader> reader;

  const Status s = BlobFileReader::Create(
-      immutable_options, FileOptions(), column_family_id, blob_file_read_hist,
-      blob_file_number, nullptr /*IOTracer*/, &reader);
+      immutable_cf_options, FileOptions(), column_family_id,
+      blob_file_read_hist, blob_file_number, nullptr /*IOTracer*/, &reader);

  const bool fail_during_create =
      sync_point_ != "BlobFileReader::GetBlob:TamperWithResult";
@@ -1,100 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_garbage_meter.h"
-
-#include "db/blob/blob_index.h"
-#include "db/blob/blob_log_format.h"
-#include "db/dbformat.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-Status BlobGarbageMeter::ProcessInFlow(const Slice& key, const Slice& value) {
-  uint64_t blob_file_number = kInvalidBlobFileNumber;
-  uint64_t bytes = 0;
-
-  const Status s = Parse(key, value, &blob_file_number, &bytes);
-  if (!s.ok()) {
-    return s;
-  }
-
-  if (blob_file_number == kInvalidBlobFileNumber) {
-    return Status::OK();
-  }
-
-  flows_[blob_file_number].AddInFlow(bytes);
-
-  return Status::OK();
-}
-
-Status BlobGarbageMeter::ProcessOutFlow(const Slice& key, const Slice& value) {
-  uint64_t blob_file_number = kInvalidBlobFileNumber;
-  uint64_t bytes = 0;
-
-  const Status s = Parse(key, value, &blob_file_number, &bytes);
-  if (!s.ok()) {
-    return s;
-  }
-
-  if (blob_file_number == kInvalidBlobFileNumber) {
-    return Status::OK();
-  }
-
-  // Note: in order to measure the amount of additional garbage, we only need to
-  // track the outflow for preexisting files, i.e. those that also had inflow.
-  // (Newly written files would only have outflow.)
-  auto it = flows_.find(blob_file_number);
-  if (it == flows_.end()) {
-    return Status::OK();
-  }
-
-  it->second.AddOutFlow(bytes);
-
-  return Status::OK();
-}
-
-Status BlobGarbageMeter::Parse(const Slice& key, const Slice& value,
-                               uint64_t* blob_file_number, uint64_t* bytes) {
-  assert(blob_file_number);
-  assert(*blob_file_number == kInvalidBlobFileNumber);
-  assert(bytes);
-  assert(*bytes == 0);
-
-  ParsedInternalKey ikey;
-
-  {
-    constexpr bool log_err_key = false;
-    const Status s = ParseInternalKey(key, &ikey, log_err_key);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (ikey.type != kTypeBlobIndex) {
-    return Status::OK();
-  }
-
-  BlobIndex blob_index;
-
-  {
-    const Status s = blob_index.DecodeFrom(value);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (blob_index.IsInlined() || blob_index.HasTTL()) {
-    return Status::Corruption("Unexpected TTL/inlined blob index");
-  }
-
-  *blob_file_number = blob_index.file_number();
-  *bytes =
-      blob_index.size() +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(ikey.user_key.size());
-
-  return Status::OK();
-}
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,102 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cassert>
-#include <cstdint>
-#include <unordered_map>
-
-#include "db/blob/blob_constants.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Slice;
-
-// A class that can be used to compute the amount of additional garbage
-// generated by a compaction. It parses the keys and blob references in the
-// input and output of a compaction, and aggregates the "inflow" and "outflow"
-// on a per-blob file basis. The amount of additional garbage for any given blob
-// file can then be computed by subtracting the outflow from the inflow.
-class BlobGarbageMeter {
- public:
-  // A class to store the number and total size of blobs on a per-blob file
-  // basis.
-  class BlobStats {
-   public:
-    void Add(uint64_t bytes) {
-      ++count_;
-      bytes_ += bytes;
-    }
-    void Add(uint64_t count, uint64_t bytes) {
-      count_ += count;
-      bytes_ += bytes;
-    }
-
-    uint64_t GetCount() const { return count_; }
-    uint64_t GetBytes() const { return bytes_; }
-
-   private:
-    uint64_t count_ = 0;
-    uint64_t bytes_ = 0;
-  };
-
-  // A class to keep track of the "inflow" and the "outflow" and to compute the
-  // amount of additional garbage for a given blob file.
-  class BlobInOutFlow {
-   public:
-    void AddInFlow(uint64_t bytes) {
-      in_flow_.Add(bytes);
-      assert(IsValid());
-    }
-    void AddOutFlow(uint64_t bytes) {
-      out_flow_.Add(bytes);
-      assert(IsValid());
-    }
-
-    const BlobStats& GetInFlow() const { return in_flow_; }
-    const BlobStats& GetOutFlow() const { return out_flow_; }
-
-    bool IsValid() const {
-      return in_flow_.GetCount() >= out_flow_.GetCount() &&
-             in_flow_.GetBytes() >= out_flow_.GetBytes();
-    }
-    bool HasGarbage() const {
-      assert(IsValid());
-      return in_flow_.GetCount() > out_flow_.GetCount();
-    }
-    uint64_t GetGarbageCount() const {
-      assert(IsValid());
-      assert(HasGarbage());
-      return in_flow_.GetCount() - out_flow_.GetCount();
-    }
-    uint64_t GetGarbageBytes() const {
-      assert(IsValid());
-      assert(HasGarbage());
-      return in_flow_.GetBytes() - out_flow_.GetBytes();
-    }
-
-   private:
-    BlobStats in_flow_;
-    BlobStats out_flow_;
-  };
-
-  Status ProcessInFlow(const Slice& key, const Slice& value);
-  Status ProcessOutFlow(const Slice& key, const Slice& value);
-
-  const std::unordered_map<uint64_t, BlobInOutFlow>& flows() const {
-    return flows_;
-  }
-
- private:
-  static Status Parse(const Slice& key, const Slice& value,
-                      uint64_t* blob_file_number, uint64_t* bytes);
-
-  std::unordered_map<uint64_t, BlobInOutFlow> flows_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,196 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_garbage_meter.h"
-
-#include <string>
-#include <vector>
-
-#include "db/blob/blob_index.h"
-#include "db/blob/blob_log_format.h"
-#include "db/dbformat.h"
-#include "test_util/testharness.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-TEST(BlobGarbageMeterTest, MeasureGarbage) {
-  BlobGarbageMeter blob_garbage_meter;
-
-  struct BlobDescriptor {
-    std::string user_key;
-    uint64_t blob_file_number;
-    uint64_t offset;
-    uint64_t size;
-    CompressionType compression_type;
-    bool has_in_flow;
-    bool has_out_flow;
-
-    uint64_t GetExpectedBytes() const {
-      return size +
-             BlobLogRecord::CalculateAdjustmentForRecordHeader(user_key.size());
-    }
-  };
-
-  // Note: blob file 4 has the same inflow and outflow and hence no additional
-  // garbage. Blob file 5 has less outflow than inflow and thus it does have
-  // additional garbage. Blob file 6 is a newly written file (i.e. no inflow,
-  // only outflow) and is thus not tracked by the meter.
-  std::vector<BlobDescriptor> blobs{
-      {"key", 4, 1234, 555, kLZ4Compression, true, true},
-      {"other_key", 4, 6789, 101010, kLZ4Compression, true, true},
-      {"yet_another_key", 5, 22222, 3456, kLZ4Compression, true, true},
-      {"foo_key", 5, 77777, 8888, kLZ4Compression, true, true},
-      {"bar_key", 5, 999999, 1212, kLZ4Compression, true, false},
-      {"baz_key", 5, 1234567, 890, kLZ4Compression, true, false},
-      {"new_key", 6, 7777, 9999, kNoCompression, false, true}};
-
-  for (const auto& blob : blobs) {
-    constexpr SequenceNumber seq = 123;
-    const InternalKey key(blob.user_key, seq, kTypeBlobIndex);
-    const Slice key_slice = key.Encode();
-
-    std::string value;
-    BlobIndex::EncodeBlob(&value, blob.blob_file_number, blob.offset, blob.size,
-                          blob.compression_type);
-    const Slice value_slice(value);
-
-    if (blob.has_in_flow) {
-      ASSERT_OK(blob_garbage_meter.ProcessInFlow(key_slice, value_slice));
-    }
-    if (blob.has_out_flow) {
-      ASSERT_OK(blob_garbage_meter.ProcessOutFlow(key_slice, value_slice));
-    }
-  }
-
-  const auto& flows = blob_garbage_meter.flows();
-  ASSERT_EQ(flows.size(), 2);
-
-  {
-    const auto it = flows.find(4);
-    ASSERT_NE(it, flows.end());
-
-    const auto& flow = it->second;
-
-    constexpr uint64_t expected_count = 2;
-    const uint64_t expected_bytes =
-        blobs[0].GetExpectedBytes() + blobs[1].GetExpectedBytes();
-
-    const auto& in = flow.GetInFlow();
-    ASSERT_EQ(in.GetCount(), expected_count);
-    ASSERT_EQ(in.GetBytes(), expected_bytes);
-
-    const auto& out = flow.GetOutFlow();
-    ASSERT_EQ(out.GetCount(), expected_count);
-    ASSERT_EQ(out.GetBytes(), expected_bytes);
-
-    ASSERT_TRUE(flow.IsValid());
-    ASSERT_FALSE(flow.HasGarbage());
-  }
-
-  {
-    const auto it = flows.find(5);
-    ASSERT_NE(it, flows.end());
-
-    const auto& flow = it->second;
-
-    const auto& in = flow.GetInFlow();
-
-    constexpr uint64_t expected_in_count = 4;
-    const uint64_t expected_in_bytes =
-        blobs[2].GetExpectedBytes() + blobs[3].GetExpectedBytes() +
-        blobs[4].GetExpectedBytes() + blobs[5].GetExpectedBytes();
-
-    ASSERT_EQ(in.GetCount(), expected_in_count);
-    ASSERT_EQ(in.GetBytes(), expected_in_bytes);
-
-    const auto& out = flow.GetOutFlow();
-
-    constexpr uint64_t expected_out_count = 2;
-    const uint64_t expected_out_bytes =
-        blobs[2].GetExpectedBytes() + blobs[3].GetExpectedBytes();
-
-    ASSERT_EQ(out.GetCount(), expected_out_count);
-    ASSERT_EQ(out.GetBytes(), expected_out_bytes);
-
-    ASSERT_TRUE(flow.IsValid());
-    ASSERT_TRUE(flow.HasGarbage());
-    ASSERT_EQ(flow.GetGarbageCount(), expected_in_count - expected_out_count);
-    ASSERT_EQ(flow.GetGarbageBytes(), expected_in_bytes - expected_out_bytes);
-  }
-}
-
-TEST(BlobGarbageMeterTest, PlainValue) {
-  constexpr char user_key[] = "user_key";
-  constexpr SequenceNumber seq = 123;
-
-  const InternalKey key(user_key, seq, kTypeValue);
-  const Slice key_slice = key.Encode();
-
-  constexpr char value[] = "value";
-  const Slice value_slice(value);
-
-  BlobGarbageMeter blob_garbage_meter;
-
-  ASSERT_OK(blob_garbage_meter.ProcessInFlow(key_slice, value_slice));
-  ASSERT_OK(blob_garbage_meter.ProcessOutFlow(key_slice, value_slice));
-  ASSERT_TRUE(blob_garbage_meter.flows().empty());
-}
-
-TEST(BlobGarbageMeterTest, CorruptInternalKey) {
-  constexpr char corrupt_key[] = "i_am_corrupt";
-  const Slice key_slice(corrupt_key);
-
-  constexpr char value[] = "value";
-  const Slice value_slice(value);
-
-  BlobGarbageMeter blob_garbage_meter;
-
-  ASSERT_NOK(blob_garbage_meter.ProcessInFlow(key_slice, value_slice));
-  ASSERT_NOK(blob_garbage_meter.ProcessOutFlow(key_slice, value_slice));
-}
-
-TEST(BlobGarbageMeterTest, CorruptBlobIndex) {
-  constexpr char user_key[] = "user_key";
-  constexpr SequenceNumber seq = 123;
-
-  const InternalKey key(user_key, seq, kTypeBlobIndex);
-  const Slice key_slice = key.Encode();
-
-  constexpr char value[] = "i_am_not_a_blob_index";
-  const Slice value_slice(value);
-
-  BlobGarbageMeter blob_garbage_meter;
-
-  ASSERT_NOK(blob_garbage_meter.ProcessInFlow(key_slice, value_slice));
-  ASSERT_NOK(blob_garbage_meter.ProcessOutFlow(key_slice, value_slice));
-}
-
-TEST(BlobGarbageMeterTest, InlinedTTLBlobIndex) {
-  constexpr char user_key[] = "user_key";
-  constexpr SequenceNumber seq = 123;
-
-  const InternalKey key(user_key, seq, kTypeBlobIndex);
-  const Slice key_slice = key.Encode();
-
-  constexpr uint64_t expiration = 1234567890;
-  constexpr char inlined_value[] = "inlined";
-
-  std::string value;
-  BlobIndex::EncodeInlinedTTL(&value, expiration, inlined_value);
-
-  const Slice value_slice(value);
-
-  BlobGarbageMeter blob_garbage_meter;
-
-  ASSERT_NOK(blob_garbage_meter.ProcessInFlow(key_slice, value_slice));
-  ASSERT_NOK(blob_garbage_meter.ProcessOutFlow(key_slice, value_slice));
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -52,9 +52,6 @@ class BlobIndex {

  BlobIndex() : type_(Type::kUnknown) {}

-  BlobIndex(const BlobIndex&) = default;
-  BlobIndex& operator=(const BlobIndex&) = default;
-
  bool IsInlined() const { return type_ == Type::kInlinedTTL; }

  bool HasTTL() const {
@@ -107,8 +107,7 @@ struct BlobLogRecord {
  // Note that the offset field of BlobIndex actually points to the blob value
  // as opposed to the start of the blob record. The following method can
  // be used to calculate the adjustment needed to read the blob record header.
-  static constexpr uint64_t CalculateAdjustmentForRecordHeader(
-      uint64_t key_size) {
+  static uint64_t CalculateAdjustmentForRecordHeader(uint64_t key_size) {
    return key_size + kHeaderSize;
  }

@@ -10,8 +10,6 @@
 #include "db/blob/blob_log_format.h"
 #include "rocksdb/slice.h"

-#define MAX_HEADER_SIZE(a, b, c) (a > b ? (a > c ? a : c) : (b > c ? b : c))
-
 namespace ROCKSDB_NAMESPACE {

 class RandomAccessFileReader;
@@ -71,13 +69,10 @@ class BlobLogSequentialReader {
  Statistics* statistics_;

  Slice buffer_;
-  char header_buf_[MAX_HEADER_SIZE(BlobLogHeader::kSize, BlobLogFooter::kSize,
-                                   BlobLogRecord::kHeaderSize)];
+  char header_buf_[BlobLogRecord::kHeaderSize];

  // which byte to read next
  uint64_t next_byte_;
 };

 }  // namespace ROCKSDB_NAMESPACE
-
-#undef MAX_HEADER_SIZE
@@ -4,10 +4,8 @@
 //  (found in the LICENSE.Apache file in the root directory).

 #include <array>
-#include <sstream>

 #include "db/blob/blob_index.h"
-#include "db/blob/blob_log_format.h"
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "test_util/sync_point.h"
@@ -18,7 +16,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBBlobBasicTest : public DBTestBase {
 protected:
  DBBlobBasicTest()
-      : DBTestBase("db_blob_basic_test", /* env_do_fsync */ false) {}
+      : DBTestBase("/db_blob_basic_test", /* env_do_fsync */ false) {}
 };

 TEST_F(DBBlobBasicTest, GetBlob) {
@@ -127,237 +125,6 @@ TEST_F(DBBlobBasicTest, MultiGetBlobs) {
  }
 }

-#ifndef ROCKSDB_LITE
-TEST_F(DBBlobBasicTest, MultiGetWithDirectIO) {
-  Options options = GetDefaultOptions();
-
-  // First, create an external SST file ["b"].
-  const std::string file_path = dbname_ + "/test.sst";
-  {
-    SstFileWriter sst_file_writer(EnvOptions(), GetDefaultOptions());
-    Status s = sst_file_writer.Open(file_path);
-    ASSERT_OK(s);
-    ASSERT_OK(sst_file_writer.Put("b", "b_value"));
-    ASSERT_OK(sst_file_writer.Finish());
-  }
-
-  options.enable_blob_files = true;
-  options.min_blob_size = 1000;
-  options.use_direct_reads = true;
-  options.allow_ingest_behind = true;
-
-  // Open DB with fixed-prefix sst-partitioner so that compaction will cut
-  // new table file when encountering a new key whose 1-byte prefix changes.
-  constexpr size_t key_len = 1;
-  options.sst_partitioner_factory =
-      NewSstPartitionerFixedPrefixFactory(key_len);
-
-  Status s = TryReopen(options);
-  if (s.IsInvalidArgument()) {
-    ROCKSDB_GTEST_SKIP("This test requires direct IO support");
-    return;
-  }
-  ASSERT_OK(s);
-
-  constexpr size_t num_keys = 3;
-  constexpr size_t blob_size = 3000;
-
-  constexpr char first_key[] = "a";
-  const std::string first_blob(blob_size, 'a');
-  ASSERT_OK(Put(first_key, first_blob));
-
-  constexpr char second_key[] = "b";
-  const std::string second_blob(2 * blob_size, 'b');
-  ASSERT_OK(Put(second_key, second_blob));
-
-  constexpr char third_key[] = "d";
-  const std::string third_blob(blob_size, 'd');
-  ASSERT_OK(Put(third_key, third_blob));
-
-  // first_blob, second_blob and third_blob in the same blob file.
-  //      SST                    Blob file
-  // L0  ["a",    "b",    "d"]   |'aaaa', 'bbbb', 'dddd'|
-  //       |       |       |         ^       ^        ^
-  //       |       |       |         |       |        |
-  //       |       |       +---------|-------|--------+
-  //       |       +-----------------|-------+
-  //       +-------------------------+
-  ASSERT_OK(Flush());
-
-  constexpr char fourth_key[] = "c";
-  const std::string fourth_blob(blob_size, 'c');
-  ASSERT_OK(Put(fourth_key, fourth_blob));
-  // fourth_blob in another blob file.
-  //      SST                    Blob file                 SST     Blob file
-  // L0  ["a",    "b",    "d"]   |'aaaa', 'bbbb', 'dddd'|  ["c"]   |'cccc'|
-  //       |       |       |         ^       ^        ^      |       ^
-  //       |       |       |         |       |        |      |       |
-  //       |       |       +---------|-------|--------+      +-------+
-  //       |       +-----------------|-------+
-  //       +-------------------------+
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-
-  // Due to the above sst partitioner, we get 4 L1 files. The blob files are
-  // unchanged.
-  //                             |'aaaa', 'bbbb', 'dddd'|  |'cccc'|
-  //                                 ^       ^     ^         ^
-  //                                 |       |     |         |
-  // L0                              |       |     |         |
-  // L1  ["a"]   ["b"]   ["c"]       |       |   ["d"]       |
-  //       |       |       |         |       |               |
-  //       |       |       +---------|-------|---------------+
-  //       |       +-----------------|-------+
-  //       +-------------------------+
-  ASSERT_EQ(4, NumTableFilesAtLevel(/*level=*/1));
-
-  {
-    // Ingest the external SST file into bottommost level.
-    std::vector<std::string> ext_files{file_path};
-    IngestExternalFileOptions opts;
-    opts.ingest_behind = true;
-    ASSERT_OK(
-        db_->IngestExternalFile(db_->DefaultColumnFamily(), ext_files, opts));
-  }
-
-  // Now the database becomes as follows.
-  //                             |'aaaa', 'bbbb', 'dddd'|  |'cccc'|
-  //                                 ^       ^     ^         ^
-  //                                 |       |     |         |
-  // L0                              |       |     |         |
-  // L1  ["a"]   ["b"]   ["c"]       |       |   ["d"]       |
-  //       |       |       |         |       |               |
-  //       |       |       +---------|-------|---------------+
-  //       |       +-----------------|-------+
-  //       +-------------------------+
-  //
-  // L6          ["b"]
-
-  {
-    // Compact ["b"] to bottommost level.
-    Slice begin = Slice(second_key);
-    Slice end = Slice(second_key);
-    CompactRangeOptions cro;
-    cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-    ASSERT_OK(db_->CompactRange(cro, &begin, &end));
-  }
-
-  //                             |'aaaa', 'bbbb', 'dddd'|  |'cccc'|
-  //                                 ^       ^     ^         ^
-  //                                 |       |     |         |
-  // L0                              |       |     |         |
-  // L1  ["a"]           ["c"]       |       |   ["d"]       |
-  //       |               |         |       |               |
-  //       |               +---------|-------|---------------+
-  //       |       +-----------------|-------+
-  //       +-------|-----------------+
-  //               |
-  // L6          ["b"]
-  ASSERT_EQ(3, NumTableFilesAtLevel(/*level=*/1));
-  ASSERT_EQ(1, NumTableFilesAtLevel(/*level=*/6));
-
-  bool called = false;
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  SyncPoint::GetInstance()->SetCallBack(
-      "RandomAccessFileReader::MultiRead:AlignedReqs", [&](void* arg) {
-        auto* aligned_reqs = static_cast<std::vector<FSReadRequest>*>(arg);
-        assert(aligned_reqs);
-        ASSERT_EQ(1, aligned_reqs->size());
-        called = true;
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::array<Slice, num_keys> keys{{first_key, third_key, second_key}};
-
-  {
-    std::array<PinnableSlice, num_keys> values;
-    std::array<Status, num_keys> statuses;
-
-    // The MultiGet(), when constructing the KeyContexts, will process the keys
-    // in such order: a, d, b. The reason is that ["a"] and ["d"] are in L1,
-    // while ["b"] resides in L6.
-    // Consequently, the original FSReadRequest list prepared by
-    // Version::MultiGetblob() will be for "a", "d" and "b". It is unsorted as
-    // follows:
-    //
-    // ["a", offset=30, len=3033],
-    // ["d", offset=9096, len=3033],
-    // ["b", offset=3063, len=6033]
-    //
-    // If we do not sort them before calling MultiRead() in DirectIO, then the
-    // underlying IO merging logic will yield two requests.
-    //
-    // [offset=0, len=4096] (for "a")
-    // [offset=0, len=12288] (result of merging the request for "d" and "b")
-    //
-    // We need to sort them in Version::MultiGetBlob() so that the underlying
-    // IO merging logic in DirectIO mode works as expected. The correct
-    // behavior will be one aligned request:
-    //
-    // [offset=0, len=12288]
-
-    db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), num_keys, &keys[0],
-                  &values[0], &statuses[0]);
-
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-
-    ASSERT_TRUE(called);
-
-    ASSERT_OK(statuses[0]);
-    ASSERT_EQ(values[0], first_blob);
-
-    ASSERT_OK(statuses[1]);
-    ASSERT_EQ(values[1], third_blob);
-
-    ASSERT_OK(statuses[2]);
-    ASSERT_EQ(values[2], second_blob);
-  }
-}
-#endif  // !ROCKSDB_LITE
-
-TEST_F(DBBlobBasicTest, MultiGetBlobsFromMultipleFiles) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr size_t kNumBlobFiles = 3;
-  constexpr size_t kNumBlobsPerFile = 3;
-  constexpr size_t kNumKeys = kNumBlobsPerFile * kNumBlobFiles;
-
-  std::vector<std::string> key_strs;
-  std::vector<std::string> value_strs;
-  for (size_t i = 0; i < kNumBlobFiles; ++i) {
-    for (size_t j = 0; j < kNumBlobsPerFile; ++j) {
-      std::string key = "key" + std::to_string(i) + "_" + std::to_string(j);
-      std::string value =
-          "value_as_blob" + std::to_string(i) + "_" + std::to_string(j);
-      ASSERT_OK(Put(key, value));
-      key_strs.push_back(key);
-      value_strs.push_back(value);
-    }
-    ASSERT_OK(Flush());
-  }
-  assert(key_strs.size() == kNumKeys);
-  std::array<Slice, kNumKeys> keys;
-  for (size_t i = 0; i < keys.size(); ++i) {
-    keys[i] = key_strs[i];
-  }
-  std::array<PinnableSlice, kNumKeys> values;
-  std::array<Status, kNumKeys> statuses;
-  db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), kNumKeys, &keys[0],
-                &values[0], &statuses[0]);
-
-  for (size_t i = 0; i < kNumKeys; ++i) {
-    ASSERT_OK(statuses[i]);
-    ASSERT_EQ(value_strs[i], values[i]);
-  }
-}
-
 TEST_F(DBBlobBasicTest, GetBlob_CorruptIndex) {
  Options options = GetDefaultOptions();
  options.enable_blob_files = true;
@@ -381,83 +148,6 @@ TEST_F(DBBlobBasicTest, GetBlob_CorruptIndex) {
                  .IsCorruption());
 }

-TEST_F(DBBlobBasicTest, MultiGetBlob_CorruptIndex) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-  options.create_if_missing = true;
-
-  DestroyAndReopen(options);
-
-  constexpr size_t kNumOfKeys = 3;
-  std::array<std::string, kNumOfKeys> key_strs;
-  std::array<std::string, kNumOfKeys> value_strs;
-  std::array<Slice, kNumOfKeys + 1> keys;
-  for (size_t i = 0; i < kNumOfKeys; ++i) {
-    key_strs[i] = "foo" + std::to_string(i);
-    value_strs[i] = "blob_value" + std::to_string(i);
-    ASSERT_OK(Put(key_strs[i], value_strs[i]));
-    keys[i] = key_strs[i];
-  }
-
-  constexpr char key[] = "key";
-  {
-    // Fake a corrupt blob index.
-    const std::string blob_index("foobar");
-    WriteBatch batch;
-    ASSERT_OK(WriteBatchInternal::PutBlobIndex(&batch, 0, key, blob_index));
-    ASSERT_OK(db_->Write(WriteOptions(), &batch));
-    keys[kNumOfKeys] = Slice(static_cast<const char*>(key), sizeof(key) - 1);
-  }
-
-  ASSERT_OK(Flush());
-
-  std::array<PinnableSlice, kNumOfKeys + 1> values;
-  std::array<Status, kNumOfKeys + 1> statuses;
-  db_->MultiGet(ReadOptions(), dbfull()->DefaultColumnFamily(), kNumOfKeys + 1,
-                keys.data(), values.data(), statuses.data(),
-                /*sorted_input=*/false);
-  for (size_t i = 0; i < kNumOfKeys + 1; ++i) {
-    if (i != kNumOfKeys) {
-      ASSERT_OK(statuses[i]);
-      ASSERT_EQ("blob_value" + std::to_string(i), values[i]);
-    } else {
-      ASSERT_TRUE(statuses[i].IsCorruption());
-    }
-  }
-}
-
-TEST_F(DBBlobBasicTest, MultiGetBlob_ExceedSoftLimit) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr size_t kNumOfKeys = 3;
-  std::array<std::string, kNumOfKeys> key_bufs;
-  std::array<std::string, kNumOfKeys> value_bufs;
-  std::array<Slice, kNumOfKeys> keys;
-  for (size_t i = 0; i < kNumOfKeys; ++i) {
-    key_bufs[i] = "foo" + std::to_string(i);
-    value_bufs[i] = "blob_value" + std::to_string(i);
-    ASSERT_OK(Put(key_bufs[i], value_bufs[i]));
-    keys[i] = key_bufs[i];
-  }
-  ASSERT_OK(Flush());
-
-  std::array<PinnableSlice, kNumOfKeys> values;
-  std::array<Status, kNumOfKeys> statuses;
-  ReadOptions read_opts;
-  read_opts.value_size_soft_limit = 1;
-  db_->MultiGet(read_opts, dbfull()->DefaultColumnFamily(), kNumOfKeys,
-                keys.data(), values.data(), statuses.data(),
-                /*sorted_input=*/true);
-  for (const auto& s : statuses) {
-    ASSERT_TRUE(s.IsAborted());
-  }
-}
-
 TEST_F(DBBlobBasicTest, GetBlob_InlinedTTLIndex) {
  constexpr uint64_t min_blob_size = 10;

@@ -620,204 +310,6 @@ TEST_F(DBBlobBasicTest, BestEffortsRecovery_MissingNewestBlobFile) {
  ASSERT_EQ("value" + std::to_string(kNumTableFiles - 2), value);
 }

-TEST_F(DBBlobBasicTest, GetMergeBlobWithPut) {
-  Options options = GetDefaultOptions();
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  ASSERT_OK(Put("Key1", "v1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("Key1", "v2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("Key1", "v3"));
-  ASSERT_OK(Flush());
-
-  std::string value;
-  ASSERT_OK(db_->Get(ReadOptions(), "Key1", &value));
-  ASSERT_EQ(Get("Key1"), "v1,v2,v3");
-}
-
-TEST_F(DBBlobBasicTest, MultiGetMergeBlobWithPut) {
-  constexpr size_t num_keys = 3;
-
-  Options options = GetDefaultOptions();
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  ASSERT_OK(Put("Key0", "v0_0"));
-  ASSERT_OK(Put("Key1", "v1_0"));
-  ASSERT_OK(Put("Key2", "v2_0"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("Key0", "v0_1"));
-  ASSERT_OK(Merge("Key1", "v1_1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("Key0", "v0_2"));
-  ASSERT_OK(Flush());
-
-  std::array<Slice, num_keys> keys{{"Key0", "Key1", "Key2"}};
-  std::array<PinnableSlice, num_keys> values;
-  std::array<Status, num_keys> statuses;
-
-  db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), num_keys, &keys[0],
-                &values[0], &statuses[0]);
-
-  ASSERT_OK(statuses[0]);
-  ASSERT_EQ(values[0], "v0_0,v0_1,v0_2");
-
-  ASSERT_OK(statuses[1]);
-  ASSERT_EQ(values[1], "v1_0,v1_1");
-
-  ASSERT_OK(statuses[2]);
-  ASSERT_EQ(values[2], "v2_0");
-}
-
-#ifndef ROCKSDB_LITE
-TEST_F(DBBlobBasicTest, Properties) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key1[] = "key1";
-  constexpr size_t key1_size = sizeof(key1) - 1;
-
-  constexpr char key2[] = "key2";
-  constexpr size_t key2_size = sizeof(key2) - 1;
-
-  constexpr char key3[] = "key3";
-  constexpr size_t key3_size = sizeof(key3) - 1;
-
-  constexpr char blob[] = "0000000000";
-  constexpr size_t blob_size = sizeof(blob) - 1;
-
-  ASSERT_OK(Put(key1, blob));
-  ASSERT_OK(Put(key2, blob));
-  ASSERT_OK(Flush());
-
-  constexpr size_t first_blob_file_expected_size =
-      BlobLogHeader::kSize +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(key1_size) + blob_size +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(key2_size) + blob_size +
-      BlobLogFooter::kSize;
-
-  ASSERT_OK(Put(key3, blob));
-  ASSERT_OK(Flush());
-
-  constexpr size_t second_blob_file_expected_size =
-      BlobLogHeader::kSize +
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(key3_size) + blob_size +
-      BlobLogFooter::kSize;
-
-  constexpr size_t total_expected_size =
-      first_blob_file_expected_size + second_blob_file_expected_size;
-
-  // Number of blob files
-  uint64_t num_blob_files = 0;
-  ASSERT_TRUE(
-      db_->GetIntProperty(DB::Properties::kNumBlobFiles, &num_blob_files));
-  ASSERT_EQ(num_blob_files, 2);
-
-  // Total size of live blob files
-  uint64_t live_blob_file_size = 0;
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kLiveBlobFileSize,
-                                  &live_blob_file_size));
-  ASSERT_EQ(live_blob_file_size, total_expected_size);
-
-  // Total size of all blob files across all versions
-  // Note: this should be the same as above since we only have one
-  // version at this point.
-  uint64_t total_blob_file_size = 0;
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kTotalBlobFileSize,
-                                  &total_blob_file_size));
-  ASSERT_EQ(total_blob_file_size, total_expected_size);
-
-  // Delete key2 to create some garbage
-  ASSERT_OK(Delete(key2));
-  ASSERT_OK(Flush());
-
-  constexpr Slice* begin = nullptr;
-  constexpr Slice* end = nullptr;
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), begin, end));
-
-  constexpr size_t expected_garbage_size =
-      BlobLogRecord::CalculateAdjustmentForRecordHeader(key2_size) + blob_size;
-
-  // Blob file stats
-  std::string blob_stats;
-  ASSERT_TRUE(db_->GetProperty(DB::Properties::kBlobStats, &blob_stats));
-
-  std::ostringstream oss;
-  oss << "Number of blob files: 2\nTotal size of blob files: "
-      << total_expected_size
-      << "\nTotal size of garbage in blob files: " << expected_garbage_size
-      << '\n';
-
-  ASSERT_EQ(blob_stats, oss.str());
-}
-
-TEST_F(DBBlobBasicTest, PropertiesMultiVersion) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr char key1[] = "key1";
-  constexpr char key2[] = "key2";
-  constexpr char key3[] = "key3";
-
-  constexpr size_t key_size = sizeof(key1) - 1;
-  static_assert(sizeof(key2) - 1 == key_size, "unexpected size: key2");
-  static_assert(sizeof(key3) - 1 == key_size, "unexpected size: key3");
-
-  constexpr char blob[] = "0000000000";
-  constexpr size_t blob_size = sizeof(blob) - 1;
-
-  ASSERT_OK(Put(key1, blob));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(key2, blob));
-  ASSERT_OK(Flush());
-
-  // Create an iterator to keep the current version alive
-  std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
-  ASSERT_OK(iter->status());
-
-  // Note: the Delete and subsequent compaction results in the first blob file
-  // not making it to the final version. (It is still part of the previous
-  // version kept alive by the iterator though.) On the other hand, the Put
-  // results in a third blob file.
-  ASSERT_OK(Delete(key1));
-  ASSERT_OK(Put(key3, blob));
-  ASSERT_OK(Flush());
-
-  constexpr Slice* begin = nullptr;
-  constexpr Slice* end = nullptr;
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), begin, end));
-
-  // Total size of all blob files across all versions: between the two versions,
-  // we should have three blob files of the same size with one blob each.
-  // The version kept alive by the iterator contains the first and the second
-  // blob file, while the final version contains the second and the third blob
-  // file. (The second blob file is thus shared by the two versions but should
-  // be counted only once.)
-  uint64_t total_blob_file_size = 0;
-  ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kTotalBlobFileSize,
-                                  &total_blob_file_size));
-  ASSERT_EQ(total_blob_file_size,
-            3 * (BlobLogHeader::kSize +
-                 BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size) +
-                 blob_size + BlobLogFooter::kSize));
-}
-#endif  // !ROCKSDB_LITE
-
 class DBBlobBasicIOErrorTest : public DBBlobBasicTest,
                               public testing::WithParamInterface<std::string> {
 protected:
@@ -830,21 +322,11 @@ class DBBlobBasicIOErrorTest : public DBBlobBasicTest,
  std::string sync_point_;
 };

-class DBBlobBasicIOErrorMultiGetTest : public DBBlobBasicIOErrorTest {
- public:
-  DBBlobBasicIOErrorMultiGetTest() : DBBlobBasicIOErrorTest() {}
-};
-
 INSTANTIATE_TEST_CASE_P(DBBlobBasicTest, DBBlobBasicIOErrorTest,
                        ::testing::ValuesIn(std::vector<std::string>{
                            "BlobFileReader::OpenFile:NewRandomAccessFile",
                            "BlobFileReader::GetBlob:ReadFromFile"}));

-INSTANTIATE_TEST_CASE_P(DBBlobBasicTest, DBBlobBasicIOErrorMultiGetTest,
-                        ::testing::ValuesIn(std::vector<std::string>{
-                            "BlobFileReader::OpenFile:NewRandomAccessFile",
-                            "BlobFileReader::MultiGetBlob:ReadFromFile"}));
-
 TEST_P(DBBlobBasicIOErrorTest, GetBlob_IOError) {
  Options options;
  options.env = fault_injection_env_.get();
@@ -874,7 +356,7 @@ TEST_P(DBBlobBasicIOErrorTest, GetBlob_IOError) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-TEST_P(DBBlobBasicIOErrorMultiGetTest, MultiGetBlobs_IOError) {
+TEST_P(DBBlobBasicIOErrorTest, MultiGetBlobs_IOError) {
  Options options = GetDefaultOptions();
  options.env = fault_injection_env_.get();
  options.enable_blob_files = true;
@@ -916,53 +398,6 @@ TEST_P(DBBlobBasicIOErrorMultiGetTest, MultiGetBlobs_IOError) {
  ASSERT_TRUE(statuses[1].IsIOError());
 }

-TEST_P(DBBlobBasicIOErrorMultiGetTest, MultipleBlobFiles) {
-  Options options = GetDefaultOptions();
-  options.env = fault_injection_env_.get();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  Reopen(options);
-
-  constexpr size_t num_keys = 2;
-
-  constexpr char key1[] = "key1";
-  constexpr char value1[] = "blob1";
-
-  ASSERT_OK(Put(key1, value1));
-  ASSERT_OK(Flush());
-
-  constexpr char key2[] = "key2";
-  constexpr char value2[] = "blob2";
-
-  ASSERT_OK(Put(key2, value2));
-  ASSERT_OK(Flush());
-
-  std::array<Slice, num_keys> keys{{key1, key2}};
-  std::array<PinnableSlice, num_keys> values;
-  std::array<Status, num_keys> statuses;
-
-  bool first_blob_file = true;
-  SyncPoint::GetInstance()->SetCallBack(
-      sync_point_, [&first_blob_file, this](void* /* arg */) {
-        if (first_blob_file) {
-          first_blob_file = false;
-          return;
-        }
-        fault_injection_env_->SetFilesystemActive(false,
-                                                  Status::IOError(sync_point_));
-      });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                keys.data(), values.data(), statuses.data());
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-  ASSERT_OK(statuses[0]);
-  ASSERT_EQ(value1, values[0]);
-  ASSERT_TRUE(statuses[1].IsIOError());
-}
-
 namespace {

 class ReadBlobCompactionFilter : public CompactionFilter {
@@ -1018,17 +453,8 @@ TEST_P(DBBlobBasicIOErrorTest, CompactionFilterReadBlob_IOError) {

 }  // namespace ROCKSDB_NAMESPACE

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -4,17 +4,17 @@
 //  (found in the LICENSE.Apache file in the root directory).

 #include "db/blob/blob_index.h"
-#include "db/blob/blob_log_format.h"
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "test_util/sync_point.h"
+#include "utilities/fault_injection_env.h"

 namespace ROCKSDB_NAMESPACE {

 class DBBlobCompactionTest : public DBTestBase {
 public:
  explicit DBBlobCompactionTest()
-      : DBTestBase("db_blob_compaction_test", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_blob_compaction_test", /*env_do_fsync=*/false) {}

 #ifndef ROCKSDB_LITE
  const std::vector<InternalStats::CompactionStats>& GetCompactionStats() {
@@ -152,31 +152,6 @@ class AlwaysKeepFilter : public CompactionFilter {
    return CompactionFilter::Decision::kKeep;
  }
 };
-
-class SkipUntilFilter : public CompactionFilter {
- public:
-  explicit SkipUntilFilter(std::string skip_until)
-      : skip_until_(std::move(skip_until)) {}
-
-  const char* Name() const override {
-    return "rocksdb.compaction.filter.skip.until";
-  }
-
-  CompactionFilter::Decision FilterV2(int /* level */, const Slice& /* key */,
-                                      ValueType /* value_type */,
-                                      const Slice& /* existing_value */,
-                                      std::string* /* new_value */,
-                                      std::string* skip_until) const override {
-    assert(skip_until);
-    *skip_until = skip_until_;
-
-    return CompactionFilter::Decision::kRemoveAndSkipUntil;
-  }
-
- private:
-  std::string skip_until_;
-};
-
 }  // anonymous namespace

 class DBBlobBadCompactionFilterTest
@@ -279,49 +254,6 @@ TEST_F(DBBlobCompactionTest, BlindWriteFilter) {
  Close();
 }

-TEST_F(DBBlobCompactionTest, SkipUntilFilter) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-
-  std::unique_ptr<CompactionFilter> compaction_filter_guard(
-      new SkipUntilFilter("z"));
-  options.compaction_filter = compaction_filter_guard.get();
-
-  Reopen(options);
-
-  const std::vector<std::string> keys{"a", "b", "c"};
-  const std::vector<std::string> values{"a_value", "b_value", "c_value"};
-  assert(keys.size() == values.size());
-
-  for (size_t i = 0; i < keys.size(); ++i) {
-    ASSERT_OK(Put(keys[i], values[i]));
-  }
-
-  ASSERT_OK(Flush());
-
-  int process_in_flow_called = 0;
-
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobCountingIterator::UpdateAndCountBlobIfNeeded:ProcessInFlow",
-      [&process_in_flow_called](void* /* arg */) { ++process_in_flow_called; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /* begin */ nullptr,
-                              /* end */ nullptr));
-
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-
-  for (const auto& key : keys) {
-    ASSERT_EQ(Get(key), "NOT_FOUND");
-  }
-
-  // Make sure SkipUntil was performed using iteration rather than Seek
-  ASSERT_EQ(process_in_flow_called, keys.size());
-
-  Close();
-}
-
 TEST_P(DBBlobBadCompactionFilterTest, BadDecisionFromCompactionFilter) {
  Options options = GetDefaultOptions();
  options.enable_blob_files = true;
@@ -458,151 +390,10 @@ TEST_F(DBBlobCompactionTest, CompactionFilterReadBlobAndKeep) {
  Close();
 }

-TEST_F(DBBlobCompactionTest, TrackGarbage) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-
-  Reopen(options);
-
-  // First table+blob file pair: 4 blobs with different keys
-  constexpr char first_key[] = "first_key";
-  constexpr char first_value[] = "first_value";
-  constexpr char second_key[] = "second_key";
-  constexpr char second_value[] = "second_value";
-  constexpr char third_key[] = "third_key";
-  constexpr char third_value[] = "third_value";
-  constexpr char fourth_key[] = "fourth_key";
-  constexpr char fourth_value[] = "fourth_value";
-
-  ASSERT_OK(Put(first_key, first_value));
-  ASSERT_OK(Put(second_key, second_value));
-  ASSERT_OK(Put(third_key, third_value));
-  ASSERT_OK(Put(fourth_key, fourth_value));
-  ASSERT_OK(Flush());
-
-  // Second table+blob file pair: overwrite 2 existing keys
-  constexpr char new_first_value[] = "new_first_value";
-  constexpr char new_second_value[] = "new_second_value";
-
-  ASSERT_OK(Put(first_key, new_first_value));
-  ASSERT_OK(Put(second_key, new_second_value));
-  ASSERT_OK(Flush());
-
-  // Compact them together. The first blob file should have 2 garbage blobs
-  // corresponding to the 2 overwritten keys.
-  constexpr Slice* begin = nullptr;
-  constexpr Slice* end = nullptr;
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), begin, end));
-
-  VersionSet* const versions = dbfull()->TEST_GetVersionSet();
-  assert(versions);
-  assert(versions->GetColumnFamilySet());
-
-  ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-  assert(cfd);
-
-  Version* const current = cfd->current();
-  assert(current);
-
-  const VersionStorageInfo* const storage_info = current->storage_info();
-  assert(storage_info);
-
-  const auto& blob_files = storage_info->GetBlobFiles();
-  ASSERT_EQ(blob_files.size(), 2);
-
-  {
-    auto it = blob_files.begin();
-    const auto& meta = it->second;
-    assert(meta);
-
-    constexpr uint64_t first_expected_bytes =
-        sizeof(first_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(first_key) -
-                                                          1);
-    constexpr uint64_t second_expected_bytes =
-        sizeof(second_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(second_key) -
-                                                          1);
-    constexpr uint64_t third_expected_bytes =
-        sizeof(third_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(third_key) -
-                                                          1);
-    constexpr uint64_t fourth_expected_bytes =
-        sizeof(fourth_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(fourth_key) -
-                                                          1);
-
-    ASSERT_EQ(meta->GetTotalBlobCount(), 4);
-    ASSERT_EQ(meta->GetTotalBlobBytes(),
-              first_expected_bytes + second_expected_bytes +
-                  third_expected_bytes + fourth_expected_bytes);
-    ASSERT_EQ(meta->GetGarbageBlobCount(), 2);
-    ASSERT_EQ(meta->GetGarbageBlobBytes(),
-              first_expected_bytes + second_expected_bytes);
-  }
-
-  {
-    auto it = blob_files.rbegin();
-    const auto& meta = it->second;
-    assert(meta);
-
-    constexpr uint64_t new_first_expected_bytes =
-        sizeof(new_first_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(first_key) -
-                                                          1);
-    constexpr uint64_t new_second_expected_bytes =
-        sizeof(new_second_value) - 1 +
-        BlobLogRecord::CalculateAdjustmentForRecordHeader(sizeof(second_key) -
-                                                          1);
-
-    ASSERT_EQ(meta->GetTotalBlobCount(), 2);
-    ASSERT_EQ(meta->GetTotalBlobBytes(),
-              new_first_expected_bytes + new_second_expected_bytes);
-    ASSERT_EQ(meta->GetGarbageBlobCount(), 0);
-    ASSERT_EQ(meta->GetGarbageBlobBytes(), 0);
-  }
-}
-
-TEST_F(DBBlobCompactionTest, MergeBlobWithBase) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  options.disable_auto_compactions = true;
-
-  Reopen(options);
-  ASSERT_OK(Put("Key1", "v1_1"));
-  ASSERT_OK(Put("Key2", "v2_1"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Merge("Key1", "v1_2"));
-  ASSERT_OK(Merge("Key2", "v2_2"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Merge("Key1", "v1_3"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-  ASSERT_EQ(Get("Key1"), "v1_1,v1_2,v1_3");
-  ASSERT_EQ(Get("Key2"), "v2_1,v2_2");
-  Close();
-}
-
 }  // namespace ROCKSDB_NAMESPACE

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -12,7 +12,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBBlobCorruptionTest : public DBTestBase {
 protected:
  DBBlobCorruptionTest()
-      : DBTestBase("db_blob_corruption_test", /* env_do_fsync */ false) {}
+      : DBTestBase("/db_blob_corruption_test", /* env_do_fsync */ false) {}

  void Corrupt(FileType filetype, int offset, int bytes_to_corrupt) {
    // Pick file to corrupt
@@ -74,17 +74,8 @@ TEST_F(DBBlobCorruptionTest, VerifyWholeBlobFileChecksum) {
 #endif  // !ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -41,7 +41,8 @@ class DBBlobIndexTest : public DBTestBase {
                                       Tier::kImmutableMemtables,
                                       Tier::kL0SstFile, Tier::kLnSstFile};

-  DBBlobIndexTest() : DBTestBase("db_blob_index_test", /*env_do_fsync=*/true) {}
+  DBBlobIndexTest()
+      : DBTestBase("/db_blob_index_test", /*env_do_fsync=*/true) {}

  ColumnFamilyHandle* cfh() { return dbfull()->DefaultColumnFamily(); }

@@ -398,7 +399,7 @@ TEST_F(DBBlobIndexTest, Iterate) {
           create_normal_iterator);
    verify(9, Status::kOk, get_value(10, 0), get_value(8, 0),
           create_normal_iterator);
-    verify(11, Status::kCorruption, "", "", create_normal_iterator);
+    verify(11, Status::kNotSupported, "", "", create_normal_iterator);
    verify(13, Status::kOk,
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
@@ -417,11 +418,7 @@ TEST_F(DBBlobIndexTest, Iterate) {
           create_blob_iterator, check_is_blob(false));
    verify(9, Status::kOk, get_value(10, 0), get_value(8, 0),
           create_blob_iterator, check_is_blob(false));
-    if (tier <= kImmutableMemtables) {
-      verify(11, Status::kNotSupported, "", "", create_blob_iterator);
-    } else {
-      verify(11, Status::kCorruption, "", "", create_blob_iterator);
-    }
+    verify(11, Status::kNotSupported, "", "", create_blob_iterator);
    verify(13, Status::kOk,
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
@@ -443,11 +440,7 @@ TEST_F(DBBlobIndexTest, Iterate) {
           create_blob_iterator, check_is_blob(false));
    verify(9, Status::kOk, get_value(10, 0), get_value(8, 0),
           create_blob_iterator, check_is_blob(false));
-    if (tier <= kImmutableMemtables) {
-      verify(11, Status::kNotSupported, "", "", create_blob_iterator);
-    } else {
-      verify(11, Status::kCorruption, "", "", create_blob_iterator);
-    }
+    verify(11, Status::kNotSupported, "", "", create_blob_iterator);
    verify(13, Status::kOk,
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
           get_value(13, 2) + "," + get_value(13, 1) + "," + get_value(13, 0),
@@ -462,119 +455,10 @@ TEST_F(DBBlobIndexTest, Iterate) {
  }
 }

-TEST_F(DBBlobIndexTest, IntegratedBlobIterate) {
-  const std::vector<std::vector<std::string>> data = {
-      /*00*/ {"Put"},
-      /*01*/ {"Put", "Merge", "Merge", "Merge"},
-      /*02*/ {"Put"}};
-
-  auto get_key = [](size_t index) { return ("key" + std::to_string(index)); };
-
-  auto get_value = [&](size_t index, size_t version) {
-    return get_key(index) + "_value" + ToString(version);
-  };
-
-  auto check_iterator = [&](Iterator* iterator, Status expected_status,
-                            const Slice& expected_value) {
-    ASSERT_EQ(expected_status, iterator->status());
-    if (expected_status.ok()) {
-      ASSERT_TRUE(iterator->Valid());
-      ASSERT_EQ(expected_value, iterator->value());
-    } else {
-      ASSERT_FALSE(iterator->Valid());
-    }
-  };
-
-  auto verify = [&](size_t index, Status expected_status,
-                    const Slice& expected_value) {
-    // Seek
-    {
-      Iterator* iterator = db_->NewIterator(ReadOptions());
-      std::unique_ptr<Iterator> iterator_guard(iterator);
-      ASSERT_OK(iterator->status());
-      ASSERT_OK(iterator->Refresh());
-      iterator->Seek(get_key(index));
-      check_iterator(iterator, expected_status, expected_value);
-    }
-    // Next
-    {
-      Iterator* iterator = db_->NewIterator(ReadOptions());
-      std::unique_ptr<Iterator> iterator_guard(iterator);
-      ASSERT_OK(iterator->Refresh());
-      iterator->Seek(get_key(index - 1));
-      ASSERT_TRUE(iterator->Valid());
-      ASSERT_OK(iterator->status());
-      iterator->Next();
-      check_iterator(iterator, expected_status, expected_value);
-    }
-    // SeekForPrev
-    {
-      Iterator* iterator = db_->NewIterator(ReadOptions());
-      std::unique_ptr<Iterator> iterator_guard(iterator);
-      ASSERT_OK(iterator->status());
-      ASSERT_OK(iterator->Refresh());
-      iterator->SeekForPrev(get_key(index));
-      check_iterator(iterator, expected_status, expected_value);
-    }
-    // Prev
-    {
-      Iterator* iterator = db_->NewIterator(ReadOptions());
-      std::unique_ptr<Iterator> iterator_guard(iterator);
-      iterator->Seek(get_key(index + 1));
-      ASSERT_TRUE(iterator->Valid());
-      ASSERT_OK(iterator->status());
-      iterator->Prev();
-      check_iterator(iterator, expected_status, expected_value);
-    }
-  };
-
-  Options options = GetTestOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 0;
-
-  DestroyAndReopen(options);
-
-  // fill data
-  for (size_t i = 0; i < data.size(); i++) {
-    for (size_t j = 0; j < data[i].size(); j++) {
-      std::string key = get_key(i);
-      std::string value = get_value(i, j);
-      if (data[i][j] == "Put") {
-        ASSERT_OK(Put(key, value));
-        ASSERT_OK(Flush());
-      } else if (data[i][j] == "Merge") {
-        ASSERT_OK(Merge(key, value));
-        ASSERT_OK(Flush());
-      }
-    }
-  }
-
-  std::string expected_value = get_value(1, 0) + "," + get_value(1, 1) + "," +
-                               get_value(1, 2) + "," + get_value(1, 3);
-  Status expected_status;
-  verify(1, expected_status, expected_value);
-
-#ifndef ROCKSDB_LITE
-  // Test DBIter::FindValueForCurrentKeyUsingSeek flow.
-  ASSERT_OK(dbfull()->SetOptions(cfh(),
-                                 {{"max_sequential_skip_in_iterations", "0"}}));
-  verify(1, expected_status, expected_value);
-#endif  // !ROCKSDB_LITE
-}
-
 }  // namespace ROCKSDB_NAMESPACE

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -65,13 +65,11 @@ Status BuildTable(
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, bool paranoid_file_checks,
    InternalStats* internal_stats, IOStatus* io_status,
-    const std::shared_ptr<IOTracer>& io_tracer,
-    BlobFileCreationReason blob_creation_reason, EventLogger* event_logger,
+    const std::shared_ptr<IOTracer>& io_tracer, EventLogger* event_logger,
    int job_id, const Env::IOPriority io_priority,
    TableProperties* table_properties, Env::WriteLifeTimeHint write_hint,
    const std::string* full_history_ts_low,
-    BlobFileCompletionCallback* blob_callback, uint64_t* num_input_entries,
-    uint64_t* memtable_payload_bytes, uint64_t* memtable_garbage_bytes) {
+    BlobFileCompletionCallback* blob_callback, uint64_t* num_input_entries) {
  assert((tboptions.column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         tboptions.column_family_name.empty());
@@ -91,12 +89,9 @@ Status BuildTable(
      new CompactionRangeDelAggregator(&tboptions.internal_comparator,
                                       snapshots));
  uint64_t num_unfragmented_tombstones = 0;
-  uint64_t total_tombstone_payload_bytes = 0;
  for (auto& range_del_iter : range_del_iters) {
    num_unfragmented_tombstones +=
        range_del_iter->num_unfragmented_tombstones();
-    total_tombstone_payload_bytes +=
-        range_del_iter->total_tombstone_payload_bytes();
    range_del_agg->AddTombstones(std::move(range_del_iter));
  }

@@ -166,7 +161,7 @@ Status BuildTable(
          std::move(file), fname, file_options, ioptions.clock, io_tracer,
          ioptions.stats, ioptions.listeners,
          ioptions.file_checksum_gen_factory.get(),
-          tmp_set.Contains(FileType::kTableFile), false));
+          tmp_set.Contains(FileType::kTableFile)));

      builder = NewTableBuilder(tboptions, file_writer.get());
    }
@@ -179,12 +174,12 @@ Status BuildTable(

    std::unique_ptr<BlobFileBuilder> blob_file_builder(
        (mutable_cf_options.enable_blob_files && blob_file_additions)
-            ? new BlobFileBuilder(
-                  versions, fs, &ioptions, &mutable_cf_options, &file_options,
-                  job_id, tboptions.column_family_id,
-                  tboptions.column_family_name, io_priority, write_hint,
-                  io_tracer, blob_callback, blob_creation_reason,
-                  &blob_file_paths, blob_file_additions)
+            ? new BlobFileBuilder(versions, fs, &ioptions, &mutable_cf_options,
+                                  &file_options, job_id,
+                                  tboptions.column_family_id,
+                                  tboptions.column_family_name, io_priority,
+                                  write_hint, io_tracer, blob_callback,
+                                  &blob_file_paths, blob_file_additions)
            : nullptr);

    CompactionIterator c_iter(
@@ -196,8 +191,7 @@ Status BuildTable(
        /*compaction=*/nullptr, compaction_filter.get(),
        /*shutting_down=*/nullptr,
        /*preserve_deletes_seqnum=*/0, /*manual_compaction_paused=*/nullptr,
-        /*manual_compaction_canceled=*/nullptr, db_options.info_log,
-        full_history_ts_low);
+        db_options.info_log, full_history_ts_low);

    c_iter.SeekToFirst();
    for (; c_iter.Valid(); c_iter.Next()) {
@@ -205,8 +199,6 @@ Status BuildTable(
      const Slice& value = c_iter.value();
      const ParsedInternalKey& ikey = c_iter.ikey();
      // Generate a rolling 64-bit hash of the key and values
-      // Note :
-      // Here "key" integrates 'sequence_number'+'kType'+'user key'.
      s = output_validator.Add(key, value);
      if (!s.ok()) {
        break;
@@ -261,25 +253,6 @@ Status BuildTable(
      meta->marked_for_compaction = builder->NeedCompact();
      assert(meta->fd.GetFileSize() > 0);
      tp = builder->GetTableProperties(); // refresh now that builder is finished
-      if (memtable_payload_bytes != nullptr &&
-          memtable_garbage_bytes != nullptr) {
-        const CompactionIterationStats& ci_stats = c_iter.iter_stats();
-        uint64_t total_payload_bytes = ci_stats.total_input_raw_key_bytes +
-                                       ci_stats.total_input_raw_value_bytes +
-                                       total_tombstone_payload_bytes;
-        uint64_t total_payload_bytes_written =
-            (tp.raw_key_size + tp.raw_value_size);
-        // Prevent underflow, which may still happen at this point
-        // since we only support inserts, deletes, and deleteRanges.
-        if (total_payload_bytes_written <= total_payload_bytes) {
-          *memtable_payload_bytes = total_payload_bytes;
-          *memtable_garbage_bytes =
-              total_payload_bytes - total_payload_bytes_written;
-        } else {
-          *memtable_payload_bytes = 0;
-          *memtable_garbage_bytes = 0;
-        }
-      }
      if (table_properties) {
        *table_properties = tp;
      }
@@ -312,7 +285,7 @@ Status BuildTable(
      if (s.ok()) {
        s = blob_file_builder->Finish();
      } else {
-        blob_file_builder->Abandon(s);
+        blob_file_builder->Abandon();
      }
      blob_file_builder.reset();
    }
@@ -60,15 +60,12 @@ extern Status BuildTable(
    SnapshotChecker* snapshot_checker, bool paranoid_file_checks,
    InternalStats* internal_stats, IOStatus* io_status,
    const std::shared_ptr<IOTracer>& io_tracer,
-    BlobFileCreationReason blob_creation_reason,
    EventLogger* event_logger = nullptr, int job_id = 0,
    const Env::IOPriority io_priority = Env::IO_HIGH,
    TableProperties* table_properties = nullptr,
    Env::WriteLifeTimeHint write_hint = Env::WLTH_NOT_SET,
    const std::string* full_history_ts_low = nullptr,
    BlobFileCompletionCallback* blob_callback = nullptr,
-    uint64_t* num_input_entries = nullptr,
-    uint64_t* memtable_payload_bytes = nullptr,
-    uint64_t* memtable_garbage_bytes = nullptr);
+    uint64_t* num_input_entries = nullptr);

 }  // namespace ROCKSDB_NAMESPACE
@@ -88,7 +88,6 @@ using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
 using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory;
 using ROCKSDB_NAMESPACE::NewGenericRateLimiter;
 using ROCKSDB_NAMESPACE::NewLRUCache;
-using ROCKSDB_NAMESPACE::NewRibbonFilterPolicy;
 using ROCKSDB_NAMESPACE::OptimisticTransactionDB;
 using ROCKSDB_NAMESPACE::OptimisticTransactionOptions;
 using ROCKSDB_NAMESPACE::Options;
@@ -3029,11 +3028,6 @@ unsigned char rocksdb_options_get_advise_random_on_open(
  return opt->rep.advise_random_on_open;
 }

-void rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t* opt,
-                                                         double v) {
-  opt->rep.experimental_mempurge_threshold = v;
-}
-
 void rocksdb_options_set_access_hint_on_compaction_start(
    rocksdb_options_t* opt, int v) {
  switch(v) {
@@ -3840,8 +3834,7 @@ void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) {
  delete filter;
 }

-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(
-    double bits_per_key, bool original_format) {
+rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(int bits_per_key, bool original_format) {
  // Make a rocksdb_filterpolicy_t, but override all of its methods so
  // they delegate to a NewBloomFilterPolicy() instead of user
  // supplied C functions.
@@ -3876,63 +3869,14 @@ rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(
  return wrapper;
 }

-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_full(
-    double bits_per_key) {
+rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_full(int bits_per_key) {
  return rocksdb_filterpolicy_create_bloom_format(bits_per_key, false);
 }

-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(double bits_per_key) {
+rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(int bits_per_key) {
  return rocksdb_filterpolicy_create_bloom_format(bits_per_key, true);
 }

-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_format(
-    double bloom_equivalent_bits_per_key, int bloom_before_level) {
-  // Make a rocksdb_filterpolicy_t, but override all of its methods so
-  // they delegate to a NewRibbonFilterPolicy() instead of user
-  // supplied C functions.
-  struct Wrapper : public rocksdb_filterpolicy_t {
-    const FilterPolicy* rep_;
-    ~Wrapper() override { delete rep_; }
-    const char* Name() const override { return rep_->Name(); }
-    void CreateFilter(const Slice* keys, int n,
-                      std::string* dst) const override {
-      return rep_->CreateFilter(keys, n, dst);
-    }
-    bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
-      return rep_->KeyMayMatch(key, filter);
-    }
-    ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext(
-        const ROCKSDB_NAMESPACE::FilterBuildingContext& context)
-        const override {
-      return rep_->GetBuilderWithContext(context);
-    }
-    ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader(
-        const Slice& contents) const override {
-      return rep_->GetFilterBitsReader(contents);
-    }
-    static void DoNothing(void*) {}
-  };
-  Wrapper* wrapper = new Wrapper;
-  wrapper->rep_ =
-      NewRibbonFilterPolicy(bloom_equivalent_bits_per_key, bloom_before_level);
-  wrapper->state_ = nullptr;
-  wrapper->delete_filter_ = nullptr;
-  wrapper->destructor_ = &Wrapper::DoNothing;
-  return wrapper;
-}
-
-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon(
-    double bloom_equivalent_bits_per_key) {
-  return rocksdb_filterpolicy_create_ribbon_format(
-      bloom_equivalent_bits_per_key, /*bloom_before_level = disabled*/ -1);
-}
-
-rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_hybrid(
-    double bloom_equivalent_bits_per_key, int bloom_before_level) {
-  return rocksdb_filterpolicy_create_ribbon_format(
-      bloom_equivalent_bits_per_key, bloom_before_level);
-}
-
 rocksdb_mergeoperator_t* rocksdb_mergeoperator_create(
    void* state, void (*destructor)(void*),
    char* (*full_merge)(void*, const char* key, size_t key_length,
@@ -4884,27 +4828,6 @@ void rocksdb_optimistictransaction_options_set_set_snapshot(
  opt->rep.set_snapshot = v;
 }

-char* rocksdb_optimistictransactiondb_property_value(
-    rocksdb_optimistictransactiondb_t* db, const char* propname) {
-  std::string tmp;
-  if (db->rep->GetProperty(Slice(propname), &tmp)) {
-    // We use strdup() since we expect human readable output.
-    return strdup(tmp.c_str());
-  } else {
-    return nullptr;
-  }
-}
-
-int rocksdb_optimistictransactiondb_property_int(
-    rocksdb_optimistictransactiondb_t* db, const char* propname,
-    uint64_t* out_val) {
-  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
 rocksdb_column_family_handle_t* rocksdb_transactiondb_create_column_family(
    rocksdb_transactiondb_t* txn_db,
    const rocksdb_options_t* column_family_options,
@@ -4975,27 +4898,6 @@ void rocksdb_transactiondb_release_snapshot(
  delete snapshot;
 }

-char* rocksdb_transactiondb_property_value(rocksdb_transactiondb_t* db,
-                                           const char* propname) {
-  std::string tmp;
-  if (db->rep->GetProperty(Slice(propname), &tmp)) {
-    // We use strdup() since we expect human readable output.
-    return strdup(tmp.c_str());
-  } else {
-    return nullptr;
-  }
-}
-
-int rocksdb_transactiondb_property_int(rocksdb_transactiondb_t* db,
-                                       const char* propname,
-                                       uint64_t* out_val) {
-  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
 rocksdb_transaction_t* rocksdb_transaction_begin(
    rocksdb_transactiondb_t* txn_db,
    const rocksdb_writeoptions_t* write_options,
@@ -5398,31 +5300,12 @@ rocksdb_transaction_t* rocksdb_optimistictransaction_begin(
  return old_txn;
 }

-// Write batch into OptimisticTransactionDB
-void rocksdb_optimistictransactiondb_write(
-    rocksdb_optimistictransactiondb_t* otxn_db,
-    const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch,
-    char** errptr) {
-  SaveError(errptr, otxn_db->rep->Write(options->rep, &batch->rep));
-}
-
 void rocksdb_optimistictransactiondb_close(
    rocksdb_optimistictransactiondb_t* otxn_db) {
  delete otxn_db->rep;
  delete otxn_db;
 }

-rocksdb_checkpoint_t* rocksdb_optimistictransactiondb_checkpoint_object_create(
-    rocksdb_optimistictransactiondb_t* otxn_db, char** errptr) {
-  Checkpoint* checkpoint;
-  if (SaveError(errptr, Checkpoint::Create(otxn_db->rep, &checkpoint))) {
-    return nullptr;
-  }
-  rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
-  result->rep = checkpoint;
-  return result;
-}
-
 void rocksdb_free(void* ptr) { free(ptr); }

 rocksdb_pinnableslice_t* rocksdb_get_pinned(
@@ -1043,25 +1043,19 @@ int main(int argc, char** argv) {
  }

  StartPhase("filter");
-  for (run = 0; run <= 4; run++) {
-    // run=0 uses custom filter
-    // run=1 uses old block-based bloom filter
-    // run=2 run uses full bloom filter
-    // run=3 uses Ribbon
-    // run=4 uses Ribbon-Bloom hybrid configuration
+  for (run = 0; run <= 2; run++) {
+    // First run uses custom filter
+    // Second run uses old block-based bloom filter
+    // Third run uses full bloom filter
    CheckNoError(err);
    rocksdb_filterpolicy_t* policy;
    if (run == 0) {
      policy = rocksdb_filterpolicy_create(NULL, FilterDestroy, FilterCreate,
                                           FilterKeyMatch, NULL, FilterName);
    } else if (run == 1) {
-      policy = rocksdb_filterpolicy_create_bloom(8.0);
-    } else if (run == 2) {
-      policy = rocksdb_filterpolicy_create_bloom_full(8.0);
-    } else if (run == 3) {
-      policy = rocksdb_filterpolicy_create_ribbon(8.0);
+      policy = rocksdb_filterpolicy_create_bloom(8);
    } else {
-      policy = rocksdb_filterpolicy_create_ribbon_hybrid(8.0, 1);
+      policy = rocksdb_filterpolicy_create_bloom_full(8);
    }
    rocksdb_block_based_options_set_filter_policy(table_options, policy);

@@ -1127,12 +1121,9 @@ int main(int argc, char** argv) {
      } else if (run == 1) {
        // Essentially a fingerprint of the block-based Bloom schema
        CheckCondition(hits == 241);
-      } else if (run == 2 || run == 4) {
+      } else {
        // Essentially a fingerprint of full Bloom schema, format_version=5
        CheckCondition(hits == 188);
-      } else {
-        // Essentially a fingerprint of Ribbon schema
-        CheckCondition(hits == 226);
      }
      CheckCondition(
          (keys_to_query - hits) ==
@@ -29,6 +29,7 @@
 #include "db/version_set.h"
 #include "db/write_controller.h"
 #include "file/sst_file_manager_impl.h"
+#include "memtable/hash_skiplist_rep.h"
 #include "monitoring/thread_status_util.h"
 #include "options/options_helper.h"
 #include "port/port.h"
@@ -202,7 +203,7 @@ Status CheckCFPathsSupported(const DBOptions& db_options,
 namespace {
 const uint64_t kDefaultTtl = 0xfffffffffffffffe;
 const uint64_t kDefaultPeriodicCompSecs = 0xfffffffffffffffe;
-}  // namespace
+};  // namespace

 ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
                                    const ColumnFamilyOptions& src) {
@@ -444,9 +445,6 @@ bool SuperVersion::Unref() {

 void SuperVersion::Cleanup() {
  assert(refs.load(std::memory_order_relaxed) == 0);
-  // Since this SuperVersion object is being deleted,
-  // decrement reference to the immutable MemtableList
-  // this SV object was pointing to.
  imm->Unref(&to_delete);
  MemTable* m = mem->Unref();
  if (m != nullptr) {
@@ -456,7 +454,7 @@ void SuperVersion::Cleanup() {
    to_delete.push_back(m);
  }
  current->Unref();
-  cfd->UnrefAndTryDelete();
+  cfd->UnrefAndTryDelete(this);
 }

 void SuperVersion::Init(ColumnFamilyData* new_cfd, MemTable* new_mem,
@@ -474,10 +472,10 @@ void SuperVersion::Init(ColumnFamilyData* new_cfd, MemTable* new_mem,

 namespace {
 void SuperVersionUnrefHandle(void* ptr) {
-  // UnrefHandle is called when a thread exits or a ThreadLocalPtr gets
-  // destroyed. When the former happens, the thread shouldn't see kSVInUse.
-  // When the latter happens, only super_version_ holds a reference
-  // to ColumnFamilyData, so no further queries are possible.
+  // UnrefHandle is called when a thread exists or a ThreadLocalPtr gets
+  // destroyed. When former happens, the thread shouldn't see kSVInUse.
+  // When latter happens, we are in ~ColumnFamilyData(), no get should happen as
+  // well.
  SuperVersion* sv = static_cast<SuperVersion*>(ptr);
  bool was_last_ref __attribute__((__unused__));
  was_last_ref = sv->Unref();
@@ -504,10 +502,9 @@ ColumnFamilyData::ColumnFamilyData(
    uint32_t id, const std::string& name, Version* _dummy_versions,
    Cache* _table_cache, WriteBufferManager* write_buffer_manager,
    const ColumnFamilyOptions& cf_options, const ImmutableDBOptions& db_options,
-    const FileOptions* file_options, ColumnFamilySet* column_family_set,
+    const FileOptions& file_options, ColumnFamilySet* column_family_set,
    BlockCacheTracer* const block_cache_tracer,
-    const std::shared_ptr<IOTracer>& io_tracer,
-    const std::string& db_session_id)
+    const std::shared_ptr<IOTracer>& io_tracer)
    : id_(id),
      name_(name),
      dummy_versions_(_dummy_versions),
@@ -565,8 +562,7 @@ ColumnFamilyData::ColumnFamilyData(
    internal_stats_.reset(
        new InternalStats(ioptions_.num_levels, ioptions_.clock, this));
    table_cache_.reset(new TableCache(ioptions_, file_options, _table_cache,
-                                      block_cache_tracer, io_tracer,
-                                      db_session_id));
+                                      block_cache_tracer, io_tracer));
    blob_file_cache_.reset(
        new BlobFileCache(_table_cache, ioptions(), soptions(), id_,
                          internal_stats_->GetBlobFileReadHist(), io_tracer));
@@ -667,7 +663,7 @@ ColumnFamilyData::~ColumnFamilyData() {
  }
 }

-bool ColumnFamilyData::UnrefAndTryDelete() {
+bool ColumnFamilyData::UnrefAndTryDelete(SuperVersion* sv_under_cleanup) {
  int old_refs = refs_.fetch_sub(1);
  assert(old_refs > 0);

@@ -677,17 +673,22 @@ bool ColumnFamilyData::UnrefAndTryDelete() {
    return true;
  }

-  if (old_refs == 2 && super_version_ != nullptr) {
+  // If called under SuperVersion::Cleanup, we should not re-enter Cleanup on
+  // the same SuperVersion. (But while installing a new SuperVersion, this
+  // cfd could be referenced only by two SuperVersions.)
+  if (old_refs == 2 && super_version_ != nullptr &&
+      super_version_ != sv_under_cleanup) {
    // Only the super_version_ holds me
    SuperVersion* sv = super_version_;
    super_version_ = nullptr;
-
-    // Release SuperVersion references kept in ThreadLocalPtr.
+    // Release SuperVersion reference kept in ThreadLocalPtr.
+    // This must be done outside of mutex_ since unref handler can lock mutex.
+    sv->db_mutex->Unlock();
    local_sv_.reset();
+    sv->db_mutex->Lock();

    if (sv->Unref()) {
-      // Note: sv will delete this ColumnFamilyData during Cleanup()
-      assert(sv->cfd == this);
+      // May delete this ColumnFamilyData after calling Cleanup()
      sv->Cleanup();
      delete sv;
      return true;
@@ -1048,10 +1049,6 @@ uint64_t ColumnFamilyData::GetTotalSstFilesSize() const {
  return VersionSet::GetTotalSstFilesSize(dummy_versions_);
 }

-uint64_t ColumnFamilyData::GetTotalBlobFileSize() const {
-  return VersionSet::GetTotalBlobFileSize(dummy_versions_);
-}
-
 uint64_t ColumnFamilyData::GetLiveSstFilesSize() const {
  return current_->GetSstFilesSize();
 }
@@ -1256,13 +1253,14 @@ bool ColumnFamilyData::ReturnThreadLocalSuperVersion(SuperVersion* sv) {
 void ColumnFamilyData::InstallSuperVersion(
    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex) {
  db_mutex->AssertHeld();
-  return InstallSuperVersion(sv_context, mutable_cf_options_);
+  return InstallSuperVersion(sv_context, db_mutex, mutable_cf_options_);
 }

 void ColumnFamilyData::InstallSuperVersion(
-    SuperVersionContext* sv_context,
+    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex,
    const MutableCFOptions& mutable_cf_options) {
  SuperVersion* new_superversion = sv_context->new_superversion.release();
+  new_superversion->db_mutex = db_mutex;
  new_superversion->mutable_cf_options = mutable_cf_options;
  new_superversion->Init(this, mem_, imm_.current(), current_);
  SuperVersion* old_superversion = super_version_;
@@ -1453,23 +1451,21 @@ ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
                                 WriteBufferManager* _write_buffer_manager,
                                 WriteController* _write_controller,
                                 BlockCacheTracer* const block_cache_tracer,
-                                 const std::shared_ptr<IOTracer>& io_tracer,
-                                 const std::string& db_session_id)
+                                 const std::shared_ptr<IOTracer>& io_tracer)
    : max_column_family_(0),
-      file_options_(file_options),
      dummy_cfd_(new ColumnFamilyData(
          ColumnFamilyData::kDummyColumnFamilyDataId, "", nullptr, nullptr,
-          nullptr, ColumnFamilyOptions(), *db_options, &file_options_, nullptr,
-          block_cache_tracer, io_tracer, db_session_id)),
+          nullptr, ColumnFamilyOptions(), *db_options, file_options, nullptr,
+          block_cache_tracer, io_tracer)),
      default_cfd_cache_(nullptr),
      db_name_(dbname),
      db_options_(db_options),
+      file_options_(file_options),
      table_cache_(table_cache),
      write_buffer_manager_(_write_buffer_manager),
      write_controller_(_write_controller),
      block_cache_tracer_(block_cache_tracer),
-      io_tracer_(io_tracer),
-      db_session_id_(db_session_id) {
+      io_tracer_(io_tracer) {
  // initialize linked list
  dummy_cfd_->prev_ = dummy_cfd_;
  dummy_cfd_->next_ = dummy_cfd_;
@@ -1535,8 +1531,7 @@ ColumnFamilyData* ColumnFamilySet::CreateColumnFamily(
  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_session_id_);
+      *db_options_, file_options_, this, block_cache_tracer_, io_tracer_);
  column_families_.insert({name, id});
  column_family_data_.insert({id, new_cfd});
  max_column_family_ = std::max(max_column_family_, id);
@@ -208,6 +208,8 @@ struct SuperVersion {
  uint64_t version_number;
  WriteStallCondition write_stall_condition;

+  InstrumentedMutex* db_mutex;
+
  // should be called outside the mutex
  SuperVersion() = default;
  ~SuperVersion();
@@ -279,7 +281,8 @@ class ColumnFamilyData {
  // UnrefAndTryDelete() decreases the reference count and do free if needed,
  // return true if this is freed else false, UnrefAndTryDelete() can only
  // be called while holding a DB mutex, or during single-threaded recovery.
-  bool UnrefAndTryDelete();
+  // sv_under_cleanup is only provided when called from SuperVersion::Cleanup.
+  bool UnrefAndTryDelete(SuperVersion* sv_under_cleanup = nullptr);

  // SetDropped() can only be called under following conditions:
  // 1) Holding a DB mutex,
@@ -357,7 +360,6 @@ class ColumnFamilyData {
  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
  void SetMemtable(MemTable* new_mem) {
    uint64_t memtable_id = last_memtable_id_.fetch_add(1) + 1;
    new_mem->SetID(memtable_id);
@@ -451,6 +453,7 @@ class ColumnFamilyData {
  // the clients to allocate SuperVersion outside of mutex.
  // IMPORTANT: Only call this from DBImpl::InstallSuperVersion()
  void InstallSuperVersion(SuperVersionContext* sv_context,
+                           InstrumentedMutex* db_mutex,
                           const MutableCFOptions& mutable_cf_options);
  void InstallSuperVersion(SuperVersionContext* sv_context,
                           InstrumentedMutex* db_mutex);
@@ -517,7 +520,6 @@ class ColumnFamilyData {
  }

  ThreadLocalPtr* TEST_GetLocalSV() { return local_sv_.get(); }
-  WriteBufferManager* write_buffer_mgr() { return write_buffer_manager_; }

 private:
  friend class ColumnFamilySet;
@@ -527,11 +529,10 @@ class ColumnFamilyData {
                   WriteBufferManager* write_buffer_manager,
                   const ColumnFamilyOptions& options,
                   const ImmutableDBOptions& db_options,
-                   const FileOptions* file_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_session_id);
+                   const std::shared_ptr<IOTracer>& io_tracer);

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

@@ -667,8 +668,7 @@ class ColumnFamilySet {
                  WriteBufferManager* _write_buffer_manager,
                  WriteController* _write_controller,
                  BlockCacheTracer* const block_cache_tracer,
-                  const std::shared_ptr<IOTracer>& io_tracer,
-                  const std::string& db_session_id);
+                  const std::shared_ptr<IOTracer>& io_tracer);
  ~ColumnFamilySet();

  ColumnFamilyData* GetDefault() const;
@@ -718,8 +718,6 @@ class ColumnFamilySet {
  std::unordered_map<uint32_t, ColumnFamilyData*> column_family_data_;

  uint32_t max_column_family_;
-  const FileOptions file_options_;
-
  ColumnFamilyData* dummy_cfd_;
  // We don't hold the refcount here, since default column family always exists
  // We are also not responsible for cleaning up default_cfd_cache_. This is
@@ -729,12 +727,12 @@ class ColumnFamilySet {

  const std::string db_name_;
  const ImmutableDBOptions* const db_options_;
+  const FileOptions file_options_;
  Cache* table_cache_;
  WriteBufferManager* write_buffer_manager_;
  WriteController* write_controller_;
  BlockCacheTracer* const block_cache_tracer_;
  std::shared_ptr<IOTracer> io_tracer_;
-  std::string db_session_id_;
 };

 // We use ColumnFamilyMemTablesImpl to provide WriteBatch a way to access
@@ -56,8 +56,16 @@ class ColumnFamilyTestBase : public testing::Test {
 public:
  explicit ColumnFamilyTestBase(uint32_t format) : rnd_(139), format_(format) {
    Env* base_env = Env::Default();
-    EXPECT_OK(
-        test::CreateEnvFromSystem(ConfigOptions(), &base_env, &env_guard_));
+#ifndef ROCKSDB_LITE
+    const char* test_env_uri = getenv("TEST_ENV_URI");
+    if (test_env_uri) {
+      Env* test_env = nullptr;
+      Status s = Env::LoadEnv(test_env_uri, &test_env, &env_guard_);
+      base_env = test_env;
+      EXPECT_OK(s);
+      EXPECT_NE(Env::Default(), base_env);
+    }
+#endif  // !ROCKSDB_LITE
    EXPECT_NE(nullptr, base_env);
    env_ = new EnvCounter(base_env);
    env_->skip_fsync_ = true;
@@ -2975,8 +2983,7 @@ TEST_P(ColumnFamilyTest, FlushCloseWALFiles) {
  SpecialEnv env(Env::Default());
  db_options_.env = &env;
  db_options_.max_background_flushes = 1;
-  column_family_options_.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(2));
+  column_family_options_.memtable_factory.reset(new SpecialSkipListFactory(2));
  Open();
  CreateColumnFamilies({"one"});
  ASSERT_OK(Put(1, "fodor", "mirko"));
@@ -3021,8 +3028,7 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile1) {
  SpecialEnv env(Env::Default());
  db_options_.env = &env;
  db_options_.max_background_flushes = 1;
-  column_family_options_.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(2));
+  column_family_options_.memtable_factory.reset(new SpecialSkipListFactory(2));
  Open();
  CreateColumnFamilies({"one"});
  ASSERT_OK(Put(1, "fodor", "mirko"));
@@ -3073,8 +3079,7 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile2) {
  env.SetBackgroundThreads(2, Env::HIGH);
  db_options_.env = &env;
  db_options_.max_background_flushes = 1;
-  column_family_options_.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(2));
+  column_family_options_.memtable_factory.reset(new SpecialSkipListFactory(2));
  Open();
  CreateColumnFamilies({"one"});
  ASSERT_OK(Put(1, "fodor", "mirko"));
@@ -3132,8 +3137,7 @@ TEST_P(ColumnFamilyTest, ForwardIteratorCloseWALFile) {
  env.SetBackgroundThreads(2, Env::HIGH);
  db_options_.env = &env;
  db_options_.max_background_flushes = 1;
-  column_family_options_.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(3));
+  column_family_options_.memtable_factory.reset(new SpecialSkipListFactory(3));
  column_family_options_.level0_file_num_compaction_trigger = 2;
  Open();
  CreateColumnFamilies({"one"});
@@ -1,275 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cassert>
-
-#include "table/internal_iterator.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// An internal iterator that wraps another one and ensures that any keys
-// returned are strictly within a range [start, end). If the underlying
-// iterator has already performed the bounds checking, it relies on that result;
-// otherwise, it performs the necessary key comparisons itself. Both bounds
-// are optional.
-class ClippingIterator : public InternalIterator {
- public:
-  ClippingIterator(InternalIterator* iter, const Slice* start, const Slice* end,
-                   const Comparator* cmp)
-      : iter_(iter), start_(start), end_(end), cmp_(cmp), valid_(false) {
-    assert(iter_);
-    assert(cmp_);
-    assert(!start_ || !end_ || cmp_->Compare(*start_, *end_) <= 0);
-
-    UpdateAndEnforceBounds();
-  }
-
-  bool Valid() const override { return valid_; }
-
-  void SeekToFirst() override {
-    if (start_) {
-      iter_->Seek(*start_);
-    } else {
-      iter_->SeekToFirst();
-    }
-
-    UpdateAndEnforceUpperBound();
-  }
-
-  void SeekToLast() override {
-    if (end_) {
-      iter_->SeekForPrev(*end_);
-
-      // Upper bound is exclusive, so we need a key which is strictly smaller
-      if (iter_->Valid() && cmp_->Compare(iter_->key(), *end_) == 0) {
-        iter_->Prev();
-      }
-    } else {
-      iter_->SeekToLast();
-    }
-
-    UpdateAndEnforceLowerBound();
-  }
-
-  void Seek(const Slice& target) override {
-    if (start_ && cmp_->Compare(target, *start_) < 0) {
-      iter_->Seek(*start_);
-      UpdateAndEnforceUpperBound();
-      return;
-    }
-
-    if (end_ && cmp_->Compare(target, *end_) >= 0) {
-      valid_ = false;
-      return;
-    }
-
-    iter_->Seek(target);
-    UpdateAndEnforceUpperBound();
-  }
-
-  void SeekForPrev(const Slice& target) override {
-    if (start_ && cmp_->Compare(target, *start_) < 0) {
-      valid_ = false;
-      return;
-    }
-
-    if (end_ && cmp_->Compare(target, *end_) >= 0) {
-      iter_->SeekForPrev(*end_);
-
-      // Upper bound is exclusive, so we need a key which is strictly smaller
-      if (iter_->Valid() && cmp_->Compare(iter_->key(), *end_) == 0) {
-        iter_->Prev();
-      }
-
-      UpdateAndEnforceLowerBound();
-      return;
-    }
-
-    iter_->SeekForPrev(target);
-    UpdateAndEnforceLowerBound();
-  }
-
-  void Next() override {
-    assert(valid_);
-    iter_->Next();
-    UpdateAndEnforceUpperBound();
-  }
-
-  bool NextAndGetResult(IterateResult* result) override {
-    assert(valid_);
-    assert(result);
-
-    IterateResult res;
-    valid_ = iter_->NextAndGetResult(&res);
-
-    if (!valid_) {
-      return false;
-    }
-
-    if (end_) {
-      EnforceUpperBoundImpl(res.bound_check_result);
-
-      if (!valid_) {
-        return false;
-      }
-    }
-
-    res.bound_check_result = IterBoundCheck::kInbound;
-    *result = res;
-
-    return true;
-  }
-
-  void Prev() override {
-    assert(valid_);
-    iter_->Prev();
-    UpdateAndEnforceLowerBound();
-  }
-
-  Slice key() const override {
-    assert(valid_);
-    return iter_->key();
-  }
-
-  Slice user_key() const override {
-    assert(valid_);
-    return iter_->user_key();
-  }
-
-  Slice value() const override {
-    assert(valid_);
-    return iter_->value();
-  }
-
-  Status status() const override { return iter_->status(); }
-
-  bool PrepareValue() override {
-    assert(valid_);
-
-    if (iter_->PrepareValue()) {
-      return true;
-    }
-
-    assert(!iter_->Valid());
-    valid_ = false;
-    return false;
-  }
-
-  bool MayBeOutOfLowerBound() override {
-    assert(valid_);
-    return false;
-  }
-
-  IterBoundCheck UpperBoundCheckResult() override {
-    assert(valid_);
-    return IterBoundCheck::kInbound;
-  }
-
-  void SetPinnedItersMgr(PinnedIteratorsManager* pinned_iters_mgr) override {
-    iter_->SetPinnedItersMgr(pinned_iters_mgr);
-  }
-
-  bool IsKeyPinned() const override {
-    assert(valid_);
-    return iter_->IsKeyPinned();
-  }
-
-  bool IsValuePinned() const override {
-    assert(valid_);
-    return iter_->IsValuePinned();
-  }
-
-  Status GetProperty(std::string prop_name, std::string* prop) override {
-    return iter_->GetProperty(prop_name, prop);
-  }
-
- private:
-  void UpdateValid() {
-    assert(!iter_->Valid() || iter_->status().ok());
-
-    valid_ = iter_->Valid();
-  }
-
-  void EnforceUpperBoundImpl(IterBoundCheck bound_check_result) {
-    if (bound_check_result == IterBoundCheck::kInbound) {
-      return;
-    }
-
-    if (bound_check_result == IterBoundCheck::kOutOfBound) {
-      valid_ = false;
-      return;
-    }
-
-    assert(bound_check_result == IterBoundCheck::kUnknown);
-
-    if (cmp_->Compare(key(), *end_) >= 0) {
-      valid_ = false;
-    }
-  }
-
-  void EnforceUpperBound() {
-    if (!valid_) {
-      return;
-    }
-
-    if (!end_) {
-      return;
-    }
-
-    EnforceUpperBoundImpl(iter_->UpperBoundCheckResult());
-  }
-
-  void EnforceLowerBound() {
-    if (!valid_) {
-      return;
-    }
-
-    if (!start_) {
-      return;
-    }
-
-    if (!iter_->MayBeOutOfLowerBound()) {
-      return;
-    }
-
-    if (cmp_->Compare(key(), *start_) < 0) {
-      valid_ = false;
-    }
-  }
-
-  void AssertBounds() {
-    assert(!valid_ || !start_ || cmp_->Compare(key(), *start_) >= 0);
-    assert(!valid_ || !end_ || cmp_->Compare(key(), *end_) < 0);
-  }
-
-  void UpdateAndEnforceBounds() {
-    UpdateValid();
-    EnforceUpperBound();
-    EnforceLowerBound();
-    AssertBounds();
-  }
-
-  void UpdateAndEnforceUpperBound() {
-    UpdateValid();
-    EnforceUpperBound();
-    AssertBounds();
-  }
-
-  void UpdateAndEnforceLowerBound() {
-    UpdateValid();
-    EnforceLowerBound();
-    AssertBounds();
-  }
-
-  InternalIterator* iter_;
-  const Slice* start_;
-  const Slice* end_;
-  const Comparator* cmp_;
-  bool valid_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,256 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/compaction/clipping_iterator.h"
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "rocksdb/comparator.h"
-#include "test_util/testharness.h"
-#include "test_util/testutil.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A vector iterator which does its own bounds checking. This is for testing the
-// optimizations in the clipping iterator where we bypass the bounds checking if
-// the input iterator has already performed it.
-class BoundsCheckingVectorIterator : public test::VectorIterator {
- public:
-  BoundsCheckingVectorIterator(const std::vector<std::string>& keys,
-                               const std::vector<std::string>& values,
-                               const Slice* start, const Slice* end,
-                               const Comparator* cmp)
-      : VectorIterator(keys, values), start_(start), end_(end), cmp_(cmp) {
-    assert(cmp_);
-  }
-
-  bool NextAndGetResult(IterateResult* result) override {
-    assert(Valid());
-    assert(result);
-
-    Next();
-
-    if (!Valid()) {
-      return false;
-    }
-
-    result->key = key();
-    result->bound_check_result = UpperBoundCheckResult();
-    result->value_prepared = true;
-
-    return true;
-  }
-
-  bool MayBeOutOfLowerBound() override {
-    assert(Valid());
-
-    if (!start_) {
-      return false;
-    }
-
-    return cmp_->Compare(key(), *start_) < 0;
-  }
-
-  IterBoundCheck UpperBoundCheckResult() override {
-    assert(Valid());
-
-    if (!end_) {
-      return IterBoundCheck::kInbound;
-    }
-
-    return cmp_->Compare(key(), *end_) >= 0 ? IterBoundCheck::kOutOfBound
-                                            : IterBoundCheck::kInbound;
-  }
-
- private:
-  const Slice* start_;
-  const Slice* end_;
-  const Comparator* cmp_;
-};
-
-class ClippingIteratorTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<std::tuple<bool, size_t, size_t>> {};
-
-TEST_P(ClippingIteratorTest, Clip) {
-  const std::vector<std::string> keys{"key0", "key1", "key2", "key3", "key4",
-                                      "key5", "key6", "key7", "key8", "key9"};
-  const std::vector<std::string> values{
-      "unused0", "value1",  "value2",  "value3",  "unused4",
-      "unused5", "unused6", "unused7", "unused8", "unused9"};
-
-  assert(keys.size() == values.size());
-
-  // Note: the input always contains key1, key2, and key3; however, the clipping
-  // window is based on the test parameters: its left edge is a value in the
-  // range [0, 4], and its size is a value in the range [0, 5]
-  const std::vector<std::string> input_keys{keys[1], keys[2], keys[3]};
-  const std::vector<std::string> input_values{values[1], values[2], values[3]};
-
-  const bool use_bounds_checking_vec_it = std::get<0>(GetParam());
-
-  const size_t clip_start_idx = std::get<1>(GetParam());
-  const size_t clip_window_size = std::get<2>(GetParam());
-  const size_t clip_end_idx = clip_start_idx + clip_window_size;
-
-  const Slice start(keys[clip_start_idx]);
-  const Slice end(keys[clip_end_idx]);
-
-  std::unique_ptr<InternalIterator> input(
-      use_bounds_checking_vec_it
-          ? new BoundsCheckingVectorIterator(input_keys, input_values, &start,
-                                             &end, BytewiseComparator())
-          : new test::VectorIterator(input_keys, input_values));
-
-  ClippingIterator clip(input.get(), &start, &end, BytewiseComparator());
-
-  // The range the clipping iterator should return values from. This is
-  // essentially the intersection of the input range [1, 4) and the clipping
-  // window [clip_start_idx, clip_end_idx)
-  const size_t data_start_idx =
-      std::max(clip_start_idx, static_cast<size_t>(1));
-  const size_t data_end_idx = std::min(clip_end_idx, static_cast<size_t>(4));
-
-  // Range is empty; all Seeks should fail
-  if (data_start_idx >= data_end_idx) {
-    clip.SeekToFirst();
-    ASSERT_FALSE(clip.Valid());
-
-    clip.SeekToLast();
-    ASSERT_FALSE(clip.Valid());
-
-    for (size_t i = 0; i < keys.size(); ++i) {
-      clip.Seek(keys[i]);
-      ASSERT_FALSE(clip.Valid());
-
-      clip.SeekForPrev(keys[i]);
-      ASSERT_FALSE(clip.Valid());
-    }
-
-    return;
-  }
-
-  // Range is non-empty; call SeekToFirst and iterate forward
-  clip.SeekToFirst();
-  ASSERT_TRUE(clip.Valid());
-  ASSERT_EQ(clip.key(), keys[data_start_idx]);
-  ASSERT_EQ(clip.value(), values[data_start_idx]);
-  ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-  ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-
-  for (size_t i = data_start_idx + 1; i < data_end_idx; ++i) {
-    clip.Next();
-    ASSERT_TRUE(clip.Valid());
-    ASSERT_EQ(clip.key(), keys[i]);
-    ASSERT_EQ(clip.value(), values[i]);
-    ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-    ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-  }
-
-  clip.Next();
-  ASSERT_FALSE(clip.Valid());
-
-  // Do it again using NextAndGetResult
-  clip.SeekToFirst();
-  ASSERT_TRUE(clip.Valid());
-  ASSERT_EQ(clip.key(), keys[data_start_idx]);
-  ASSERT_EQ(clip.value(), values[data_start_idx]);
-  ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-  ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-
-  for (size_t i = data_start_idx + 1; i < data_end_idx; ++i) {
-    IterateResult result;
-    ASSERT_TRUE(clip.NextAndGetResult(&result));
-    ASSERT_EQ(result.key, keys[i]);
-    ASSERT_EQ(result.bound_check_result, IterBoundCheck::kInbound);
-    ASSERT_TRUE(clip.Valid());
-    ASSERT_EQ(clip.key(), keys[i]);
-    ASSERT_EQ(clip.value(), values[i]);
-    ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-    ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-  }
-
-  IterateResult result;
-  ASSERT_FALSE(clip.NextAndGetResult(&result));
-  ASSERT_FALSE(clip.Valid());
-
-  // Call SeekToLast and iterate backward
-  clip.SeekToLast();
-  ASSERT_TRUE(clip.Valid());
-  ASSERT_EQ(clip.key(), keys[data_end_idx - 1]);
-  ASSERT_EQ(clip.value(), values[data_end_idx - 1]);
-  ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-  ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-
-  for (size_t i = data_end_idx - 2; i >= data_start_idx; --i) {
-    clip.Prev();
-    ASSERT_TRUE(clip.Valid());
-    ASSERT_EQ(clip.key(), keys[i]);
-    ASSERT_EQ(clip.value(), values[i]);
-    ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-    ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-  }
-
-  clip.Prev();
-  ASSERT_FALSE(clip.Valid());
-
-  // Call Seek/SeekForPrev for all keys; Seek should return the smallest key
-  // which is >= the target; SeekForPrev should return the largest key which is
-  // <= the target
-  for (size_t i = 0; i < keys.size(); ++i) {
-    clip.Seek(keys[i]);
-
-    if (i < data_start_idx) {
-      ASSERT_TRUE(clip.Valid());
-      ASSERT_EQ(clip.key(), keys[data_start_idx]);
-      ASSERT_EQ(clip.value(), values[data_start_idx]);
-      ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-      ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-    } else if (i < data_end_idx) {
-      ASSERT_TRUE(clip.Valid());
-      ASSERT_EQ(clip.key(), keys[i]);
-      ASSERT_EQ(clip.value(), values[i]);
-      ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-      ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-    } else {
-      ASSERT_FALSE(clip.Valid());
-    }
-
-    clip.SeekForPrev(keys[i]);
-
-    if (i < data_start_idx) {
-      ASSERT_FALSE(clip.Valid());
-    } else if (i < data_end_idx) {
-      ASSERT_TRUE(clip.Valid());
-      ASSERT_EQ(clip.key(), keys[i]);
-      ASSERT_EQ(clip.value(), values[i]);
-      ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-      ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-    } else {
-      ASSERT_TRUE(clip.Valid());
-      ASSERT_EQ(clip.key(), keys[data_end_idx - 1]);
-      ASSERT_EQ(clip.value(), values[data_end_idx - 1]);
-      ASSERT_FALSE(clip.MayBeOutOfLowerBound());
-      ASSERT_EQ(clip.UpperBoundCheckResult(), IterBoundCheck::kInbound);
-    }
-  }
-}
-
-INSTANTIATE_TEST_CASE_P(
-    ClippingIteratorTest, ClippingIteratorTest,
-    ::testing::Combine(
-        ::testing::Bool(),
-        ::testing::Range(static_cast<size_t>(0), static_cast<size_t>(5)),
-        ::testing::Range(static_cast<size_t>(0), static_cast<size_t>(6))));
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -211,9 +211,9 @@ Compaction::Compaction(
    std::vector<CompactionInputFiles> _inputs, int _output_level,
    uint64_t _target_file_size, uint64_t _max_compaction_bytes,
    uint32_t _output_path_id, CompressionType _compression,
-    CompressionOptions _compression_opts, Temperature _output_temperature,
-    uint32_t _max_subcompactions, std::vector<FileMetaData*> _grandparents,
-    bool _manual_compaction, double _score, bool _deletion_compaction,
+    CompressionOptions _compression_opts, uint32_t _max_subcompactions,
+    std::vector<FileMetaData*> _grandparents, bool _manual_compaction,
+    double _score, bool _deletion_compaction,
    CompactionReason _compaction_reason)
    : input_vstorage_(vstorage),
      start_level_(_inputs[0].level),
@@ -229,7 +229,6 @@ Compaction::Compaction(
      output_path_id_(_output_path_id),
      output_compression_(_compression),
      output_compression_opts_(_compression_opts),
-      output_temperature_(_output_temperature),
      deletion_compaction_(_deletion_compaction),
      inputs_(PopulateWithAtomicBoundaries(vstorage, std::move(_inputs))),
      grandparents_(std::move(_grandparents)),
@@ -238,8 +237,7 @@ Compaction::Compaction(
      is_full_compaction_(IsFullCompaction(vstorage, inputs_)),
      is_manual_compaction_(_manual_compaction),
      is_trivial_move_(false),
-      compaction_reason_(_compaction_reason),
-      notify_on_compaction_completion_(false) {
+      compaction_reason_(_compaction_reason) {
  MarkFilesBeingCompacted(true);
  if (is_manual_compaction_) {
    compaction_reason_ = CompactionReason::kManualCompaction;
@@ -309,12 +307,6 @@ bool Compaction::IsTrivialMove() const {
    return false;
  }

-  if (start_level_ == output_level_) {
-    // It doesn't make sense if compaction picker picks files just to trivial
-    // move to the same level.
-    return false;
-  }
-
  // Used in universal compaction, where trivial move can be done if the
  // input files are non overlapping
  if ((mutable_cf_options_.compaction_options_universal.allow_trivial_move) &&
@@ -571,14 +563,6 @@ bool Compaction::ShouldFormSubcompactions() const {
  if (max_subcompactions_ <= 1 || cfd_ == nullptr) {
    return false;
  }
-
-  // Note: the subcompaction boundary picking logic does not currently guarantee
-  // that all user keys that differ only by timestamp get processed by the same
-  // subcompaction.
-  if (cfd_->user_comparator()->timestamp_size() > 0) {
-    return false;
-  }
-
  if (cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
    return (start_level_ == 0 || is_manual_compaction_) && output_level_ > 0 &&
           !IsOutputLevelEmpty();
@@ -589,29 +573,6 @@ bool Compaction::ShouldFormSubcompactions() const {
  }
 }

-bool Compaction::DoesInputReferenceBlobFiles() const {
-  assert(input_version_);
-
-  const VersionStorageInfo* storage_info = input_version_->storage_info();
-  assert(storage_info);
-
-  if (storage_info->GetBlobFiles().empty()) {
-    return false;
-  }
-
-  for (size_t i = 0; i < inputs_.size(); ++i) {
-    for (const FileMetaData* meta : inputs_[i].files) {
-      assert(meta);
-
-      if (meta->oldest_blob_file_number != kInvalidBlobFileNumber) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
 uint64_t Compaction::MinInputFileOldestAncesterTime() const {
  uint64_t min_oldest_ancester_time = port::kMaxUint64;
  for (const auto& level_files : inputs_) {
@@ -76,8 +76,7 @@ class Compaction {
             std::vector<CompactionInputFiles> inputs, int output_level,
             uint64_t target_file_size, uint64_t max_compaction_bytes,
             uint32_t output_path_id, CompressionType compression,
-             CompressionOptions compression_opts,
-             Temperature output_temperature, uint32_t max_subcompactions,
+             CompressionOptions compression_opts, uint32_t max_subcompactions,
             std::vector<FileMetaData*> grandparents,
             bool manual_compaction = false, double score = -1,
             bool deletion_compaction = false,
@@ -224,9 +223,9 @@ class Compaction {
  // How many total levels are there?
  int number_levels() const { return number_levels_; }

-  // Return the ImmutableOptions that should be used throughout the compaction
+  // Return the ImmutableCFOptions that should be used throughout the compaction
  // procedure
-  const ImmutableOptions* immutable_options() const {
+  const ImmutableOptions* immutable_cf_options() const {
    return &immutable_options_;
  }

@@ -267,11 +266,6 @@ class Compaction {
  // Should this compaction be broken up into smaller ones run in parallel?
  bool ShouldFormSubcompactions() const;

-  // Returns true iff at least one input file references a blob file.
-  //
-  // PRE: input version has been set.
-  bool DoesInputReferenceBlobFiles() const;
-
  // test function to validate the functionality of IsBottommostLevel()
  // function -- determines if compaction with inputs and storage is bottommost
  static bool TEST_IsBottommostLevel(
@@ -300,22 +294,10 @@ class Compaction {

  uint64_t max_compaction_bytes() const { return max_compaction_bytes_; }

-  Temperature output_temperature() const { return output_temperature_; }
-
  uint32_t max_subcompactions() const { return max_subcompactions_; }

  uint64_t MinInputFileOldestAncesterTime() const;

-  // Called by DBImpl::NotifyOnCompactionCompleted to make sure number of
-  // compaction begin and compaction completion callbacks match.
-  void SetNotifyOnCompactionCompleted() {
-    notify_on_compaction_completion_ = true;
-  }
-
-  bool ShouldNotifyOnCompactionCompleted() const {
-    return notify_on_compaction_completion_;
-  }
-
 private:
  // mark (or clear) all files that are being compacted
  void MarkFilesBeingCompacted(bool mark_as_compacted);
@@ -359,7 +341,6 @@ class Compaction {
  const uint32_t output_path_id_;
  CompressionType output_compression_;
  CompressionOptions output_compression_opts_;
-  Temperature output_temperature_;
  // If true, then the compaction can be done by simply deleting input files.
  const bool deletion_compaction_;

@@ -400,10 +381,6 @@ class Compaction {

  // Reason for compaction
  CompactionReason compaction_reason_;
-
-  // Notify on compaction completion only if listener was notified on compaction
-  // begin.
-  bool notify_on_compaction_completion_;
 };

 // Return sum of sizes of all files in `files`.
@@ -5,8 +5,6 @@

 #pragma once

-#include <cstdint>
-
 #include "rocksdb/rocksdb_namespace.h"

 struct CompactionIterationStats {
@@ -40,6 +38,4 @@ struct CompactionIterationStats {
  // Blob related statistics
  uint64_t num_blobs_read = 0;
  uint64_t total_blob_bytes_read = 0;
-  uint64_t num_blobs_relocated = 0;
-  uint64_t total_blob_bytes_relocated = 0;
 };
@@ -16,6 +16,22 @@
 #include "table/internal_iterator.h"
 #include "test_util/sync_point.h"

+#define DEFINITELY_IN_SNAPSHOT(seq, snapshot)                       \
+  ((seq) <= (snapshot) &&                                           \
+   (snapshot_checker_ == nullptr ||                                 \
+    LIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) == \
+           SnapshotCheckerResult::kInSnapshot)))
+
+#define DEFINITELY_NOT_IN_SNAPSHOT(seq, snapshot)                     \
+  ((seq) > (snapshot) ||                                              \
+   (snapshot_checker_ != nullptr &&                                   \
+    UNLIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) == \
+             SnapshotCheckerResult::kNotInSnapshot)))
+
+#define IN_EARLIEST_SNAPSHOT(seq) \
+  ((seq) <= earliest_snapshot_ && \
+   (snapshot_checker_ == nullptr || LIKELY(IsInEarliestSnapshot(seq))))
+
 namespace ROCKSDB_NAMESPACE {
 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
@@ -29,7 +45,6 @@ CompactionIterator::CompactionIterator(
    const std::atomic<bool>* shutting_down,
    const SequenceNumber preserve_deletes_seqnum,
    const std::atomic<int>* manual_compaction_paused,
-    const std::atomic<bool>* manual_compaction_canceled,
    const std::shared_ptr<Logger> info_log,
    const std::string* full_history_ts_low)
    : CompactionIterator(
@@ -40,8 +55,7 @@ CompactionIterator::CompactionIterator(
          std::unique_ptr<CompactionProxy>(
              compaction ? new RealCompaction(compaction) : nullptr),
          compaction_filter, shutting_down, preserve_deletes_seqnum,
-          manual_compaction_paused, manual_compaction_canceled, info_log,
-          full_history_ts_low) {}
+          manual_compaction_paused, info_log, full_history_ts_low) {}

 CompactionIterator::CompactionIterator(
    InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
@@ -56,11 +70,12 @@ CompactionIterator::CompactionIterator(
    const std::atomic<bool>* shutting_down,
    const SequenceNumber preserve_deletes_seqnum,
    const std::atomic<int>* manual_compaction_paused,
-    const std::atomic<bool>* manual_compaction_canceled,
    const std::shared_ptr<Logger> info_log,
    const std::string* full_history_ts_low)
-    : input_(input, cmp,
-             !compaction || compaction->DoesInputReferenceBlobFiles()),
+    : input_(
+          input, cmp,
+          compaction ==
+              nullptr),  // Now only need to count number of entries in flush.
      cmp_(cmp),
      merge_helper_(merge_helper),
      snapshots_(snapshots),
@@ -76,7 +91,6 @@ CompactionIterator::CompactionIterator(
      compaction_filter_(compaction_filter),
      shutting_down_(shutting_down),
      manual_compaction_paused_(manual_compaction_paused),
-      manual_compaction_canceled_(manual_compaction_canceled),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
      info_log_(info_log),
      allow_data_in_errors_(allow_data_in_errors),
@@ -495,11 +509,11 @@ void CompactionIterator::NextFromInput() {
                        "Unexpected key type %d for compaction output",
                        ikey_.type);
      }
-      assert(current_user_key_snapshot_ >= last_snapshot);
-      if (current_user_key_snapshot_ < last_snapshot) {
+      assert(current_user_key_snapshot_ == last_snapshot);
+      if (current_user_key_snapshot_ != last_snapshot) {
        ROCKS_LOG_FATAL(info_log_,
                        "current_user_key_snapshot_ (%" PRIu64
-                        ") < last_snapshot (%" PRIu64 ")",
+                        ") != last_snapshot (%" PRIu64 ")",
                        current_user_key_snapshot_, last_snapshot);
      }

@@ -555,20 +569,10 @@ void CompactionIterator::NextFromInput() {
          ParseInternalKey(input_.key(), &next_ikey, allow_data_in_errors_)
              .ok() &&
          cmp_->Equal(ikey_.user_key, next_ikey.user_key)) {
-#ifndef NDEBUG
-        const Compaction* c =
-            compaction_ ? compaction_->real_compaction() : nullptr;
-#endif
-        TEST_SYNC_POINT_CALLBACK(
-            "CompactionIterator::NextFromInput:SingleDelete:1",
-            const_cast<Compaction*>(c));
-
        // Check whether the next key belongs to the same snapshot as the
        // SingleDelete.
        if (prev_snapshot == 0 ||
-            DefinitelyNotInSnapshot(next_ikey.sequence, prev_snapshot)) {
-          TEST_SYNC_POINT_CALLBACK(
-              "CompactionIterator::NextFromInput:SingleDelete:2", nullptr);
+            DEFINITELY_NOT_IN_SNAPSHOT(next_ikey.sequence, prev_snapshot)) {
          if (next_ikey.type == kTypeSingleDeletion) {
            // We encountered two SingleDeletes in a row.  This could be due to
            // unexpected user input.
@@ -580,8 +584,8 @@ void CompactionIterator::NextFromInput() {
            ++iter_stats_.num_record_drop_obsolete;
            ++iter_stats_.num_single_del_mismatch;
          } else if (has_outputted_key_ ||
-                     DefinitelyInSnapshot(ikey_.sequence,
-                                          earliest_write_conflict_snapshot_)) {
+                     DEFINITELY_IN_SNAPSHOT(
+                         ikey_.sequence, earliest_write_conflict_snapshot_)) {
            // Found a matching value, we can drop the single delete and the
            // value.  It is safe to drop both records since we've already
            // outputted a key in this snapshot, or there is no earlier
@@ -614,9 +618,6 @@ void CompactionIterator::NextFromInput() {
            // Set up the Put to be outputted in the next iteration.
            // (Optimization 3).
            clear_and_output_next_key_ = true;
-            TEST_SYNC_POINT_CALLBACK(
-                "CompactionIterator::NextFromInput:KeepSDForWW",
-                /*arg=*/nullptr);
          }
        } else {
          // We hit the next snapshot without hitting a put, so the iterator
@@ -632,8 +633,7 @@ void CompactionIterator::NextFromInput() {
        // iteration. If the next key is corrupt, we return before the
        // comparison, so the value of has_current_user_key does not matter.
        has_current_user_key_ = false;
-        if (compaction_ != nullptr &&
-            DefinitelyInSnapshot(ikey_.sequence, earliest_snapshot_) &&
+        if (compaction_ != nullptr && IN_EARLIEST_SNAPSHOT(ikey_.sequence) &&
            compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
                                                       &level_ptrs_)) {
          // Key doesn't exist outside of this range.
@@ -677,7 +677,7 @@ void CompactionIterator::NextFromInput() {
               (ikey_.type == kTypeDeletion ||
                (ikey_.type == kTypeDeletionWithTimestamp &&
                 cmp_with_history_ts_low_ < 0)) &&
-               DefinitelyInSnapshot(ikey_.sequence, earliest_snapshot_) &&
+               IN_EARLIEST_SNAPSHOT(ikey_.sequence) &&
               ikeyNotNeededForIncrementalSnapshot() &&
               compaction_->KeyNotExistsBeyondOutputLevel(ikey_.user_key,
                                                          &level_ptrs_)) {
@@ -720,13 +720,6 @@ void CompactionIterator::NextFromInput() {
                                 ikey_.user_key, &level_ptrs_));
      ParsedInternalKey next_ikey;
      AdvanceInputIter();
-#ifndef NDEBUG
-      const Compaction* c =
-          compaction_ ? compaction_->real_compaction() : nullptr;
-#endif
-      TEST_SYNC_POINT_CALLBACK(
-          "CompactionIterator::NextFromInput:BottommostDelete:1",
-          const_cast<Compaction*>(c));
      // Skip over all versions of this key that happen to occur in the same
      // snapshot range as the delete.
      //
@@ -739,7 +732,7 @@ void CompactionIterator::NextFromInput() {
                  .ok()) &&
             cmp_->EqualWithoutTimestamp(ikey_.user_key, next_ikey.user_key) &&
             (prev_snapshot == 0 ||
-              DefinitelyNotInSnapshot(next_ikey.sequence, prev_snapshot))) {
+              DEFINITELY_NOT_IN_SNAPSHOT(next_ikey.sequence, prev_snapshot))) {
        AdvanceInputIter();
      }
      // If you find you still need to output a row with this key, we need to output the
@@ -759,15 +752,13 @@ void CompactionIterator::NextFromInput() {
      }

      pinned_iters_mgr_.StartPinning();
-      Version* version = compaction_ ? compaction_->input_version() : nullptr;
-
      // We know the merge type entry is not hidden, otherwise we would
      // have hit (A)
      // We encapsulate the merge related state machine in a different
      // object to minimize change to the existing flow.
-      Status s = merge_helper_->MergeUntil(&input_, range_del_agg_,
-                                           prev_snapshot, bottommost_level_,
-                                           allow_data_in_errors_, version);
+      Status s =
+          merge_helper_->MergeUntil(&input_, range_del_agg_, prev_snapshot,
+                                    bottommost_level_, allow_data_in_errors_);
      merge_out_iter_.SeekToFirst();

      if (!s.ok() && !s.IsMergeInProgress()) {
@@ -919,9 +910,6 @@ void CompactionIterator::GarbageCollectBlobIfNeeded() {
    ++iter_stats_.num_blobs_read;
    iter_stats_.total_blob_bytes_read += bytes_read;

-    ++iter_stats_.num_blobs_relocated;
-    iter_stats_.total_blob_bytes_relocated += blob_index.size();
-
    value_ = blob_value_;

    if (ExtractLargeValueIfNeededImpl()) {
@@ -985,8 +973,7 @@ void CompactionIterator::PrepareOutput() {
    if (valid_ && compaction_ != nullptr &&
        !compaction_->allow_ingest_behind() &&
        ikeyNotNeededForIncrementalSnapshot() && bottommost_level_ &&
-        DefinitelyInSnapshot(ikey_.sequence, earliest_snapshot_) &&
-        ikey_.type != kTypeMerge) {
+        IN_EARLIEST_SNAPSHOT(ikey_.sequence) && ikey_.type != kTypeMerge) {
      assert(ikey_.type != kTypeDeletion && ikey_.type != kTypeSingleDeletion);
      if (ikey_.type == kTypeDeletion || ikey_.type == kTypeSingleDeletion) {
        ROCKS_LOG_FATAL(info_log_,
@@ -1062,7 +1049,7 @@ inline bool CompactionIterator::ikeyNotNeededForIncrementalSnapshot() {
         (ikey_.sequence < preserve_deletes_seqnum_);
 }

-bool CompactionIterator::IsInCurrentEarliestSnapshot(SequenceNumber sequence) {
+bool CompactionIterator::IsInEarliestSnapshot(SequenceNumber sequence) {
  assert(snapshot_checker_ != nullptr);
  bool pre_condition = (earliest_snapshot_ == kMaxSequenceNumber ||
                        (earliest_snapshot_iter_ != snapshots_->end() &&
@@ -97,10 +97,6 @@ class CompactionIterator {
    virtual double blob_garbage_collection_age_cutoff() const = 0;

    virtual Version* input_version() const = 0;
-
-    virtual bool DoesInputReferenceBlobFiles() const = 0;
-
-    virtual const Compaction* real_compaction() const = 0;
  };

  class RealCompaction : public CompactionProxy {
@@ -108,7 +104,7 @@ class CompactionIterator {
    explicit RealCompaction(const Compaction* compaction)
        : compaction_(compaction) {
      assert(compaction_);
-      assert(compaction_->immutable_options());
+      assert(compaction_->immutable_cf_options());
      assert(compaction_->mutable_cf_options());
    }

@@ -130,11 +126,11 @@ class CompactionIterator {
    }

    bool allow_ingest_behind() const override {
-      return compaction_->immutable_options()->allow_ingest_behind;
+      return compaction_->immutable_cf_options()->allow_ingest_behind;
    }

    bool preserve_deletes() const override {
-      return compaction_->immutable_options()->preserve_deletes;
+      return compaction_->immutable_cf_options()->preserve_deletes;
    }

    bool enable_blob_garbage_collection() const override {
@@ -150,50 +146,44 @@ class CompactionIterator {
      return compaction_->input_version();
    }

-    bool DoesInputReferenceBlobFiles() const override {
-      return compaction_->DoesInputReferenceBlobFiles();
-    }
-
-    const Compaction* real_compaction() const override { return compaction_; }
-
   private:
    const Compaction* compaction_;
  };

-  CompactionIterator(
-      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_write_conflict_snapshot,
-      const SnapshotChecker* snapshot_checker, Env* env,
-      bool report_detailed_time, bool expect_valid_internal_key,
-      CompactionRangeDelAggregator* range_del_agg,
-      BlobFileBuilder* blob_file_builder, bool allow_data_in_errors,
-      const Compaction* compaction = nullptr,
-      const CompactionFilter* compaction_filter = nullptr,
-      const std::atomic<bool>* shutting_down = nullptr,
-      const SequenceNumber preserve_deletes_seqnum = 0,
-      const std::atomic<int>* manual_compaction_paused = nullptr,
-      const std::atomic<bool>* manual_compaction_canceled = nullptr,
-      const std::shared_ptr<Logger> info_log = nullptr,
-      const std::string* full_history_ts_low = nullptr);
+  CompactionIterator(InternalIterator* input, const Comparator* cmp,
+                     MergeHelper* merge_helper, SequenceNumber last_sequence,
+                     std::vector<SequenceNumber>* snapshots,
+                     SequenceNumber earliest_write_conflict_snapshot,
+                     const SnapshotChecker* snapshot_checker, Env* env,
+                     bool report_detailed_time, bool expect_valid_internal_key,
+                     CompactionRangeDelAggregator* range_del_agg,
+                     BlobFileBuilder* blob_file_builder,
+                     bool allow_data_in_errors,
+                     const Compaction* compaction = nullptr,
+                     const CompactionFilter* compaction_filter = nullptr,
+                     const std::atomic<bool>* shutting_down = nullptr,
+                     const SequenceNumber preserve_deletes_seqnum = 0,
+                     const std::atomic<int>* manual_compaction_paused = nullptr,
+                     const std::shared_ptr<Logger> info_log = nullptr,
+                     const std::string* full_history_ts_low = nullptr);

  // Constructor with custom CompactionProxy, used for tests.
-  CompactionIterator(
-      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
-      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
-      SequenceNumber earliest_write_conflict_snapshot,
-      const SnapshotChecker* snapshot_checker, Env* env,
-      bool report_detailed_time, bool expect_valid_internal_key,
-      CompactionRangeDelAggregator* range_del_agg,
-      BlobFileBuilder* blob_file_builder, bool allow_data_in_errors,
-      std::unique_ptr<CompactionProxy> compaction,
-      const CompactionFilter* compaction_filter = nullptr,
-      const std::atomic<bool>* shutting_down = nullptr,
-      const SequenceNumber preserve_deletes_seqnum = 0,
-      const std::atomic<int>* manual_compaction_paused = nullptr,
-      const std::atomic<bool>* manual_compaction_canceled = nullptr,
-      const std::shared_ptr<Logger> info_log = nullptr,
-      const std::string* full_history_ts_low = nullptr);
+  CompactionIterator(InternalIterator* input, const Comparator* cmp,
+                     MergeHelper* merge_helper, SequenceNumber last_sequence,
+                     std::vector<SequenceNumber>* snapshots,
+                     SequenceNumber earliest_write_conflict_snapshot,
+                     const SnapshotChecker* snapshot_checker, Env* env,
+                     bool report_detailed_time, bool expect_valid_internal_key,
+                     CompactionRangeDelAggregator* range_del_agg,
+                     BlobFileBuilder* blob_file_builder,
+                     bool allow_data_in_errors,
+                     std::unique_ptr<CompactionProxy> compaction,
+                     const CompactionFilter* compaction_filter = nullptr,
+                     const std::atomic<bool>* shutting_down = nullptr,
+                     const SequenceNumber preserve_deletes_seqnum = 0,
+                     const std::atomic<int>* manual_compaction_paused = nullptr,
+                     const std::shared_ptr<Logger> info_log = nullptr,
+                     const std::string* full_history_ts_low = nullptr);

  ~CompactionIterator();

@@ -271,13 +261,7 @@ class CompactionIterator {
               SnapshotCheckerResult::kInSnapshot;
  }

-  bool IsInCurrentEarliestSnapshot(SequenceNumber sequence);
-
-  bool DefinitelyInSnapshot(SequenceNumber seq, SequenceNumber snapshot);
-
-  bool DefinitelyNotInSnapshot(SequenceNumber seq, SequenceNumber snapshot);
-
-  bool InCurrentEarliestSnapshot(SequenceNumber seq);
+  bool IsInEarliestSnapshot(SequenceNumber sequence);

  // Extract user-defined timestamp from user key if possible and compare it
  // with *full_history_ts_low_ if applicable.
@@ -319,7 +303,6 @@ class CompactionIterator {
  const CompactionFilter* compaction_filter_;
  const std::atomic<bool>* shutting_down_;
  const std::atomic<int>* manual_compaction_paused_;
-  const std::atomic<bool>* manual_compaction_canceled_;
  const SequenceNumber preserve_deletes_seqnum_;
  bool bottommost_level_;
  bool valid_ = false;
@@ -416,33 +399,8 @@ class CompactionIterator {

  bool IsPausingManualCompaction() {
    // This is a best-effort facility, so memory_order_relaxed is sufficient.
-    return (manual_compaction_paused_ &&
-            manual_compaction_paused_->load(std::memory_order_relaxed) > 0) ||
-           (manual_compaction_canceled_ &&
-            manual_compaction_canceled_->load(std::memory_order_relaxed));
+    return manual_compaction_paused_ &&
+           manual_compaction_paused_->load(std::memory_order_relaxed) > 0;
  }
 };
-
-inline bool CompactionIterator::DefinitelyInSnapshot(SequenceNumber seq,
-                                                     SequenceNumber snapshot) {
-  return ((seq) <= (snapshot) &&
-          (snapshot_checker_ == nullptr ||
-           LIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) ==
-                  SnapshotCheckerResult::kInSnapshot)));
-}
-
-inline bool CompactionIterator::DefinitelyNotInSnapshot(
-    SequenceNumber seq, SequenceNumber snapshot) {
-  return ((seq) > (snapshot) ||
-          (snapshot_checker_ != nullptr &&
-           UNLIKELY(snapshot_checker_->CheckInSnapshot((seq), (snapshot)) ==
-                    SnapshotCheckerResult::kNotInSnapshot)));
-}
-
-inline bool CompactionIterator::InCurrentEarliestSnapshot(SequenceNumber seq) {
-  return ((seq) <= earliest_snapshot_ &&
-          (snapshot_checker_ == nullptr ||
-           LIKELY(IsInCurrentEarliestSnapshot(seq))));
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -182,10 +182,6 @@ class FakeCompaction : public CompactionIterator::CompactionProxy {

  Version* input_version() const override { return nullptr; }

-  bool DoesInputReferenceBlobFiles() const override { return false; }
-
-  const Compaction* real_compaction() const override { return nullptr; }
-
  bool key_not_exists_beyond_output_level = false;

  bool is_bottommost_level = false;
@@ -286,8 +282,7 @@ class CompactionIteratorTest : public testing::TestWithParam<bool> {
        range_del_agg_.get(), nullptr /* blob_file_builder */,
        true /*allow_data_in_errors*/, std::move(compaction), filter,
        &shutting_down_, /*preserve_deletes_seqnum=*/0,
-        /*manual_compaction_paused=*/nullptr,
-        /*manual_compaction_canceled=*/nullptr, /*info_log=*/nullptr,
+        /*manual_compaction_paused=*/nullptr, /*info_log=*/nullptr,
        full_history_ts_low));
  }

@@ -20,12 +20,9 @@
 #include <utility>
 #include <vector>

-#include "db/blob/blob_counting_iterator.h"
 #include "db/blob/blob_file_addition.h"
 #include "db/blob/blob_file_builder.h"
-#include "db/blob/blob_garbage_meter.h"
 #include "db/builder.h"
-#include "db/compaction/clipping_iterator.h"
 #include "db/db_impl/db_impl.h"
 #include "db/db_iter.h"
 #include "db/dbformat.h"
@@ -107,8 +104,6 @@ const char* GetCompactionReasonString(CompactionReason compaction_reason) {
      return "ExternalSstIngestion";
    case CompactionReason::kPeriodicCompaction:
      return "PeriodicCompaction";
-    case CompactionReason::kChangeTemperature:
-      return "ChangeTemperature";
    case CompactionReason::kNumOfReasons:
      // fall through
    default:
@@ -151,7 +146,6 @@ struct CompactionJob::SubcompactionState {
  // State kept for output being generated
  std::vector<Output> outputs;
  std::vector<BlobFileAddition> blob_file_additions;
-  std::unique_ptr<BlobGarbageMeter> blob_garbage_meter;
  std::unique_ptr<WritableFileWriter> outfile;
  std::unique_ptr<TableBuilder> builder;

@@ -182,17 +176,9 @@ struct CompactionJob::SubcompactionState {
  uint64_t overlapped_bytes = 0;
  // A flag determine whether the key has been seen in ShouldStopBefore()
  bool seen_key = false;
-  // sub compaction job id, which is used to identify different sub-compaction
-  // within the same compaction job.
-  const uint32_t sub_job_id;

-  SubcompactionState(Compaction* c, Slice* _start, Slice* _end, uint64_t size,
-                     uint32_t _sub_job_id)
-      : compaction(c),
-        start(_start),
-        end(_end),
-        approx_size(size),
-        sub_job_id(_sub_job_id) {
+  SubcompactionState(Compaction* c, Slice* _start, Slice* _end, uint64_t size)
+      : compaction(c), start(_start), end(_end), approx_size(size) {
    assert(compaction != nullptr);
  }

@@ -242,14 +228,6 @@ struct CompactionJob::SubcompactionState {

    return false;
  }
-
-  Status ProcessOutFlowIfNeeded(const Slice& key, const Slice& value) {
-    if (!blob_garbage_meter) {
-      return Status::OK();
-    }
-
-    return blob_garbage_meter->ProcessOutFlow(key, value);
-  }
 };

 // Maintains state for the entire compaction
@@ -335,10 +313,9 @@ CompactionJob::CompactionJob(
    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<int>* manual_compaction_paused,
-    const std::atomic<bool>* manual_compaction_canceled,
-    const std::string& db_id, const std::string& db_session_id,
-    std::string full_history_ts_low, BlobFileCompletionCallback* blob_callback)
+    const std::atomic<int>* manual_compaction_paused, const std::string& db_id,
+    const std::string& db_session_id, std::string full_history_ts_low,
+    BlobFileCompletionCallback* blob_callback)
    : compact_(new CompactionState(compaction)),
      compaction_stats_(compaction->compaction_reason(), 1),
      db_options_(db_options),
@@ -362,7 +339,6 @@ CompactionJob::CompactionJob(
      versions_(versions),
      shutting_down_(shutting_down),
      manual_compaction_paused_(manual_compaction_paused),
-      manual_compaction_canceled_(manual_compaction_canceled),
      preserve_deletes_seqnum_(preserve_deletes_seqnum),
      db_directory_(db_directory),
      blob_output_directory_(blob_output_directory),
@@ -459,8 +435,7 @@ void CompactionJob::Prepare() {
    for (size_t i = 0; i <= boundaries_.size(); i++) {
      Slice* start = i == 0 ? nullptr : &boundaries_[i - 1];
      Slice* end = i == boundaries_.size() ? nullptr : &boundaries_[i];
-      compact_->sub_compact_states.emplace_back(c, start, end, sizes_[i],
-                                                static_cast<uint32_t>(i));
+      compact_->sub_compact_states.emplace_back(c, start, end, sizes_[i]);
    }
    RecordInHistogram(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
                      compact_->sub_compact_states.size());
@@ -469,8 +444,7 @@ void CompactionJob::Prepare() {
    constexpr Slice* end = nullptr;
    constexpr uint64_t size = 0;

-    compact_->sub_compact_states.emplace_back(c, start, end, size,
-                                              /*sub_job_id*/ 0);
+    compact_->sub_compact_states.emplace_back(c, start, end, size);
  }
 }

@@ -576,10 +550,9 @@ void CompactionJob::GenSubcompactionBoundaries() {
  int base_level = v->storage_info()->base_level();
  uint64_t max_output_files = static_cast<uint64_t>(std::ceil(
      sum / min_file_fill_percent /
-      MaxFileSizeForLevel(
-          *(c->mutable_cf_options()), out_lvl,
-          c->immutable_options()->compaction_style, base_level,
-          c->immutable_options()->level_compaction_dynamic_level_bytes)));
+      MaxFileSizeForLevel(*(c->mutable_cf_options()), out_lvl,
+          c->immutable_cf_options()->compaction_style, base_level,
+          c->immutable_cf_options()->level_compaction_dynamic_level_bytes)));
  uint64_t subcompactions =
      std::min({static_cast<uint64_t>(ranges.size()),
                static_cast<uint64_t>(c->max_subcompactions()),
@@ -778,7 +751,7 @@ Status CompactionJob::Run() {
  for (const auto& state : compact_->sub_compact_states) {
    for (const auto& output : state.outputs) {
      auto fn =
-          TableFileName(state.compaction->immutable_options()->cf_paths,
+          TableFileName(state.compaction->immutable_cf_options()->cf_paths,
                        output.meta.fd.GetNumber(), output.meta.fd.GetPathId());
      tp[fn] = output.table_properties;
    }
@@ -881,7 +854,7 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {

  UpdateCompactionJobStats(stats);

-  auto stream = event_logger_->LogToBuffer(log_buffer_, 8192);
+  auto stream = event_logger_->LogToBuffer(log_buffer_);
  stream << "job" << job_id_ << "event"
         << "compaction_finished"
         << "compaction_time_micros" << stats.micros
@@ -932,8 +905,7 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {
 }

 #ifndef ROCKSDB_LITE
-CompactionServiceJobStatus
-CompactionJob::ProcessKeyValueCompactionWithCompactionService(
+void CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    SubcompactionState* sub_compact) {
  assert(sub_compact);
  assert(sub_compact->compaction);
@@ -970,7 +942,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
  Status s = compaction_input.Write(&compaction_input_binary);
  if (!s.ok()) {
    sub_compact->status = s;
-    return CompactionServiceJobStatus::kFailure;
+    return;
  }

  std::ostringstream input_files_oss;
@@ -985,77 +957,38 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
      "[%s] [JOB %d] Starting remote compaction (output level: %d): %s",
      compaction_input.column_family.name.c_str(), job_id_,
      compaction_input.output_level, input_files_oss.str().c_str());
-  CompactionServiceJobInfo info(dbname_, db_id_, db_session_id_,
-                                GetCompactionId(sub_compact), thread_pri_);
  CompactionServiceJobStatus compaction_status =
-      db_options_.compaction_service->StartV2(info, compaction_input_binary);
-  switch (compaction_status) {
-    case CompactionServiceJobStatus::kSuccess:
-      break;
-    case CompactionServiceJobStatus::kFailure:
-      sub_compact->status = Status::Incomplete(
-          "CompactionService failed to start compaction job.");
-      ROCKS_LOG_WARN(db_options_.info_log,
-                     "[%s] [JOB %d] Remote compaction failed to start.",
-                     compaction_input.column_family.name.c_str(), job_id_);
-      return compaction_status;
-    case CompactionServiceJobStatus::kUseLocal:
-      ROCKS_LOG_INFO(
-          db_options_.info_log,
-          "[%s] [JOB %d] Remote compaction fallback to local by API Start.",
-          compaction_input.column_family.name.c_str(), job_id_);
-      return compaction_status;
-    default:
-      assert(false);  // unknown status
-      break;
+      db_options_.compaction_service->Start(compaction_input_binary, job_id_);
+  if (compaction_status != CompactionServiceJobStatus::kSuccess) {
+    sub_compact->status =
+        Status::Incomplete("CompactionService failed to start compaction job.");
+    return;
  }

-  ROCKS_LOG_INFO(db_options_.info_log,
-                 "[%s] [JOB %d] Waiting for remote compaction...",
-                 compaction_input.column_family.name.c_str(), job_id_);
  std::string compaction_result_binary;
-  compaction_status = db_options_.compaction_service->WaitForCompleteV2(
-      info, &compaction_result_binary);
-
-  if (compaction_status == CompactionServiceJobStatus::kUseLocal) {
-    ROCKS_LOG_INFO(db_options_.info_log,
-                   "[%s] [JOB %d] Remote compaction fallback to local by API "
-                   "WaitForComplete.",
-                   compaction_input.column_family.name.c_str(), job_id_);
-    return compaction_status;
-  }
+  compaction_status = db_options_.compaction_service->WaitForComplete(
+      job_id_, &compaction_result_binary);

  CompactionServiceResult compaction_result;
  s = CompactionServiceResult::Read(compaction_result_binary,
                                    &compaction_result);
-
-  if (compaction_status == CompactionServiceJobStatus::kFailure) {
-    if (s.ok()) {
-      if (compaction_result.status.ok()) {
-        sub_compact->status = Status::Incomplete(
-            "CompactionService failed to run the compaction job (even though "
-            "the internal status is okay).");
-      } else {
-        // set the current sub compaction status with the status returned from
-        // remote
-        sub_compact->status = compaction_result.status;
-      }
-    } else {
-      sub_compact->status = Status::Incomplete(
-          "CompactionService failed to run the compaction job (and no valid "
-          "result is returned).");
-      compaction_result.status.PermitUncheckedError();
-    }
+  if (compaction_status != CompactionServiceJobStatus::kSuccess) {
+    sub_compact->status =
+        s.ok() ? compaction_result.status
+               : Status::Incomplete(
+                     "CompactionService failed to run compaction job.");
+    compaction_result.status.PermitUncheckedError();
    ROCKS_LOG_WARN(db_options_.info_log,
-                   "[%s] [JOB %d] Remote compaction failed.",
-                   compaction_input.column_family.name.c_str(), job_id_);
-    return compaction_status;
+                   "[%s] [JOB %d] Remote compaction failed, status: %s",
+                   compaction_input.column_family.name.c_str(), job_id_,
+                   s.ToString().c_str());
+    return;
  }

  if (!s.ok()) {
    sub_compact->status = s;
    compaction_result.status.PermitUncheckedError();
-    return CompactionServiceJobStatus::kFailure;
+    return;
  }
  sub_compact->status = compaction_result.status;

@@ -1075,18 +1008,18 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(

  if (!s.ok()) {
    sub_compact->status = s;
-    return CompactionServiceJobStatus::kFailure;
+    return;
  }

  for (const auto& file : compaction_result.output_files) {
    uint64_t file_num = versions_->NewFileNumber();
    auto src_file = compaction_result.output_path + "/" + file.file_name;
-    auto tgt_file = TableFileName(compaction->immutable_options()->cf_paths,
+    auto tgt_file = TableFileName(compaction->immutable_cf_options()->cf_paths,
                                  file_num, compaction->output_path_id());
    s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr);
    if (!s.ok()) {
      sub_compact->status = s;
-      return CompactionServiceJobStatus::kFailure;
+      return;
    }

    FileMetaData meta;
@@ -1094,7 +1027,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    s = fs_->GetFileSize(tgt_file, IOOptions(), &file_size, nullptr);
    if (!s.ok()) {
      sub_compact->status = s;
-      return CompactionServiceJobStatus::kFailure;
+      return;
    }
    meta.fd = FileDescriptor(file_num, compaction->output_path_id(), file_size,
                             file.smallest_seqno, file.largest_seqno);
@@ -1115,7 +1048,6 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
  sub_compact->total_bytes = compaction_result.total_bytes;
  IOSTATS_ADD(bytes_written, compaction_result.bytes_written);
  IOSTATS_ADD(bytes_read, compaction_result.bytes_read);
-  return CompactionServiceJobStatus::kSuccess;
 }
 #endif  // !ROCKSDB_LITE

@@ -1125,14 +1057,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {

 #ifndef ROCKSDB_LITE
  if (db_options_.compaction_service) {
-    CompactionServiceJobStatus comp_status =
-        ProcessKeyValueCompactionWithCompactionService(sub_compact);
-    if (comp_status == CompactionServiceJobStatus::kSuccess ||
-        comp_status == CompactionServiceJobStatus::kFailure) {
-      return;
-    }
-    // fallback to local compaction
-    assert(comp_status == CompactionServiceJobStatus::kUseLocal);
+    return ProcessKeyValueCompactionWithCompactionService(sub_compact);
  }
 #endif  // !ROCKSDB_LITE

@@ -1159,10 +1084,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {

  CompactionRangeDelAggregator range_del_agg(&cfd->internal_comparator(),
                                             existing_snapshots_);
-
-  const Slice* const start = sub_compact->start;
-  const Slice* const end = sub_compact->end;
-
  ReadOptions read_options;
  read_options.verify_checksums = true;
  read_options.fill_cache = false;
@@ -1172,51 +1093,11 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  // (b) CompactionFilter::Decision::kRemoveAndSkipUntil.
  read_options.total_order_seek = true;

-  // Note: if we're going to support subcompactions for user-defined timestamps,
-  // the timestamp part will have to be stripped from the bounds here.
-  assert((!start && !end) || cfd->user_comparator()->timestamp_size() == 0);
-  read_options.iterate_lower_bound = start;
-  read_options.iterate_upper_bound = end;
-
  // Although the v2 aggregator is what the level iterator(s) know about,
  // the AddTombstones calls will be propagated down to the v1 aggregator.
-  std::unique_ptr<InternalIterator> raw_input(
+  std::unique_ptr<InternalIterator> input(
      versions_->MakeInputIterator(read_options, sub_compact->compaction,
                                   &range_del_agg, file_options_for_read_));
-  InternalIterator* input = raw_input.get();
-
-  IterKey start_ikey;
-  IterKey end_ikey;
-  Slice start_slice;
-  Slice end_slice;
-
-  if (start) {
-    start_ikey.SetInternalKey(*start, kMaxSequenceNumber, kValueTypeForSeek);
-    start_slice = start_ikey.GetInternalKey();
-  }
-  if (end) {
-    end_ikey.SetInternalKey(*end, kMaxSequenceNumber, kValueTypeForSeek);
-    end_slice = end_ikey.GetInternalKey();
-  }
-
-  std::unique_ptr<InternalIterator> clip;
-  if (start || end) {
-    clip.reset(new ClippingIterator(
-        raw_input.get(), start ? &start_slice : nullptr,
-        end ? &end_slice : nullptr, &cfd->internal_comparator()));
-    input = clip.get();
-  }
-
-  std::unique_ptr<InternalIterator> blob_counter;
-
-  if (sub_compact->compaction->DoesInputReferenceBlobFiles()) {
-    sub_compact->blob_garbage_meter.reset(new BlobGarbageMeter);
-    blob_counter.reset(
-        new BlobCountingIterator(input, sub_compact->blob_garbage_meter.get()));
-    input = blob_counter.get();
-  }
-
-  input->SeekToFirst();

  AutoThreadOperationStageUpdater stage_updater(
      ThreadStatus::STAGE_COMPACTION_PROCESS_KV);
@@ -1256,13 +1137,13 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {

  std::unique_ptr<BlobFileBuilder> blob_file_builder(
      mutable_cf_options->enable_blob_files
-          ? new BlobFileBuilder(
-                versions_, fs_.get(),
-                sub_compact->compaction->immutable_options(),
-                mutable_cf_options, &file_options_, job_id_, cfd->GetID(),
-                cfd->GetName(), Env::IOPriority::IO_LOW, write_hint_,
-                io_tracer_, blob_callback_, BlobFileCreationReason::kCompaction,
-                &blob_file_paths, &sub_compact->blob_file_additions)
+          ? new BlobFileBuilder(versions_, fs_.get(),
+                                sub_compact->compaction->immutable_cf_options(),
+                                mutable_cf_options, &file_options_, job_id_,
+                                cfd->GetID(), cfd->GetName(),
+                                Env::IOPriority::IO_LOW, write_hint_,
+                                io_tracer_, blob_callback_, &blob_file_paths,
+                                &sub_compact->blob_file_additions)
          : nullptr);

  TEST_SYNC_POINT("CompactionJob::Run():Inprogress");
@@ -1271,18 +1152,28 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      reinterpret_cast<void*>(
          const_cast<std::atomic<int>*>(manual_compaction_paused_)));

+  Slice* start = sub_compact->start;
+  Slice* end = sub_compact->end;
+  if (start != nullptr) {
+    IterKey start_iter;
+    start_iter.SetInternalKey(*start, kMaxSequenceNumber, kValueTypeForSeek);
+    input->Seek(start_iter.GetInternalKey());
+  } else {
+    input->SeekToFirst();
+  }
+
  Status status;
  const std::string* const full_history_ts_low =
      full_history_ts_low_.empty() ? nullptr : &full_history_ts_low_;
  sub_compact->c_iter.reset(new CompactionIterator(
-      input, cfd->user_comparator(), &merge, versions_->LastSequence(),
+      input.get(), cfd->user_comparator(), &merge, versions_->LastSequence(),
      &existing_snapshots_, earliest_write_conflict_snapshot_,
      snapshot_checker_, env_, ShouldReportDetailedTime(env_, stats_),
      /*expect_valid_internal_key=*/true, &range_del_agg,
      blob_file_builder.get(), db_options_.allow_data_in_errors,
      sub_compact->compaction, compaction_filter, shutting_down_,
-      preserve_deletes_seqnum_, manual_compaction_paused_,
-      manual_compaction_canceled_, db_options_.info_log, full_history_ts_low));
+      preserve_deletes_seqnum_, manual_compaction_paused_, db_options_.info_log,
+      full_history_ts_low));
  auto c_iter = sub_compact->c_iter.get();
  c_iter->SeekToFirst();
  if (c_iter->Valid() && sub_compact->compaction->output_level() != 0) {
@@ -1306,9 +1197,12 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    const Slice& key = c_iter->key();
    const Slice& value = c_iter->value();

-    assert(!end ||
-           cfd->user_comparator()->Compare(c_iter->user_key(), *end) < 0);
-
+    // If an end key (exclusive) is specified, check if the current key is
+    // >= than it and exit if it is because the iterator is out of its range
+    if (end != nullptr &&
+        cfd->user_comparator()->Compare(c_iter->user_key(), *end) >= 0) {
+      break;
+    }
    if (c_iter_stats.num_input_records % kRecordStatsEvery ==
        kRecordStatsEvery - 1) {
      RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
@@ -1328,11 +1222,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
      break;
    }

-    status = sub_compact->ProcessOutFlowIfNeeded(key, value);
-    if (!status.ok()) {
-      break;
-    }
-
    sub_compact->current_output_file_size =
        sub_compact->builder->EstimatedFileSize();
    const ParsedInternalKey& ikey = c_iter->ikey();
@@ -1416,16 +1305,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {

  RecordTick(stats_, FILTER_OPERATION_TOTAL_TIME,
             c_iter_stats.total_filter_time);
-
-  if (c_iter_stats.num_blobs_relocated > 0) {
-    RecordTick(stats_, BLOB_DB_GC_NUM_KEYS_RELOCATED,
-               c_iter_stats.num_blobs_relocated);
-  }
-  if (c_iter_stats.total_blob_bytes_relocated > 0) {
-    RecordTick(stats_, BLOB_DB_GC_BYTES_RELOCATED,
-               c_iter_stats.total_blob_bytes_relocated);
-  }
-
  RecordDroppedKeys(c_iter_stats, &sub_compact->compaction_job_stats);
  RecordCompactionIOStats();

@@ -1438,10 +1317,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    status = Status::ShutdownInProgress("Database shutdown");
  }
  if ((status.ok() || status.IsColumnFamilyDropped()) &&
-      ((manual_compaction_paused_ &&
-        manual_compaction_paused_->load(std::memory_order_relaxed) > 0) ||
-       (manual_compaction_canceled_ &&
-        manual_compaction_canceled_->load(std::memory_order_relaxed)))) {
+      (manual_compaction_paused_ &&
+       manual_compaction_paused_->load(std::memory_order_relaxed) > 0)) {
    status = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
  }
  if (status.ok()) {
@@ -1473,7 +1350,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    if (status.ok()) {
      status = blob_file_builder->Finish();
    } else {
-      blob_file_builder->Abandon(status);
+      blob_file_builder->Abandon();
    }
    blob_file_builder.reset();
  }
@@ -1510,16 +1387,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
 #endif  // ROCKSDB_ASSERT_STATUS_CHECKED

  sub_compact->c_iter.reset();
-  blob_counter.reset();
-  clip.reset();
-  raw_input.reset();
+  input.reset();
  sub_compact->status = status;
 }

-uint64_t CompactionJob::GetCompactionId(SubcompactionState* sub_compact) {
-  return (uint64_t)job_id_ << 32 | sub_compact->sub_job_id;
-}
-
 void CompactionJob::RecordDroppedKeys(
    const CompactionIterationStats& c_iter_stats,
    CompactionJobStats* compaction_job_stats) {
@@ -1799,7 +1670,7 @@ Status CompactionJob::FinishCompactionOutputFile(
    // This happens when the output level is bottom level, at the same time
    // the sub_compact output nothing.
    std::string fname =
-        TableFileName(sub_compact->compaction->immutable_options()->cf_paths,
+        TableFileName(sub_compact->compaction->immutable_cf_options()->cf_paths,
                      meta->fd.GetNumber(), meta->fd.GetPathId());

    // TODO(AR) it is not clear if there are any larger implications if
@@ -1884,6 +1755,19 @@ Status CompactionJob::InstallCompactionResults(
  auto* compaction = compact_->compaction;
  assert(compaction);

+  // paranoia: verify that the files that we started with
+  // still exist in the current version and in the same original level.
+  // This ensures that a concurrent compaction did not erroneously
+  // pick the same files to compact_.
+  if (!versions_->VerifyCompactionFileConsistency(compaction)) {
+    Compaction::InputLevelSummaryBuffer inputs_summary;
+
+    ROCKS_LOG_ERROR(db_options_.info_log, "[%s] [JOB %d] Compaction %s aborted",
+                    compaction->column_family_data()->GetName().c_str(),
+                    job_id_, compaction->InputLevelSummary(&inputs_summary));
+    return Status::Corruption("Compaction input files inconsistent");
+  }
+
  {
    Compaction::InputLevelSummaryBuffer inputs_summary;
    ROCKS_LOG_INFO(db_options_.info_log,
@@ -1899,8 +1783,6 @@ Status CompactionJob::InstallCompactionResults(
  // Add compaction inputs
  compaction->AddInputDeletions(edit);

-  std::unordered_map<uint64_t, BlobGarbageMeter::BlobStats> blob_total_garbage;
-
  for (const auto& sub_compact : compact_->sub_compact_states) {
    for (const auto& out : sub_compact.outputs) {
      edit->AddFile(compaction->output_level(), out.meta);
@@ -1909,29 +1791,6 @@ Status CompactionJob::InstallCompactionResults(
    for (const auto& blob : sub_compact.blob_file_additions) {
      edit->AddBlobFile(blob);
    }
-
-    if (sub_compact.blob_garbage_meter) {
-      const auto& flows = sub_compact.blob_garbage_meter->flows();
-
-      for (const auto& pair : flows) {
-        const uint64_t blob_file_number = pair.first;
-        const BlobGarbageMeter::BlobInOutFlow& flow = pair.second;
-
-        assert(flow.IsValid());
-        if (flow.HasGarbage()) {
-          blob_total_garbage[blob_file_number].Add(flow.GetGarbageCount(),
-                                                   flow.GetGarbageBytes());
-        }
-      }
-    }
-  }
-
-  for (const auto& pair : blob_total_garbage) {
-    const uint64_t blob_file_number = pair.first;
-    const BlobGarbageMeter::BlobStats& stats = pair.second;
-
-    edit->AddBlobFileGarbage(blob_file_number, stats.GetCount(),
-                             stats.GetBytes());
  }

  return versions_->LogAndApply(compaction->column_family_data(),
@@ -1986,12 +1845,11 @@ Status CompactionJob::OpenCompactionOutputFile(

  // Pass temperature of botommost files to FileSystem.
  FileOptions fo_copy = file_options_;
-  Temperature temperature = sub_compact->compaction->output_temperature();
-  if (temperature == Temperature::kUnknown && bottommost_level_) {
-    temperature =
+  Temperature temperature = Temperature::kUnknown;
+  if (bottommost_level_) {
+    fo_copy.temperature = temperature =
        sub_compact->compaction->mutable_cf_options()->bottommost_temperature;
  }
-  fo_copy.temperature = temperature;

  Status s;
  IOStatus io_s = NewWritableFile(fs_.get(), fname, &writable_file, fo_copy);
@@ -2056,12 +1914,12 @@ Status CompactionJob::OpenCompactionOutputFile(
  writable_file->SetPreallocationBlockSize(static_cast<size_t>(
      sub_compact->compaction->OutputFilePreallocationSize()));
  const auto& listeners =
-      sub_compact->compaction->immutable_options()->listeners;
+      sub_compact->compaction->immutable_cf_options()->listeners;
  sub_compact->outfile.reset(new WritableFileWriter(
      std::move(writable_file), fname, file_options_, db_options_.clock,
      io_tracer_, db_options_.stats, listeners,
      db_options_.file_checksum_gen_factory.get(),
-      tmp_set.Contains(FileType::kTableFile), false));
+      tmp_set.Contains(FileType::kTableFile)));

  TableBuilderOptions tboptions(
      *cfd->ioptions(), *(sub_compact->compaction->mutable_cf_options()),
@@ -2071,8 +1929,7 @@ Status CompactionJob::OpenCompactionOutputFile(
      cfd->GetName(), sub_compact->compaction->output_level(),
      bottommost_level_, TableFileCreationReason::kCompaction,
      oldest_ancester_time, 0 /* oldest_key_time */, current_time, db_id_,
-      db_session_id_, sub_compact->compaction->max_output_file_size(),
-      file_number);
+      db_session_id_, sub_compact->compaction->max_output_file_size());
  sub_compact->builder.reset(
      NewTableBuilder(tboptions, sub_compact->outfile.get()));
  LogFlush(db_options_.info_log);
@@ -2238,7 +2095,7 @@ void CompactionJob::LogCompaction() {
 }

 std::string CompactionJob::GetTableFileName(uint64_t file_number) {
-  return TableFileName(compact_->compaction->immutable_options()->cf_paths,
+  return TableFileName(compact_->compaction->immutable_cf_options()->cf_paths,
                       file_number, compact_->compaction->output_path_id());
 }

@@ -2269,7 +2126,7 @@ CompactionServiceCompactionJob::CompactionServiceCompactionJob(
          compaction->mutable_cf_options()->paranoid_file_checks,
          compaction->mutable_cf_options()->report_bg_io_stats, dbname,
          &(compaction_service_result->stats), Env::Priority::USER, io_tracer,
-          nullptr, nullptr, db_id, db_session_id,
+          nullptr, db_id, db_session_id,
          compaction->column_family_data()->GetFullHistoryTsLow()),
      output_path_(output_path),
      compaction_input_(compaction_service_input),
@@ -2292,8 +2149,8 @@ Status CompactionServiceCompactionJob::Run() {
  Slice end = compaction_input_.end;
  compact_->sub_compact_states.emplace_back(
      c, compaction_input_.has_begin ? &begin : nullptr,
-      compaction_input_.has_end ? &end : nullptr, compaction_input_.approx_size,
-      /*sub_job_id*/ 0);
+      compaction_input_.has_end ? &end : nullptr,
+      compaction_input_.approx_size);

  log_buffer_->FlushBufferToLog();
  LogCompaction();
@@ -2332,7 +2189,7 @@ Status CompactionServiceCompactionJob::Run() {
    status = io_s;
  }
  if (status.ok()) {
-    // TODO: Add verify_table()
+    // TODO: Add verify_table() and VerifyCompactionFileConsistency()
  }

  // Finish up all book-keeping to unify the subcompaction results
@@ -81,7 +81,6 @@ class CompactionJob {
      const std::string& dbname, CompactionJobStats* compaction_job_stats,
      Env::Priority thread_pri, const std::shared_ptr<IOTracer>& io_tracer,
      const std::atomic<int>* manual_compaction_paused = nullptr,
-      const std::atomic<bool>* manual_compaction_canceled = nullptr,
      const std::string& db_id = "", const std::string& db_session_id = "",
      std::string full_history_ts_low = "",
      BlobFileCompletionCallback* blob_callback = nullptr);
@@ -146,7 +145,7 @@ class CompactionJob {
  // consecutive groups such that each group has a similar size.
  void GenSubcompactionBoundaries();

-  CompactionServiceJobStatus ProcessKeyValueCompactionWithCompactionService(
+  void ProcessKeyValueCompactionWithCompactionService(
      SubcompactionState* sub_compact);

  // update the thread status for starting a compaction.
@@ -168,7 +167,7 @@ class CompactionJob {
  void UpdateCompactionInputStatsHelper(
      int* num_files, uint64_t* bytes_read, int input_level);

-  uint32_t job_id_;
+  int job_id_;

  CompactionJobStats* compaction_job_stats_;

@@ -186,7 +185,6 @@ class CompactionJob {
  VersionSet* versions_;
  const std::atomic<bool>* shutting_down_;
  const std::atomic<int>* manual_compaction_paused_;
-  const std::atomic<bool>* manual_compaction_canceled_;
  const SequenceNumber preserve_deletes_seqnum_;
  FSDirectory* db_directory_;
  FSDirectory* blob_output_directory_;
@@ -219,8 +217,6 @@ class CompactionJob {
  std::string full_history_ts_low_;
  BlobFileCompletionCallback* blob_callback_;

-  uint64_t GetCompactionId(SubcompactionState* sub_compact);
-
  // Get table file name in where it's outputting to, which should also be in
  // `output_directory_`.
  virtual std::string GetTableFileName(uint64_t file_number);
@@ -24,6 +24,7 @@
 #include "db/write_batch_internal.h"
 #include "env/mock_env.h"
 #include "file/filename.h"
+#include "memtable/hash_linklist_rep.h"
 #include "monitoring/statistics.h"
 #include "monitoring/thread_status_util.h"
 #include "port/stack_trace.h"
@@ -268,10 +269,10 @@ class CompactionJobStatsTest : public testing::Test,
    if (cf == 0) {
      // default cfd
      EXPECT_TRUE(db_->GetProperty(
-          "rocksdb.num-files-at-level" + ToString(level), &property));
+          "rocksdb.num-files-at-level" + NumberToString(level), &property));
    } else {
      EXPECT_TRUE(db_->GetProperty(
-          handles_[cf], "rocksdb.num-files-at-level" + ToString(level),
+          handles_[cf], "rocksdb.num-files-at-level" + NumberToString(level),
          &property));
    }
    return atoi(property.c_str());
@@ -82,11 +82,10 @@ class CompactionJobTestBase : public testing::Test {
        mutable_db_options_(),
        table_cache_(NewLRUCache(50000, 16)),
        write_buffer_manager_(db_options_.db_write_buffer_size),
-        versions_(new VersionSet(dbname_, &db_options_, env_options_,
-                                 table_cache_.get(), &write_buffer_manager_,
-                                 &write_controller_,
-                                 /*block_cache_tracer=*/nullptr,
-                                 /*io_tracer=*/nullptr, /*db_session_id*/ "")),
+        versions_(new VersionSet(
+            dbname_, &db_options_, env_options_, table_cache_.get(),
+            &write_buffer_manager_, &write_controller_,
+            /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr)),
        shutting_down_(false),
        preserve_deletes_seqnum_(0),
        mock_table_factory_(new mock::MockTableFactory()),
@@ -270,8 +269,7 @@ class CompactionJobTestBase : public testing::Test {
    versions_.reset(
        new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
                       &write_buffer_manager_, &write_controller_,
-                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                       /*db_session_id*/ ""));
+                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr));
    compaction_job_stats_.Reset();
    ASSERT_OK(SetIdentityFile(env_, dbname_));

@@ -334,8 +332,8 @@ class CompactionJobTestBase : public testing::Test {
        cfd->current()->storage_info(), *cfd->ioptions(),
        *cfd->GetLatestMutableCFOptions(), mutable_db_options_,
        compaction_input_files, output_level, 1024 * 1024, 10 * 1024 * 1024, 0,
-        kNoCompression, cfd->GetLatestMutableCFOptions()->compression_opts,
-        Temperature::kUnknown, 0, {}, true);
+        kNoCompression, cfd->GetLatestMutableCFOptions()->compression_opts, 0,
+        {}, true);
    compaction.SetInputVersion(cfd->current());

    LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
@@ -352,8 +350,7 @@ class CompactionJobTestBase : public testing::Test {
        earliest_write_conflict_snapshot, snapshot_checker, table_cache_,
        &event_logger, false, false, dbname_, &compaction_job_stats_,
        Env::Priority::USER, nullptr /* IOTracer */,
-        /*manual_compaction_paused=*/nullptr,
-        /*manual_compaction_canceled=*/nullptr, /*db_id=*/"",
+        /*manual_compaction_paused=*/nullptr, /*db_id=*/"",
        /*db_session_id=*/"", full_history_ts_low_);
    VerifyInitializationOfCompactionJobStats(compaction_job_stats_);

@@ -1120,9 +1117,7 @@ TEST_F(CompactionJobTest, InputSerialization) {
    input.snapshots.emplace_back(rnd64.Uniform(UINT64_MAX));
  }
  while (!rnd.OneIn(10)) {
-    input.input_files.emplace_back(rnd.RandomString(
-        rnd.Uniform(kStrMaxLen - 1) +
-        1));  // input file name should have at least one character
+    input.input_files.emplace_back(rnd.RandomString(rnd.Uniform(kStrMaxLen)));
  }
  input.output_level = 4;
  input.has_begin = rnd.OneIn(2);
@@ -358,7 +358,7 @@ Compaction* CompactionPicker::CompactFiles(
      output_level, compact_options.output_file_size_limit,
      mutable_cf_options.max_compaction_bytes, output_path_id, compression_type,
      GetCompressionOptions(mutable_cf_options, vstorage, output_level),
-      Temperature::kUnknown, compact_options.max_subcompactions,
+      compact_options.max_subcompactions,
      /* grandparents */ {}, true);
  RegisterCompaction(c);
  return c;
@@ -634,8 +634,7 @@ Compaction* CompactionPicker::CompactRange(
        GetCompressionType(ioptions_, vstorage, mutable_cf_options,
                           output_level, 1),
        GetCompressionOptions(mutable_cf_options, vstorage, output_level),
-        Temperature::kUnknown, compact_range_options.max_subcompactions,
-        /* grandparents */ {},
+        compact_range_options.max_subcompactions, /* grandparents */ {},
        /* is manual */ true);
    RegisterCompaction(c);
    vstorage->ComputeCompactionScore(ioptions_, mutable_cf_options);
@@ -813,8 +812,7 @@ Compaction* CompactionPicker::CompactRange(
      GetCompressionType(ioptions_, vstorage, mutable_cf_options, output_level,
                         vstorage->base_level()),
      GetCompressionOptions(mutable_cf_options, vstorage, output_level),
-      Temperature::kUnknown, compact_range_options.max_subcompactions,
-      std::move(grandparents),
+      compact_range_options.max_subcompactions, std::move(grandparents),
      /* is manual compaction */ true);

  TEST_SYNC_POINT_CALLBACK("CompactionPicker::CompactRange:Return", compaction);
@@ -111,7 +111,7 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
  Compaction* c = new Compaction(
      vstorage, ioptions_, mutable_cf_options, mutable_db_options,
      std::move(inputs), 0, 0, 0, 0, kNoCompression,
-      mutable_cf_options.compression_opts, Temperature::kUnknown,
+      mutable_cf_options.compression_opts,
      /* max_subcompactions */ 0, {}, /* is manual */ false,
      vstorage->CompactionScore(0),
      /* is deletion compaction */ true, CompactionReason::kFIFOTtl);
@@ -154,8 +154,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
            {comp_inputs}, 0, 16 * 1024 * 1024 /* output file size limit */,
            0 /* max compaction bytes, not applicable */,
            0 /* output path ID */, mutable_cf_options.compression,
-            mutable_cf_options.compression_opts, Temperature::kUnknown,
-            0 /* max_subcompactions */, {},
+            mutable_cf_options.compression_opts, 0 /* max_subcompactions */, {},
            /* is manual */ false, vstorage->CompactionScore(0),
            /* is deletion compaction */ false,
            CompactionReason::kFIFOReduceNumFiles);
@@ -204,119 +203,13 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
  Compaction* c = new Compaction(
      vstorage, ioptions_, mutable_cf_options, mutable_db_options,
      std::move(inputs), 0, 0, 0, 0, kNoCompression,
-      mutable_cf_options.compression_opts, Temperature::kUnknown,
+      mutable_cf_options.compression_opts,
      /* max_subcompactions */ 0, {}, /* is manual */ false,
      vstorage->CompactionScore(0),
      /* is deletion compaction */ true, CompactionReason::kFIFOMaxSize);
  return c;
 }

-Compaction* FIFOCompactionPicker::PickCompactionToWarm(
-    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer) {
-  if (mutable_cf_options.compaction_options_fifo.age_for_warm == 0) {
-    return nullptr;
-  }
-
-  const int kLevel0 = 0;
-  const std::vector<FileMetaData*>& level_files = vstorage->LevelFiles(kLevel0);
-
-  int64_t _current_time;
-  auto status = ioptions_.clock->GetCurrentTime(&_current_time);
-  if (!status.ok()) {
-    ROCKS_LOG_BUFFER(log_buffer,
-                     "[%s] FIFO compaction: Couldn't get current time: %s. "
-                     "Not doing compactions based on warm threshold. ",
-                     cf_name.c_str(), status.ToString().c_str());
-    return nullptr;
-  }
-  const uint64_t current_time = static_cast<uint64_t>(_current_time);
-
-  if (!level0_compactions_in_progress_.empty()) {
-    ROCKS_LOG_BUFFER(
-        log_buffer,
-        "[%s] FIFO compaction: Already executing compaction. Parallel "
-        "compactions are not supported",
-        cf_name.c_str());
-    return nullptr;
-  }
-
-  std::vector<CompactionInputFiles> inputs;
-  inputs.emplace_back();
-  inputs[0].level = 0;
-
-  // avoid underflow
-  if (current_time > mutable_cf_options.compaction_options_fifo.age_for_warm) {
-    uint64_t create_time_threshold =
-        current_time - mutable_cf_options.compaction_options_fifo.age_for_warm;
-    uint64_t compaction_size = 0;
-    // We will ideally identify a file qualifying for warm tier by knowing
-    // the timestamp for the youngest entry in the file. However, right now
-    // we don't have the information. We infer it by looking at timestamp
-    // of the next file's (which is just younger) oldest entry's timestamp.
-    FileMetaData* prev_file = nullptr;
-    for (auto ritr = level_files.rbegin(); ritr != level_files.rend(); ++ritr) {
-      FileMetaData* f = *ritr;
-      assert(f);
-      if (f->being_compacted) {
-        // Right now this probably won't happen as we never try to schedule
-        // two compactions in parallel, so here we just simply don't schedule
-        // anything.
-        return nullptr;
-      }
-      uint64_t oldest_ancester_time = f->TryGetOldestAncesterTime();
-      if (oldest_ancester_time == kUnknownOldestAncesterTime) {
-        // Older files might not have enough information. It is possible to
-        // handle these files by looking at newer files, but maintaining the
-        // logic isn't worth it.
-        break;
-      }
-      if (oldest_ancester_time > create_time_threshold) {
-        // The previous file (which has slightly older data) doesn't qualify
-        // for warm tier.
-        break;
-      }
-      if (prev_file != nullptr) {
-        compaction_size += prev_file->fd.GetFileSize();
-        if (compaction_size > mutable_cf_options.max_compaction_bytes) {
-          break;
-        }
-        inputs[0].files.push_back(prev_file);
-        ROCKS_LOG_BUFFER(log_buffer,
-                         "[%s] FIFO compaction: picking file %" PRIu64
-                         " with next file's oldest time %" PRIu64 " for warm",
-                         cf_name.c_str(), prev_file->fd.GetNumber(),
-                         oldest_ancester_time);
-      }
-      if (f->temperature == Temperature::kUnknown ||
-          f->temperature == Temperature::kHot) {
-        prev_file = f;
-      } else if (!inputs[0].files.empty()) {
-        // A warm file newer than files picked.
-        break;
-      } else {
-        assert(prev_file == nullptr);
-      }
-    }
-  }
-
-  if (inputs[0].files.empty()) {
-    return nullptr;
-  }
-
-  Compaction* c = new Compaction(
-      vstorage, ioptions_, mutable_cf_options, mutable_db_options,
-      std::move(inputs), 0, 0 /* output file size limit */,
-      0 /* max compaction bytes, not applicable */, 0 /* output path ID */,
-      mutable_cf_options.compression, mutable_cf_options.compression_opts,
-      Temperature::kWarm,
-      /* max_subcompactions */ 0, {}, /* is manual */ false,
-      vstorage->CompactionScore(0),
-      /* is deletion compaction */ false, CompactionReason::kChangeTemperature);
-  return c;
-}
-
 Compaction* FIFOCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
@@ -332,10 +225,6 @@ Compaction* FIFOCompactionPicker::PickCompaction(
    c = PickSizeCompaction(cf_name, mutable_cf_options, mutable_db_options,
                           vstorage, log_buffer);
  }
-  if (c == nullptr) {
-    c = PickCompactionToWarm(cf_name, mutable_cf_options, mutable_db_options,
-                             vstorage, log_buffer);
-  }
  RegisterCompaction(c);
  return c;
 }
@@ -52,12 +52,6 @@ class FIFOCompactionPicker : public CompactionPicker {
                                 const MutableDBOptions& mutable_db_options,
                                 VersionStorageInfo* version,
                                 LogBuffer* log_buffer);
-
-  Compaction* PickCompactionToWarm(const std::string& cf_name,
-                                   const MutableCFOptions& mutable_cf_options,
-                                   const MutableDBOptions& mutable_db_options,
-                                   VersionStorageInfo* version,
-                                   LogBuffer* log_buffer);
 };
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // !ROCKSDB_LITE
@@ -336,7 +336,6 @@ Compaction* LevelCompactionBuilder::GetCompaction() {
      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_,
                         output_level_, vstorage_->base_level()),
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level_),
-      Temperature::kUnknown,
      /* max_subcompactions */ 0, std::move(grandparents_), is_manual_,
      start_level_score_, false /* deletion_compaction */, compaction_reason_);

@@ -385,7 +384,7 @@ uint32_t LevelCompactionBuilder::GetPathId(
          if (ioptions.level_compaction_dynamic_level_bytes) {
            // Currently, level_compaction_dynamic_level_bytes is ignored when
            // multiple db paths are specified. https://github.com/facebook/
-            // rocksdb/blob/main/db/column_family.cc.
+            // rocksdb/blob/master/db/column_family.cc.
            // Still, adding this check to avoid accidentally using
            // max_bytes_for_level_multiplier_additional
            level_size = static_cast<uint64_t>(
@@ -98,9 +98,7 @@ class CompactionPickerTest : public testing::Test {
  void Add(int level, uint32_t file_number, const char* smallest,
           const char* largest, uint64_t file_size = 1, uint32_t path_id = 0,
           SequenceNumber smallest_seq = 100, SequenceNumber largest_seq = 100,
-           size_t compensated_file_size = 0, bool marked_for_compact = false,
-           Temperature temperature = Temperature::kUnknown,
-           uint64_t oldest_ancestor_time = kUnknownOldestAncesterTime) {
+           size_t compensated_file_size = 0, bool marked_for_compact = false) {
    VersionStorageInfo* vstorage;
    if (temp_vstorage_) {
      vstorage = temp_vstorage_.get();
@@ -117,8 +115,6 @@ class CompactionPickerTest : public testing::Test {
        kUnknownFileChecksum, kUnknownFileChecksumFuncName);
    f->compensated_file_size =
        (compensated_file_size != 0) ? compensated_file_size : file_size;
-    f->temperature = temperature;
-    f->oldest_ancester_time = oldest_ancestor_time;
    vstorage->AddFile(level, f);
    files_.emplace_back(f);
    file_map_.insert({file_number, {f, level}});
@@ -761,245 +757,6 @@ TEST_F(CompactionPickerTest, NeedsCompactionFIFO) {
              vstorage_->CompactionScore(0) >= 1);
  }
 }
-
-TEST_F(CompactionPickerTest, FIFOToWarm1) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kUnknown, threshold_time - 3000);
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
-  ASSERT_EQ(3U, compaction->input(0, 0)->fd.GetNumber());
-}
-
-TEST_F(CompactionPickerTest, FIFOToWarm2) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kUnknown, threshold_time - 3000);
-  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
-      Temperature::kUnknown, threshold_time - 4000);
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(2U, compaction->num_input_files(0));
-  ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(3U, compaction->input(0, 1)->fd.GetNumber());
-}
-
-TEST_F(CompactionPickerTest, FIFOToWarmMaxSize) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 9;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kUnknown, threshold_time - 3000);
-  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
-      Temperature::kUnknown, threshold_time - 4000);
-  Add(0, 1U, "200", "300", 4 * kFileSize, 0, 2000, 2100, 0, true,
-      Temperature::kUnknown, threshold_time - 5000);
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(2U, compaction->num_input_files(0));
-  ASSERT_EQ(1U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(2U, compaction->input(0, 1)->fd.GetNumber());
-}
-
-TEST_F(CompactionPickerTest, FIFOToWarmWithExistingWarm) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kUnknown, threshold_time - 3000);
-  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
-      Temperature::kUnknown, threshold_time - 4000);
-  Add(0, 1U, "200", "300", 4 * kFileSize, 0, 2000, 2100, 0, true,
-      Temperature::kWarm, threshold_time - 5000);
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(2U, compaction->num_input_files(0));
-  ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(3U, compaction->input(0, 1)->fd.GetNumber());
-}
-
-TEST_F(CompactionPickerTest, FIFOToWarmWithOngoing) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kUnknown, threshold_time - 3000);
-  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
-      Temperature::kUnknown, threshold_time - 4000);
-  Add(0, 1U, "200", "300", 4 * kFileSize, 0, 2000, 2100, 0, true,
-      Temperature::kWarm, threshold_time - 5000);
-  file_map_[2].first->being_compacted = true;
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  // Stop if a file is being compacted
-  ASSERT_TRUE(compaction.get() == nullptr);
-}
-
-TEST_F(CompactionPickerTest, FIFOToWarmWithHotBetweenWarms) {
-  NewVersionStorage(1, kCompactionStyleFIFO);
-  const uint64_t kFileSize = 100000;
-  const uint64_t kMaxSize = kFileSize * 100000;
-  uint64_t kWarmThreshold = 2000;
-
-  fifo_options_.max_table_files_size = kMaxSize;
-  fifo_options_.age_for_warm = kWarmThreshold;
-  mutable_cf_options_.compaction_options_fifo = fifo_options_;
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.max_compaction_bytes = kFileSize * 100;
-  FIFOCompactionPicker fifo_compaction_picker(ioptions_, &icmp_);
-
-  int64_t current_time = 0;
-  ASSERT_OK(Env::Default()->GetCurrentTime(&current_time));
-  uint64_t threshold_time =
-      static_cast<uint64_t>(current_time) - kWarmThreshold;
-  Add(0, 6U, "240", "290", 2 * kFileSize, 0, 2900, 3000, 0, true,
-      Temperature::kUnknown, static_cast<uint64_t>(current_time) - 100);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 2700, 2800, 0, true,
-      Temperature::kUnknown, threshold_time + 100);
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 2500, 2600, 0, true,
-      Temperature::kUnknown, threshold_time - 2000);
-  Add(0, 3U, "200", "300", 4 * kFileSize, 0, 2300, 2400, 0, true,
-      Temperature::kWarm, threshold_time - 3000);
-  Add(0, 2U, "200", "300", 4 * kFileSize, 0, 2100, 2200, 0, true,
-      Temperature::kUnknown, threshold_time - 4000);
-  Add(0, 1U, "200", "300", 4 * kFileSize, 0, 2000, 2100, 0, true,
-      Temperature::kWarm, threshold_time - 5000);
-  UpdateVersionStorageInfo();
-
-  ASSERT_EQ(fifo_compaction_picker.NeedsCompaction(vstorage_.get()), true);
-  std::unique_ptr<Compaction> compaction(fifo_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_));
-  // Stop if a file is being compacted
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(1U, compaction->num_input_files(0));
-  ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
-}
-
 #endif  // ROCKSDB_LITE

 TEST_F(CompactionPickerTest, CompactionPriMinOverlapping1) {
@@ -157,9 +157,9 @@ struct SmallestKeyHeapComparator {
  const Comparator* ucmp_;
 };

-using SmallestKeyHeap =
-    std::priority_queue<InputFileInfo, std::vector<InputFileInfo>,
-                        SmallestKeyHeapComparator>;
+typedef std::priority_queue<InputFileInfo, std::vector<InputFileInfo>,
+                            SmallestKeyHeapComparator>
+    SmallestKeyHeap;

 // This function creates the heap that is used to find if the files are
 // overlapping during universal compaction when the allow_trivial_move
@@ -728,7 +728,6 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
                         1, enable_compression),
      GetCompressionOptions(mutable_cf_options_, vstorage_, start_level,
                            enable_compression),
-      Temperature::kUnknown,
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
      score_, false /* deletion_compaction */, compaction_reason);
 }
@@ -956,7 +955,6 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
      GetCompressionType(ioptions_, vstorage_, mutable_cf_options_,
                         output_level, 1),
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level),
-      Temperature::kUnknown,
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
      score_, false /* deletion_compaction */,
      CompactionReason::kFilesMarkedForCompaction);
@@ -1031,7 +1029,6 @@ Compaction* UniversalCompactionBuilder::PickCompactionToOldest(
                         output_level, 1, true /* enable_compression */),
      GetCompressionOptions(mutable_cf_options_, vstorage_, output_level,
                            true /* enable_compression */),
-      Temperature::kUnknown,
      /* max_subcompactions */ 0, /* grandparents */ {}, /* is manual */ false,
      score_, false /* deletion_compaction */, compaction_reason);
 }
@@ -10,70 +10,23 @@

 namespace ROCKSDB_NAMESPACE {

-class TestCompactionServiceBase {
+class MyTestCompactionService : public CompactionService {
 public:
-  virtual int GetCompactionNum() = 0;
-
-  void OverrideStartStatus(CompactionServiceJobStatus s) {
-    is_override_start_status = true;
-    override_start_status = s;
-  }
-
-  void OverrideWaitStatus(CompactionServiceJobStatus s) {
-    is_override_wait_status = true;
-    override_wait_status = s;
-  }
-
-  void OverrideWaitResult(std::string str) {
-    is_override_wait_result = true;
-    override_wait_result = std::move(str);
-  }
-
-  void ResetOverride() {
-    is_override_wait_result = false;
-    is_override_start_status = false;
-    is_override_wait_status = false;
-  }
-
-  virtual ~TestCompactionServiceBase() = default;
-
- protected:
-  bool is_override_start_status = false;
-  CompactionServiceJobStatus override_start_status =
-      CompactionServiceJobStatus::kFailure;
-  bool is_override_wait_status = false;
-  CompactionServiceJobStatus override_wait_status =
-      CompactionServiceJobStatus::kFailure;
-  bool is_override_wait_result = false;
-  std::string override_wait_result;
-};
-
-class MyTestCompactionServiceLegacy : public CompactionService,
-                                      public TestCompactionServiceBase {
- public:
-  MyTestCompactionServiceLegacy(std::string db_path, Options& options,
-                                std::shared_ptr<Statistics>& statistics)
-      : db_path_(std::move(db_path)),
-        options_(options),
-        statistics_(statistics) {}
-
-  static const char* kClassName() { return "MyTestCompactionServiceLegacy"; }
-
-  const char* Name() const override { return kClassName(); }
+  MyTestCompactionService(const std::string& db_path,
+                          std::shared_ptr<FileSystem> fs, Options& options)
+      : db_path_(db_path), fs_(fs), options_(options) {}

  CompactionServiceJobStatus Start(const std::string& compaction_service_input,
-                                   uint64_t job_id) override {
+                                   int job_id) override {
    InstrumentedMutexLock l(&mutex_);
    jobs_.emplace(job_id, compaction_service_input);
    CompactionServiceJobStatus s = CompactionServiceJobStatus::kSuccess;
-    if (is_override_start_status) {
-      return override_start_status;
-    }
+    TEST_SYNC_POINT_CALLBACK("MyTestCompactionService::Start::End", &s);
    return s;
  }

  CompactionServiceJobStatus WaitForComplete(
-      uint64_t job_id, std::string* compaction_service_result) override {
+      int job_id, std::string* compaction_service_result) override {
    std::string compaction_input;
    {
      InstrumentedMutexLock l(&mutex_);
@@ -85,10 +38,6 @@ class MyTestCompactionServiceLegacy : public CompactionService,
      jobs_.erase(i);
    }

-    if (is_override_wait_status) {
-      return override_wait_status;
-    }
-
    CompactionServiceOptionsOverride options_override;
    options_override.env = options_.env;
    options_override.file_checksum_gen_factory =
@@ -101,14 +50,12 @@ class MyTestCompactionServiceLegacy : public CompactionService,
    options_override.prefix_extractor = options_.prefix_extractor;
    options_override.table_factory = options_.table_factory;
    options_override.sst_partitioner_factory = options_.sst_partitioner_factory;
-    options_override.statistics = statistics_;

-    Status s = DB::OpenAndCompact(
-        db_path_, db_path_ + "/" + ROCKSDB_NAMESPACE::ToString(job_id),
-        compaction_input, compaction_service_result, options_override);
-    if (is_override_wait_result) {
-      *compaction_service_result = override_wait_result;
-    }
+    Status s = DB::OpenAndCompact(db_path_, db_path_ + "/" + ToString(job_id),
+                                  compaction_input, compaction_service_result,
+                                  options_override);
+    TEST_SYNC_POINT_CALLBACK("MyTestCompactionService::WaitForComplete::End",
+                             compaction_service_result);
    compaction_num_.fetch_add(1);
    if (s.ok()) {
      return CompactionServiceJobStatus::kSuccess;
@@ -117,155 +64,23 @@ class MyTestCompactionServiceLegacy : public CompactionService,
    }
  }

-  int GetCompactionNum() override { return compaction_num_.load(); }
+  int GetCompactionNum() { return compaction_num_.load(); }

 private:
  InstrumentedMutex mutex_;
  std::atomic_int compaction_num_{0};
-  std::map<uint64_t, std::string> jobs_;
+  std::map<int, std::string> jobs_;
  const std::string db_path_;
+  std::shared_ptr<FileSystem> fs_;
  Options options_;
-  std::shared_ptr<Statistics> statistics_;
 };

-class MyTestCompactionService : public CompactionService,
-                                public TestCompactionServiceBase {
- public:
-  MyTestCompactionService(std::string db_path, Options& options,
-                          std::shared_ptr<Statistics>& statistics)
-      : db_path_(std::move(db_path)),
-        options_(options),
-        statistics_(statistics),
-        start_info_("na", "na", "na", 0, Env::TOTAL),
-        wait_info_("na", "na", "na", 0, Env::TOTAL) {}
-
-  static const char* kClassName() { return "MyTestCompactionService"; }
-
-  const char* Name() const override { return kClassName(); }
-
-  CompactionServiceJobStatus StartV2(
-      const CompactionServiceJobInfo& info,
-      const std::string& compaction_service_input) override {
-    InstrumentedMutexLock l(&mutex_);
-    start_info_ = info;
-    assert(info.db_name == db_path_);
-    jobs_.emplace(info.job_id, compaction_service_input);
-    CompactionServiceJobStatus s = CompactionServiceJobStatus::kSuccess;
-    if (is_override_start_status) {
-      return override_start_status;
-    }
-    return s;
-  }
-
-  CompactionServiceJobStatus WaitForCompleteV2(
-      const CompactionServiceJobInfo& info,
-      std::string* compaction_service_result) override {
-    std::string compaction_input;
-    assert(info.db_name == db_path_);
-    {
-      InstrumentedMutexLock l(&mutex_);
-      wait_info_ = info;
-      auto i = jobs_.find(info.job_id);
-      if (i == jobs_.end()) {
-        return CompactionServiceJobStatus::kFailure;
-      }
-      compaction_input = std::move(i->second);
-      jobs_.erase(i);
-    }
-
-    if (is_override_wait_status) {
-      return override_wait_status;
-    }
-
-    CompactionServiceOptionsOverride options_override;
-    options_override.env = options_.env;
-    options_override.file_checksum_gen_factory =
-        options_.file_checksum_gen_factory;
-    options_override.comparator = options_.comparator;
-    options_override.merge_operator = options_.merge_operator;
-    options_override.compaction_filter = options_.compaction_filter;
-    options_override.compaction_filter_factory =
-        options_.compaction_filter_factory;
-    options_override.prefix_extractor = options_.prefix_extractor;
-    options_override.table_factory = options_.table_factory;
-    options_override.sst_partitioner_factory = options_.sst_partitioner_factory;
-    options_override.statistics = statistics_;
-
-    Status s = DB::OpenAndCompact(
-        db_path_, db_path_ + "/" + ROCKSDB_NAMESPACE::ToString(info.job_id),
-        compaction_input, compaction_service_result, options_override);
-    if (is_override_wait_result) {
-      *compaction_service_result = override_wait_result;
-    }
-    compaction_num_.fetch_add(1);
-    if (s.ok()) {
-      return CompactionServiceJobStatus::kSuccess;
-    } else {
-      return CompactionServiceJobStatus::kFailure;
-    }
-  }
-
-  int GetCompactionNum() override { return compaction_num_.load(); }
-
-  CompactionServiceJobInfo GetCompactionInfoForStart() { return start_info_; }
-  CompactionServiceJobInfo GetCompactionInfoForWait() { return wait_info_; }
-
- private:
-  InstrumentedMutex mutex_;
-  std::atomic_int compaction_num_{0};
-  std::map<uint64_t, std::string> jobs_;
-  const std::string db_path_;
-  Options options_;
-  std::shared_ptr<Statistics> statistics_;
-  CompactionServiceJobInfo start_info_;
-  CompactionServiceJobInfo wait_info_;
-};
-
-// This is only for listing test classes
-enum TestCompactionServiceType {
-  MyTestCompactionServiceType,
-  MyTestCompactionServiceLegacyType,
-};
-
-class CompactionServiceTest
-    : public DBTestBase,
-      public testing::WithParamInterface<TestCompactionServiceType> {
+class CompactionServiceTest : public DBTestBase {
 public:
  explicit CompactionServiceTest()
      : DBTestBase("compaction_service_test", true) {}

 protected:
-  void ReopenWithCompactionService(Options* options) {
-    options->env = env_;
-    primary_statistics_ = CreateDBStatistics();
-    options->statistics = primary_statistics_;
-    compactor_statistics_ = CreateDBStatistics();
-    TestCompactionServiceType cs_type = GetParam();
-    switch (cs_type) {
-      case MyTestCompactionServiceType:
-        compaction_service_ = std::make_shared<MyTestCompactionService>(
-            dbname_, *options, compactor_statistics_);
-        break;
-      case MyTestCompactionServiceLegacyType:
-        compaction_service_ = std::make_shared<MyTestCompactionServiceLegacy>(
-            dbname_, *options, compactor_statistics_);
-        break;
-      default:
-        assert(false);
-    }
-    options->compaction_service = compaction_service_;
-    DestroyAndReopen(*options);
-  }
-
-  Statistics* GetCompactorStatistics() { return compactor_statistics_.get(); }
-
-  Statistics* GetPrimaryStatistics() { return primary_statistics_.get(); }
-
-  TestCompactionServiceBase* GetCompactionService() {
-    CompactionService* cs = compaction_service_.get();
-    return dynamic_cast<TestCompactionServiceBase*>(cs);
-  }
-
  void GenerateTestData() {
    // Generate 20 files @ L2
    for (int i = 0; i < 20; i++) {
@@ -299,16 +114,15 @@ class CompactionServiceTest
      }
    }
  }
-
- private:
-  std::shared_ptr<Statistics> compactor_statistics_;
-  std::shared_ptr<Statistics> primary_statistics_;
-  std::shared_ptr<CompactionService> compaction_service_;
 };

-TEST_P(CompactionServiceTest, BasicCompactions) {
+TEST_F(CompactionServiceTest, BasicCompactions) {
  Options options = CurrentOptions();
-  ReopenWithCompactionService(&options);
+  options.env = env_;
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+
+  DestroyAndReopen(options);

  for (int i = 0; i < 20; i++) {
    for (int j = 0; j < 10; j++) {
@@ -336,22 +150,15 @@ TEST_P(CompactionServiceTest, BasicCompactions) {
      ASSERT_EQ(result, "value_new" + ToString(i));
    }
  }
-  auto my_cs = GetCompactionService();
-  Statistics* compactor_statistics = GetCompactorStatistics();
+  auto my_cs =
+      dynamic_cast<MyTestCompactionService*>(options.compaction_service.get());
  ASSERT_GE(my_cs->GetCompactionNum(), 1);

-  // make sure the compaction statistics is only recorded on the remote side
-  ASSERT_GE(
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY), 1);
-  Statistics* primary_statistics = GetPrimaryStatistics();
-  ASSERT_EQ(primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-            0);
-
  // Test failed compaction
  SyncPoint::GetInstance()->SetCallBack(
      "DBImplSecondary::CompactWithoutInstallation::End", [&](void* status) {
        // override job status
-        auto s = static_cast<Status*>(status);
+        Status* s = static_cast<Status*>(status);
        *s = Status::Aborted("MyTestCompactionService failed to compact!");
      });
  SyncPoint::GetInstance()->EnableProcessing();
@@ -380,13 +187,17 @@ TEST_P(CompactionServiceTest, BasicCompactions) {
  ASSERT_TRUE(s.IsAborted());
 }

-TEST_P(CompactionServiceTest, ManualCompaction) {
+TEST_F(CompactionServiceTest, ManualCompaction) {
  Options options = CurrentOptions();
+  options.env = env_;
  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+  DestroyAndReopen(options);
  GenerateTestData();

-  auto my_cs = GetCompactionService();
+  auto my_cs =
+      dynamic_cast<MyTestCompactionService*>(options.compaction_service.get());

  std::string start_str = Key(15);
  std::string end_str = Key(45);
@@ -417,15 +228,22 @@ TEST_P(CompactionServiceTest, ManualCompaction) {
  VerifyTestData();
 }

-TEST_P(CompactionServiceTest, FailedToStart) {
+TEST_F(CompactionServiceTest, FailedToStart) {
  Options options = CurrentOptions();
+  options.env = env_;
  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+  DestroyAndReopen(options);
  GenerateTestData();

-  auto my_cs = GetCompactionService();
-  my_cs->OverrideStartStatus(CompactionServiceJobStatus::kFailure);
+  SyncPoint::GetInstance()->SetCallBack(
+      "MyTestCompactionService::Start::End", [&](void* status) {
+        // override job status
+        auto s = static_cast<CompactionServiceJobStatus*>(status);
+        *s = CompactionServiceJobStatus::kFailure;
+      });
+  SyncPoint::GetInstance()->EnableProcessing();

  std::string start_str = Key(15);
  std::string end_str = Key(45);
@@ -435,15 +253,22 @@ TEST_P(CompactionServiceTest, FailedToStart) {
  ASSERT_TRUE(s.IsIncomplete());
 }

-TEST_P(CompactionServiceTest, InvalidResult) {
+TEST_F(CompactionServiceTest, InvalidResult) {
  Options options = CurrentOptions();
+  options.env = env_;
  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+  DestroyAndReopen(options);
  GenerateTestData();

-  auto my_cs = GetCompactionService();
-  my_cs->OverrideWaitResult("Invalid Str");
+  SyncPoint::GetInstance()->SetCallBack(
+      "MyTestCompactionService::WaitForComplete::End", [&](void* result) {
+        // override job status
+        auto result_str = static_cast<std::string*>(result);
+        *result_str = "Invalid Str";
+      });
+  SyncPoint::GetInstance()->EnableProcessing();

  std::string start_str = Key(15);
  std::string end_str = Key(45);
@@ -453,27 +278,22 @@ TEST_P(CompactionServiceTest, InvalidResult) {
  ASSERT_FALSE(s.ok());
 }

-TEST_P(CompactionServiceTest, SubCompaction) {
+// TODO: support sub-compaction
+TEST_F(CompactionServiceTest, DISABLED_SubCompaction) {
  Options options = CurrentOptions();
+  options.env = env_;
  options.max_subcompactions = 10;
  options.target_file_size_base = 1 << 10;  // 1KB
  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);

+  DestroyAndReopen(options);
  GenerateTestData();
-  VerifyTestData();
-
-  auto my_cs = GetCompactionService();
-  int compaction_num_before = my_cs->GetCompactionNum();

  auto cro = CompactRangeOptions();
  cro.max_subcompactions = 10;
-  Status s = db_->CompactRange(cro, nullptr, nullptr);
-  ASSERT_OK(s);
-  VerifyTestData();
-  int compaction_num = my_cs->GetCompactionNum() - compaction_num_before;
-  // make sure there's sub-compaction by checking the compaction number
-  ASSERT_GE(compaction_num, 2);
+  db_->CompactRange(cro, nullptr, nullptr);
 }

 class PartialDeleteCompactionFilter : public CompactionFilter {
@@ -492,12 +312,15 @@ class PartialDeleteCompactionFilter : public CompactionFilter {
  const char* Name() const override { return "PartialDeleteCompactionFilter"; }
 };

-TEST_P(CompactionServiceTest, CompactionFilter) {
+TEST_F(CompactionServiceTest, CompactionFilter) {
  Options options = CurrentOptions();
-  std::unique_ptr<CompactionFilter> delete_comp_filter(
-      new PartialDeleteCompactionFilter());
-  options.compaction_filter = delete_comp_filter.get();
-  ReopenWithCompactionService(&options);
+  options.env = env_;
+  auto delete_comp_filter = PartialDeleteCompactionFilter();
+  options.compaction_filter = &delete_comp_filter;
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+
+  DestroyAndReopen(options);

  for (int i = 0; i < 20; i++) {
    for (int j = 0; j < 10; j++) {
@@ -529,13 +352,18 @@ TEST_P(CompactionServiceTest, CompactionFilter) {
      ASSERT_EQ(result, "value_new" + ToString(i));
    }
  }
-  auto my_cs = GetCompactionService();
+  auto my_cs =
+      dynamic_cast<MyTestCompactionService*>(options.compaction_service.get());
  ASSERT_GE(my_cs->GetCompactionNum(), 1);
 }

-TEST_P(CompactionServiceTest, Snapshot) {
+TEST_F(CompactionServiceTest, Snapshot) {
  Options options = CurrentOptions();
-  ReopenWithCompactionService(&options);
+  options.env = env_;
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
+
+  DestroyAndReopen(options);

  ASSERT_OK(Put(Key(1), "value1"));
  ASSERT_OK(Put(Key(2), "value1"));
@@ -547,18 +375,23 @@ TEST_P(CompactionServiceTest, Snapshot) {
  ASSERT_OK(Flush());

  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  auto my_cs = GetCompactionService();
+  auto my_cs =
+      dynamic_cast<MyTestCompactionService*>(options.compaction_service.get());
  ASSERT_GE(my_cs->GetCompactionNum(), 1);
  ASSERT_EQ("value1", Get(Key(1), s1));
  ASSERT_EQ("value2", Get(Key(1)));
  db_->ReleaseSnapshot(s1);
 }

-TEST_P(CompactionServiceTest, ConcurrentCompaction) {
+TEST_F(CompactionServiceTest, ConcurrentCompaction) {
  Options options = CurrentOptions();
  options.level0_file_num_compaction_trigger = 100;
+  options.env = env_;
+  options.compaction_service = std::make_shared<MyTestCompactionService>(
+      dbname_, env_->GetFileSystem(), options);
  options.max_background_jobs = 20;
-  ReopenWithCompactionService(&options);
+
+  DestroyAndReopen(options);
  GenerateTestData();

  ColumnFamilyMetaData meta;
@@ -586,209 +419,12 @@ TEST_P(CompactionServiceTest, ConcurrentCompaction) {
      ASSERT_EQ(result, "value_new" + ToString(i));
    }
  }
-  auto my_cs = GetCompactionService();
+  auto my_cs =
+      dynamic_cast<MyTestCompactionService*>(options.compaction_service.get());
  ASSERT_EQ(my_cs->GetCompactionNum(), 10);
  ASSERT_EQ(FilesPerLevel(), "0,0,10");
 }

-TEST_P(CompactionServiceTest, CompactionInfo) {
-  // only test compaction info for new compaction service interface
-  if (GetParam() != MyTestCompactionServiceType) {
-    return;
-  }
-
-  Options options = CurrentOptions();
-  ReopenWithCompactionService(&options);
-
-  for (int i = 0; i < 20; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  for (int i = 0; i < 10; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 20 + j * 2;
-      ASSERT_OK(Put(Key(key_id), "value_new" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  auto my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-  uint64_t comp_num = my_cs->GetCompactionNum();
-  ASSERT_GE(comp_num, 1);
-
-  CompactionServiceJobInfo info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(dbname_, info.db_name);
-  std::string db_id, db_session_id;
-  ASSERT_OK(db_->GetDbIdentity(db_id));
-  ASSERT_EQ(db_id, info.db_id);
-  ASSERT_OK(db_->GetDbSessionId(db_session_id));
-  ASSERT_EQ(db_session_id, info.db_session_id);
-  ASSERT_EQ(Env::LOW, info.priority);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(dbname_, info.db_name);
-  ASSERT_EQ(db_id, info.db_id);
-  ASSERT_EQ(db_session_id, info.db_session_id);
-  ASSERT_EQ(Env::LOW, info.priority);
-
-  // Test priority USER
-  ColumnFamilyMetaData meta;
-  db_->GetColumnFamilyMetaData(&meta);
-  SstFileMetaData file = meta.levels[1].files[0];
-  ASSERT_OK(db_->CompactFiles(CompactionOptions(),
-                              {file.db_path + "/" + file.name}, 2));
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(Env::USER, info.priority);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(Env::USER, info.priority);
-
-  // Test priority BOTTOM
-  env_->SetBackgroundThreads(1, Env::BOTTOM);
-  options.num_levels = 2;
-  ReopenWithCompactionService(&options);
-  my_cs =
-      static_cast_with_check<MyTestCompactionService>(GetCompactionService());
-
-  for (int i = 0; i < 20; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 20 + j * 2;
-      ASSERT_OK(Put(Key(key_id), "value_new" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  info = my_cs->GetCompactionInfoForStart();
-  ASSERT_EQ(Env::BOTTOM, info.priority);
-  info = my_cs->GetCompactionInfoForWait();
-  ASSERT_EQ(Env::BOTTOM, info.priority);
-}
-
-TEST_P(CompactionServiceTest, FallbackLocalAuto) {
-  Options options = CurrentOptions();
-  ReopenWithCompactionService(&options);
-
-  auto my_cs = GetCompactionService();
-  Statistics* compactor_statistics = GetCompactorStatistics();
-  Statistics* primary_statistics = GetPrimaryStatistics();
-  uint64_t compactor_new_key =
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-  uint64_t primary_new_key =
-      primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-
-  my_cs->OverrideStartStatus(CompactionServiceJobStatus::kUseLocal);
-
-  for (int i = 0; i < 20; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 10 + j;
-      ASSERT_OK(Put(Key(key_id), "value" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-
-  for (int i = 0; i < 10; i++) {
-    for (int j = 0; j < 10; j++) {
-      int key_id = i * 20 + j * 2;
-      ASSERT_OK(Put(Key(key_id), "value_new" + ToString(key_id)));
-    }
-    ASSERT_OK(Flush());
-  }
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  // verify result
-  for (int i = 0; i < 200; i++) {
-    auto result = Get(Key(i));
-    if (i % 2) {
-      ASSERT_EQ(result, "value" + ToString(i));
-    } else {
-      ASSERT_EQ(result, "value_new" + ToString(i));
-    }
-  }
-
-  ASSERT_EQ(my_cs->GetCompactionNum(), 0);
-
-  // make sure the compaction statistics is only recorded on the local side
-  ASSERT_EQ(
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-      compactor_new_key);
-  ASSERT_GT(primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-            primary_new_key);
-}
-
-TEST_P(CompactionServiceTest, FallbackLocalManual) {
-  Options options = CurrentOptions();
-  options.disable_auto_compactions = true;
-  ReopenWithCompactionService(&options);
-
-  GenerateTestData();
-  VerifyTestData();
-
-  auto my_cs = GetCompactionService();
-  Statistics* compactor_statistics = GetCompactorStatistics();
-  Statistics* primary_statistics = GetPrimaryStatistics();
-  uint64_t compactor_new_key =
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-  uint64_t primary_new_key =
-      primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-
-  // re-enable remote compaction
-  my_cs->ResetOverride();
-  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();
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  ASSERT_GE(my_cs->GetCompactionNum(), comp_num + 1);
-  // make sure the compaction statistics is only recorded on the remote side
-  ASSERT_GT(
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-      compactor_new_key);
-  ASSERT_EQ(primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-            primary_new_key);
-
-  // return run local again with API WaitForComplete
-  my_cs->OverrideWaitStatus(CompactionServiceJobStatus::kUseLocal);
-  start_str = Key(120);
-  start = start_str;
-  comp_num = my_cs->GetCompactionNum();
-  compactor_new_key =
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-  primary_new_key =
-      primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY);
-
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, nullptr));
-  ASSERT_EQ(my_cs->GetCompactionNum(),
-            comp_num);  // no remote compaction is run
-  // make sure the compaction statistics is only recorded on the local side
-  ASSERT_EQ(
-      compactor_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-      compactor_new_key);
-  ASSERT_GT(primary_statistics->getTickerCount(COMPACTION_KEY_DROP_NEWER_ENTRY),
-            primary_new_key);
-
-  // verify result after 2 manual compactions
-  VerifyTestData();
-}
-
-INSTANTIATE_TEST_CASE_P(
-    CompactionServiceTest, CompactionServiceTest,
-    ::testing::Values(
-        TestCompactionServiceType::MyTestCompactionServiceType,
-        TestCompactionServiceType::MyTestCompactionServiceLegacyType));
-
 }  // namespace ROCKSDB_NAMESPACE

 #ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
@@ -55,9 +55,14 @@ class CorruptionTest : public testing::Test {
    // bug in recovery code. Keep it 4 for now to make the test passes.
    tiny_cache_ = NewLRUCache(100, 4);
    Env* base_env = Env::Default();
-    EXPECT_OK(
-        test::CreateEnvFromSystem(ConfigOptions(), &base_env, &env_guard_));
-    EXPECT_NE(base_env, nullptr);
+#ifndef ROCKSDB_LITE
+    const char* test_env_uri = getenv("TEST_ENV_URI");
+    if (test_env_uri) {
+      Status s = Env::LoadEnv(test_env_uri, &base_env, &env_guard_);
+      EXPECT_OK(s);
+      EXPECT_NE(Env::Default(), base_env);
+    }
+#endif  //! ROCKSDB_LITE
    env_ = new test::ErrorEnv(base_env);
    options_.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
    options_.env = env_;
@@ -94,8 +94,8 @@ class CuckooTableDBTest : public testing::Test {

  int NumTableFilesAtLevel(int level) {
    std::string property;
-    EXPECT_TRUE(db_->GetProperty("rocksdb.num-files-at-level" + ToString(level),
-                                 &property));
+    EXPECT_TRUE(db_->GetProperty(
+        "rocksdb.num-files-at-level" + NumberToString(level), &property));
    return atoi(property.c_str());
  }

@@ -8,6 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include <cstring>
+#include <regex>

 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
@@ -30,7 +31,7 @@ namespace ROCKSDB_NAMESPACE {

 class DBBasicTest : public DBTestBase {
 public:
-  DBBasicTest() : DBTestBase("db_basic_test", /*env_do_fsync=*/false) {}
+  DBBasicTest() : DBTestBase("/db_basic_test", /*env_do_fsync=*/false) {}
 };

 TEST_F(DBBasicTest, OpenWhenOpen) {
@@ -68,10 +69,11 @@ TEST_F(DBBasicTest, UniqueSession) {
  ASSERT_EQ(sid2, sid4);

  // Expected compact format for session ids (see notes in implementation)
-  TestRegex expected("[0-9A-Z]{20}");
-  EXPECT_MATCHES_REGEX(sid1, expected);
-  EXPECT_MATCHES_REGEX(sid2, expected);
-  EXPECT_MATCHES_REGEX(sid3, expected);
+  std::regex expected("[0-9A-Z]{20}");
+  const std::string match("match");
+  EXPECT_EQ(match, std::regex_replace(sid1, expected, match));
+  EXPECT_EQ(match, std::regex_replace(sid2, expected, match));
+  EXPECT_EQ(match, std::regex_replace(sid3, expected, match));

 #ifndef ROCKSDB_LITE
  Close();
@@ -1360,28 +1362,6 @@ TEST_P(DBMultiGetTestWithParam, MultiGetMultiCFSnapshot) {
  }
 }

-TEST_P(DBMultiGetTestWithParam, MultiGetMultiCFUnsorted) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"one", "two"}, options);
-
-  ASSERT_OK(Put(1, "foo", "bar"));
-  ASSERT_OK(Put(2, "baz", "xyz"));
-  ASSERT_OK(Put(1, "abc", "def"));
-
-  // Note: keys for the same CF do not form a consecutive range
-  std::vector<int> cfs{1, 2, 1};
-  std::vector<std::string> keys{"foo", "baz", "abc"};
-  std::vector<std::string> values;
-
-  values =
-      MultiGet(cfs, keys, /* snapshot */ nullptr, /* batched */ GetParam());
-
-  ASSERT_EQ(values.size(), 3);
-  ASSERT_EQ(values[0], "bar");
-  ASSERT_EQ(values[1], "xyz");
-  ASSERT_EQ(values[2], "def");
-}
-
 INSTANTIATE_TEST_CASE_P(DBMultiGetTestWithParam, DBMultiGetTestWithParam,
                        testing::Bool());

@@ -2596,7 +2576,7 @@ class DBBasicTestTrackWal : public DBTestBase,
                            public testing::WithParamInterface<bool> {
 public:
  DBBasicTestTrackWal()
-      : DBTestBase("db_basic_test_track_wal", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_basic_test_track_wal", /*env_do_fsync=*/false) {}

  int CountWalFiles() {
    VectorLogPtr log_files;
@@ -2754,11 +2734,6 @@ class DBBasicTestMultiGet : public DBTestBase {
        EXPECT_OK(dbfull()->Flush(FlushOptions(), handles_[cf]));
      }
    }
-    // Clear compressed cache, which is always pre-populated
-    if (compressed_cache_) {
-      compressed_cache_->SetCapacity(0);
-      compressed_cache_->SetCapacity(1048576);
-    }
  }

  bool CheckValue(int i, const std::string& value) {
@@ -3235,11 +3210,13 @@ INSTANTIATE_TEST_CASE_P(ParallelIO, DBBasicTestWithParallelIO,
 // Forward declaration
 class DeadlineFS;

-class DeadlineRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
+class DeadlineRandomAccessFile : public FSRandomAccessFileWrapper {
 public:
  DeadlineRandomAccessFile(DeadlineFS& fs,
                           std::unique_ptr<FSRandomAccessFile>& file)
-      : FSRandomAccessFileOwnerWrapper(std::move(file)), fs_(fs) {}
+      : FSRandomAccessFileWrapper(file.get()),
+        fs_(fs),
+        file_(std::move(file)) {}

  IOStatus Read(uint64_t offset, size_t len, const IOOptions& opts,
                Slice* result, char* scratch,
@@ -7,7 +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 <cstdlib>
-#include <functional>
 #include <memory>

 #include "cache/cache_entry_roles.h"
@@ -15,12 +14,9 @@
 #include "db/column_family.h"
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
-#include "rocksdb/statistics.h"
 #include "rocksdb/table.h"
 #include "util/compression.h"
-#include "util/defer.h"
 #include "util/random.h"
-#include "utilities/fault_injection_fs.h"

 namespace ROCKSDB_NAMESPACE {

@@ -43,7 +39,7 @@ class DBBlockCacheTest : public DBTestBase {
  const size_t kValueSize = 100;

  DBBlockCacheTest()
-      : DBTestBase("db_block_cache_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_block_cache_test", /*env_do_fsync=*/true) {}

  BlockBasedTableOptions GetTableOptions() {
    BlockBasedTableOptions table_options;
@@ -261,28 +257,12 @@ TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {

 #ifdef SNAPPY
 TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  BlockBasedTableOptions table_options;
-  table_options.no_block_cache = true;
-  table_options.block_cache_compressed = nullptr;
-  table_options.block_size = 1;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  table_options.cache_index_and_filter_blocks = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.compression = CompressionType::kSnappyCompression;
-
-  DestroyAndReopen(options);
-
-  std::string value(kValueSize, 'a');
-  for (size_t i = 0; i < kNumBlocks; i++) {
-    ASSERT_OK(Put(ToString(i), value));
-    ASSERT_OK(Flush());
-  }
-
  ReadOptions read_options;
+  auto table_options = GetTableOptions();
+  auto options = GetOptions(table_options);
+  options.compression = CompressionType::kSnappyCompression;
+  InitTable(options);
+
  std::shared_ptr<Cache> compressed_cache = NewLRUCache(1 << 25, 0, false);
  LRUCacheOptions co;
  co.capacity = 0;
@@ -292,23 +272,25 @@ TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
  co.metadata_charge_policy = kDontChargeCacheMetadata;
  std::shared_ptr<Cache> cache = NewLRUCache(co);
  table_options.block_cache = cache;
-  table_options.no_block_cache = false;
  table_options.block_cache_compressed = compressed_cache;
-  table_options.max_auto_readahead_size = 0;
-  table_options.cache_index_and_filter_blocks = false;
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  Reopen(options);
  RecordCacheCounters(options);

+  std::vector<std::unique_ptr<Iterator>> iterators(kNumBlocks - 1);
+  Iterator* iter = nullptr;
+
  // Load blocks into cache.
-  for (size_t i = 0; i < kNumBlocks - 1; i++) {
-    ASSERT_EQ(value, Get(ToString(i)));
+  for (size_t i = 0; i + 1 < kNumBlocks; i++) {
+    iter = db_->NewIterator(read_options);
+    iter->Seek(ToString(i));
+    ASSERT_OK(iter->status());
    CheckCacheCounters(options, 1, 0, 1, 0);
    CheckCompressedCacheCounters(options, 1, 0, 1, 0);
+    iterators[i].reset(iter);
  }
-
  size_t usage = cache->GetUsage();
-  ASSERT_EQ(0, usage);
+  ASSERT_LT(0, usage);
  ASSERT_EQ(usage, cache->GetPinnedUsage());
  size_t compressed_usage = compressed_cache->GetUsage();
  ASSERT_LT(0, compressed_usage);
@@ -320,21 +302,24 @@ TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
  cache->SetCapacity(usage);
  cache->SetStrictCapacityLimit(true);
  ASSERT_EQ(usage, cache->GetPinnedUsage());
-
-  // Load last key block.
-  ASSERT_EQ("Result incomplete: Insert failed due to LRU cache being full.",
-            Get(ToString(kNumBlocks - 1)));
-  // Failure will also record the miss counter.
+  iter = db_->NewIterator(read_options);
+  iter->Seek(ToString(kNumBlocks - 1));
+  ASSERT_TRUE(iter->status().IsIncomplete());
  CheckCacheCounters(options, 1, 0, 0, 1);
  CheckCompressedCacheCounters(options, 1, 0, 1, 0);
+  delete iter;
+  iter = nullptr;

  // Clear strict capacity limit flag. This time we shall hit compressed block
-  // cache and load into block cache.
+  // cache.
  cache->SetStrictCapacityLimit(false);
-  // Load last key block.
-  ASSERT_EQ(value, Get(ToString(kNumBlocks - 1)));
+  iter = db_->NewIterator(read_options);
+  iter->Seek(ToString(kNumBlocks - 1));
+  ASSERT_OK(iter->status());
  CheckCacheCounters(options, 1, 0, 1, 0);
  CheckCompressedCacheCounters(options, 0, 1, 0, 0);
+  delete iter;
+  iter = nullptr;
 }
 #endif  // SNAPPY

@@ -482,136 +467,6 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
  //           filter_bytes_insert);
 }

-#if (defined OS_LINUX || defined OS_WIN)
-TEST_F(DBBlockCacheTest, WarmCacheWithDataBlocksDuringFlush) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewLRUCache(1 << 25, 0, false);
-  table_options.cache_index_and_filter_blocks = false;
-  table_options.prepopulate_block_cache =
-      BlockBasedTableOptions::PrepopulateBlockCache::kFlushOnly;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  DestroyAndReopen(options);
-
-  std::string value(kValueSize, 'a');
-  for (size_t i = 1; i <= kNumBlocks; i++) {
-    ASSERT_OK(Put(ToString(i), value));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-    ASSERT_EQ(value, Get(ToString(i)));
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_DATA_MISS));
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_DATA_HIT));
-  }
-  // Verify compaction not counted
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-  EXPECT_EQ(kNumBlocks,
-            options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-}
-
-// This test cache data, index and filter blocks during flush.
-TEST_F(DBBlockCacheTest, WarmCacheWithBlocksDuringFlush) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewLRUCache(1 << 25, 0, false);
-  table_options.cache_index_and_filter_blocks = true;
-  table_options.prepopulate_block_cache =
-      BlockBasedTableOptions::PrepopulateBlockCache::kFlushOnly;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  DestroyAndReopen(options);
-
-  std::string value(kValueSize, 'a');
-  for (size_t i = 1; i <= kNumBlocks; i++) {
-    ASSERT_OK(Put(ToString(i), value));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_INDEX_ADD));
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_FILTER_ADD));
-
-    ASSERT_EQ(value, Get(ToString(i)));
-
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_DATA_MISS));
-    ASSERT_EQ(i, options.statistics->getTickerCount(BLOCK_CACHE_DATA_HIT));
-
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_INDEX_MISS));
-    ASSERT_EQ(i * 3, options.statistics->getTickerCount(BLOCK_CACHE_INDEX_HIT));
-
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOCK_CACHE_FILTER_MISS));
-    ASSERT_EQ(i * 2,
-              options.statistics->getTickerCount(BLOCK_CACHE_FILTER_HIT));
-  }
-  // Verify compaction not counted
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-  EXPECT_EQ(kNumBlocks,
-            options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-  // Index and filter blocks are automatically warmed when the new table file
-  // is automatically opened at the end of compaction. This is not easily
-  // disabled so results in the new index and filter blocks being warmed.
-  EXPECT_EQ(1 + kNumBlocks,
-            options.statistics->getTickerCount(BLOCK_CACHE_INDEX_ADD));
-  EXPECT_EQ(1 + kNumBlocks,
-            options.statistics->getTickerCount(BLOCK_CACHE_FILTER_ADD));
-}
-
-TEST_F(DBBlockCacheTest, DynamicallyWarmCacheDuringFlush) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewLRUCache(1 << 25, 0, false);
-  table_options.cache_index_and_filter_blocks = false;
-  table_options.prepopulate_block_cache =
-      BlockBasedTableOptions::PrepopulateBlockCache::kFlushOnly;
-
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  DestroyAndReopen(options);
-
-  std::string value(kValueSize, 'a');
-
-  for (size_t i = 1; i <= 5; i++) {
-    ASSERT_OK(Put(ToString(i), value));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(1,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-
-    ASSERT_EQ(value, Get(ToString(i)));
-    ASSERT_EQ(0,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-    ASSERT_EQ(
-        0, options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-    ASSERT_EQ(1,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
-  }
-
-  ASSERT_OK(dbfull()->SetOptions(
-      {{"block_based_table_factory", "{prepopulate_block_cache=kDisable;}"}}));
-
-  for (size_t i = 6; i <= kNumBlocks; i++) {
-    ASSERT_OK(Put(ToString(i), value));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(0,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-
-    ASSERT_EQ(value, Get(ToString(i)));
-    ASSERT_EQ(1,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_ADD));
-    ASSERT_EQ(
-        1, options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_MISS));
-    ASSERT_EQ(0,
-              options.statistics->getAndResetTickerCount(BLOCK_CACHE_DATA_HIT));
-  }
-}
-#endif
-
 namespace {

 // A mock cache wraps LRUCache, and record how many entries have been
@@ -1319,238 +1174,13 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {

 #endif  // ROCKSDB_LITE

-class DBBlockCacheKeyTest
-    : public DBTestBase,
-      public testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  DBBlockCacheKeyTest()
-      : DBTestBase("db_block_cache_test", /*env_do_fsync=*/false) {}
-
-  void SetUp() override {
-    use_compressed_cache_ = std::get<0>(GetParam());
-    exclude_file_numbers_ = std::get<1>(GetParam());
-  }
-
-  bool use_compressed_cache_;
-  bool exclude_file_numbers_;
-};
-
-// Disable LinkFile so that we can physically copy a DB using Checkpoint.
-// Disable file GetUniqueId to enable stable cache keys.
-class StableCacheKeyTestFS : public FaultInjectionTestFS {
- public:
-  explicit StableCacheKeyTestFS(const std::shared_ptr<FileSystem>& base)
-      : FaultInjectionTestFS(base) {
-    SetFailGetUniqueId(true);
-  }
-
-  virtual ~StableCacheKeyTestFS() override {}
-
-  IOStatus LinkFile(const std::string&, const std::string&, const IOOptions&,
-                    IODebugContext*) override {
-    return IOStatus::NotSupported("Disabled");
-  }
-};
-
-TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
-  std::shared_ptr<StableCacheKeyTestFS> test_fs{
-      new StableCacheKeyTestFS(env_->GetFileSystem())};
-  std::unique_ptr<CompositeEnvWrapper> test_env{
-      new CompositeEnvWrapper(env_, test_fs)};
-
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-  options.env = test_env.get();
-
-  BlockBasedTableOptions table_options;
-
-  int key_count = 0;
-  uint64_t expected_stat = 0;
-
-  std::function<void()> verify_stats;
-  if (use_compressed_cache_) {
-    if (!Snappy_Supported()) {
-      ROCKSDB_GTEST_SKIP("Compressed cache test requires snappy support");
-      return;
-    }
-    options.compression = CompressionType::kSnappyCompression;
-    table_options.no_block_cache = true;
-    table_options.block_cache_compressed = NewLRUCache(1 << 25, 0, false);
-    verify_stats = [&options, &expected_stat] {
-      // One for ordinary SST file and one for external SST file
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_COMPRESSED_ADD));
-    };
-  } else {
-    table_options.cache_index_and_filter_blocks = true;
-    table_options.block_cache = NewLRUCache(1 << 25, 0, false);
-    verify_stats = [&options, &expected_stat] {
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_INDEX_ADD));
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_FILTER_ADD));
-    };
-  }
-
-  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  CreateAndReopenWithCF({"koko"}, options);
-
-  if (exclude_file_numbers_) {
-    // Simulate something like old behavior without file numbers in properties.
-    // This is a "control" side of the test that also ensures safely degraded
-    // behavior on old files.
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-        "PropertyBlockBuilder::AddTableProperty:Start", [&](void* arg) {
-          TableProperties* props = reinterpret_cast<TableProperties*>(arg);
-          props->orig_file_number = 0;
-        });
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  }
-
-  std::function<void()> perform_gets = [&key_count, &expected_stat, this]() {
-    if (exclude_file_numbers_) {
-      // No cache key reuse should happen, because we can't rely on current
-      // file number being stable
-      expected_stat += key_count;
-    } else {
-      // Cache keys should be stable
-      expected_stat = key_count;
-    }
-    for (int i = 0; i < key_count; ++i) {
-      ASSERT_EQ(Get(1, Key(i)), "abc");
-    }
-  };
-
-  // Ordinary SST files with same session id
-  const std::string something_compressible(500U, 'x');
-  for (int i = 0; i < 2; ++i) {
-    ASSERT_OK(Put(1, Key(key_count), "abc"));
-    ASSERT_OK(Put(1, Key(key_count) + "a", something_compressible));
-    ASSERT_OK(Flush(1));
-    ++key_count;
-  }
-
-#ifndef ROCKSDB_LITE
-  // Save an export of those ordinary SST files for later
-  std::string export_files_dir = dbname_ + "/exported";
-  ExportImportFilesMetaData* metadata_ptr_ = nullptr;
-  Checkpoint* checkpoint;
-  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
-  ASSERT_OK(checkpoint->ExportColumnFamily(handles_[1], export_files_dir,
-                                           &metadata_ptr_));
-  ASSERT_NE(metadata_ptr_, nullptr);
-  delete checkpoint;
-  checkpoint = nullptr;
-
-  // External SST files with same session id
-  SstFileWriter sst_file_writer(EnvOptions(), options);
-  std::vector<std::string> external;
-  for (int i = 0; i < 2; ++i) {
-    std::string f = dbname_ + "/external" + ToString(i) + ".sst";
-    external.push_back(f);
-    ASSERT_OK(sst_file_writer.Open(f));
-    ASSERT_OK(sst_file_writer.Put(Key(key_count), "abc"));
-    ASSERT_OK(
-        sst_file_writer.Put(Key(key_count) + "a", something_compressible));
-    ++key_count;
-    ExternalSstFileInfo external_info;
-    ASSERT_OK(sst_file_writer.Finish(&external_info));
-    IngestExternalFileOptions ingest_opts;
-    ASSERT_OK(db_->IngestExternalFile(handles_[1], {f}, ingest_opts));
-  }
-
-  if (exclude_file_numbers_) {
-    // FIXME(peterd): figure out where these extra two ADDs are coming from
-    options.statistics->recordTick(BLOCK_CACHE_INDEX_ADD,
-                                   uint64_t{0} - uint64_t{2});
-    options.statistics->recordTick(BLOCK_CACHE_FILTER_ADD,
-                                   uint64_t{0} - uint64_t{2});
-    options.statistics->recordTick(BLOCK_CACHE_COMPRESSED_ADD,
-                                   uint64_t{0} - uint64_t{2});
-  }
-#endif
-
-  perform_gets();
-  verify_stats();
-
-  // Make sure we can cache hit after re-open
-  ReopenWithColumnFamilies({"default", "koko"}, options);
-
-  perform_gets();
-  verify_stats();
-
-  // Make sure we can cache hit even on a full copy of the DB. Using
-  // StableCacheKeyTestFS, Checkpoint will resort to full copy not hard link.
-  // (Checkpoint  not available in LITE mode to test this.)
-#ifndef ROCKSDB_LITE
-  auto db_copy_name = dbname_ + "-copy";
-  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
-  ASSERT_OK(checkpoint->CreateCheckpoint(db_copy_name));
-  delete checkpoint;
-
-  Close();
-  Destroy(options);
-
-  // Switch to the DB copy
-  SaveAndRestore<std::string> save_dbname(&dbname_, db_copy_name);
-  ReopenWithColumnFamilies({"default", "koko"}, options);
-
-  perform_gets();
-  verify_stats();
-
-  // And ensure that re-importing + ingesting the same files into a
-  // different DB uses same cache keys
-  DestroyAndReopen(options);
-
-  ColumnFamilyHandle* cfh = nullptr;
-  ASSERT_OK(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                              ImportColumnFamilyOptions(),
-                                              *metadata_ptr_, &cfh));
-  ASSERT_NE(cfh, nullptr);
-  delete cfh;
-  cfh = nullptr;
-  delete metadata_ptr_;
-  metadata_ptr_ = nullptr;
-
-  DestroyDB(export_files_dir, options);
-
-  ReopenWithColumnFamilies({"default", "yoyo"}, options);
-
-  IngestExternalFileOptions ingest_opts;
-  ASSERT_OK(db_->IngestExternalFile(handles_[1], {external}, ingest_opts));
-
-  if (exclude_file_numbers_) {
-    // FIXME(peterd): figure out where these extra two ADDs are coming from
-    options.statistics->recordTick(BLOCK_CACHE_INDEX_ADD,
-                                   uint64_t{0} - uint64_t{2});
-    options.statistics->recordTick(BLOCK_CACHE_FILTER_ADD,
-                                   uint64_t{0} - uint64_t{2});
-  }
-
-  perform_gets();
-  verify_stats();
-#endif  // !ROCKSDB_LITE
-
-  Close();
-  Destroy(options);
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-}
-
-INSTANTIATE_TEST_CASE_P(DBBlockCacheKeyTest, DBBlockCacheKeyTest,
-                        ::testing::Combine(::testing::Bool(),
-                                           ::testing::Bool()));
-
 class DBBlockCachePinningTest
    : public DBTestBase,
      public testing::WithParamInterface<
          std::tuple<bool, PinningTier, PinningTier, PinningTier>> {
 public:
  DBBlockCachePinningTest()
-      : DBTestBase("db_block_cache_test", /*env_do_fsync=*/false) {}
+      : DBTestBase("/db_block_cache_test", /*env_do_fsync=*/false) {}

  void SetUp() override {
    partition_index_and_filters_ = std::get<0>(GetParam());
@@ -15,7 +15,6 @@
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
 #include "table/block_based/filter_policy_internal.h"
-#include "test_util/testutil.h"
 #include "util/string_util.h"

 namespace ROCKSDB_NAMESPACE {
@@ -29,7 +28,7 @@ using BFP = BloomFilterPolicy;
 class DBBloomFilterTest : public DBTestBase {
 public:
  DBBloomFilterTest()
-      : DBTestBase("db_bloom_filter_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_bloom_filter_test", /*env_do_fsync=*/true) {}
 };

 class DBBloomFilterTestWithParam : public DBTestBase,
@@ -43,7 +42,7 @@ class DBBloomFilterTestWithParam : public DBTestBase,

 public:
  DBBloomFilterTestWithParam()
-      : DBTestBase("db_bloom_filter_tests", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_bloom_filter_tests", /*env_do_fsync=*/true) {}

  ~DBBloomFilterTestWithParam() override {}

@@ -528,7 +527,7 @@ TEST_P(DBBloomFilterTestWithParam, BloomFilter) {
  } while (ChangeCompactOptions());
 }

-#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#ifndef ROCKSDB_VALGRIND_RUN
 INSTANTIATE_TEST_CASE_P(
    FormatDef, DBBloomFilterTestDefFormatVersion,
    ::testing::Values(
@@ -552,7 +551,7 @@ INSTANTIATE_TEST_CASE_P(
                        test::kLatestFormatVersion),
        std::make_tuple(BFP::kAutoBloom, true, test::kLatestFormatVersion),
        std::make_tuple(BFP::kAutoBloom, false, test::kLatestFormatVersion)));
-#endif  // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#endif  // ROCKSDB_VALGRIND_RUN

 TEST_F(DBBloomFilterTest, BloomFilterRate) {
  while (ChangeFilterOptions()) {
@@ -1095,7 +1094,7 @@ class DBBloomFilterTestVaryPrefixAndFormatVer

 public:
  DBBloomFilterTestVaryPrefixAndFormatVer()
-      : DBTestBase("db_bloom_filter_tests", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_bloom_filter_tests", /*env_do_fsync=*/true) {}

  ~DBBloomFilterTestVaryPrefixAndFormatVer() override {}

@@ -2172,8 +2171,7 @@ TEST_F(DBBloomFilterTest, SeekForPrevWithPartitionedFilters) {
  Options options = CurrentOptions();
  constexpr size_t kNumKeys = 10000;
  static_assert(kNumKeys <= 10000, "kNumKeys have to be <= 10000");
-  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(kNumKeys + 10));
+  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeys + 10));
  options.create_if_missing = true;
  constexpr size_t kPrefixLength = 4;
  options.prefix_extractor.reset(NewFixedPrefixTransform(kPrefixLength));
@@ -22,7 +22,7 @@ static std::string NEW_VALUE = "NewValue";
 class DBTestCompactionFilter : public DBTestBase {
 public:
  DBTestCompactionFilter()
-      : DBTestBase("db_compaction_filter_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_compaction_filter_test", /*env_do_fsync=*/true) {}
 };

 // Param variant of DBTestBase::ChangeCompactOptions
@@ -46,7 +46,7 @@ class DBTestCompactionFilterWithCompactParam
  }
 };

-#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#ifndef ROCKSDB_VALGRIND_RUN
 INSTANTIATE_TEST_CASE_P(
    CompactionFilterWithOption, DBTestCompactionFilterWithCompactParam,
    ::testing::Values(DBTestBase::OptionConfig::kDefault,
@@ -55,11 +55,11 @@ INSTANTIATE_TEST_CASE_P(
                      DBTestBase::OptionConfig::kLevelSubcompactions,
                      DBTestBase::OptionConfig::kUniversalSubcompactions));
 #else
-// Run fewer cases in non-full valgrind to save time.
+// Run fewer cases in valgrind
 INSTANTIATE_TEST_CASE_P(CompactionFilterWithOption,
                        DBTestCompactionFilterWithCompactParam,
                        ::testing::Values(DBTestBase::OptionConfig::kDefault));
-#endif  // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#endif  // ROCKSDB_VALGRIND_RUN

 class KeepFilter : public CompactionFilter {
 public:
@@ -19,7 +19,6 @@
 #include "rocksdb/sst_file_writer.h"
 #include "rocksdb/utilities/convenience.h"
 #include "test_util/sync_point.h"
-#include "test_util/testutil.h"
 #include "util/concurrent_task_limiter_impl.h"
 #include "util/random.h"
 #include "utilities/fault_injection_env.h"
@@ -33,7 +32,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBCompactionTest : public DBTestBase {
 public:
  DBCompactionTest()
-      : DBTestBase("db_compaction_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_compaction_test", /*env_do_fsync=*/true) {}
 };

 class DBCompactionTestWithParam
@@ -41,7 +40,7 @@ class DBCompactionTestWithParam
      public testing::WithParamInterface<std::tuple<uint32_t, bool>> {
 public:
  DBCompactionTestWithParam()
-      : DBTestBase("db_compaction_test", /*env_do_fsync=*/true) {
+      : DBTestBase("/db_compaction_test", /*env_do_fsync=*/true) {
    max_subcompactions_ = std::get<0>(GetParam());
    exclusive_manual_compaction_ = std::get<1>(GetParam());
  }
@@ -59,7 +58,7 @@ class DBCompactionTestWithBottommostParam
      public testing::WithParamInterface<BottommostLevelCompaction> {
 public:
  DBCompactionTestWithBottommostParam()
-      : DBTestBase("db_compaction_test", /*env_do_fsync=*/true) {
+      : DBTestBase("/db_compaction_test", /*env_do_fsync=*/true) {
    bottommost_level_compaction_ = GetParam();
  }

@@ -302,7 +301,7 @@ const SstFileMetaData* PickFileRandomly(
 }
 }  // anonymous namespace

-#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#ifndef ROCKSDB_VALGRIND_RUN
 // All the TEST_P tests run once with sub_compactions disabled (i.e.
 // options.max_subcompactions = 1) and once with it enabled
 TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
@@ -367,7 +366,7 @@ TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
    }
  }
 }
-#endif  // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
+#endif  // ROCKSDB_VALGRIND_RUN

 TEST_P(DBCompactionTestWithParam, CompactionsPreserveDeletes) {
  //  For each options type we test following
@@ -806,8 +805,7 @@ TEST_P(DBCompactionTestWithParam, CompactionTrigger) {
  options.num_levels = 3;
  options.level0_file_num_compaction_trigger = 3;
  options.max_subcompactions = max_subcompactions_;
-  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(kNumKeysPerFile));
+  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
  CreateAndReopenWithCF({"pikachu"}, options);

  Random rnd(301);
@@ -854,8 +852,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {
  options.level0_slowdown_writes_trigger = 20;
  options.soft_pending_compaction_bytes_limit = 1 << 30;  // Infinitely large
  options.max_background_compactions = 3;
-  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(kNumKeysPerFile));
+  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));

  // Block all threads in thread pool.
  const size_t kTotalTasks = 4;
@@ -2097,7 +2094,7 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionThirdPath) {
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
@@ -2206,7 +2203,7 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionPathUse) {
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
@@ -2316,7 +2313,7 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionCFPathUse) {
  options.db_paths.emplace_back(dbname_ + "_2", 4 * 1024 * 1024);
  options.db_paths.emplace_back(dbname_ + "_3", 1024 * 1024 * 1024);
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+    new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
@@ -2335,7 +2332,7 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionCFPathUse) {
  option_vector.emplace_back(DBOptions(options), cf_opt1);
  CreateColumnFamilies({"one"},option_vector[1]);

-  // Configure CF2 specific paths.
+  // Configura CF2 specific paths.
  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2", 500 * 1024);
  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_2", 4 * 1024 * 1024);
  cf_opt2.cf_paths.emplace_back(dbname_ + "cf2_3", 1024 * 1024 * 1024);
@@ -2390,16 +2387,13 @@ TEST_P(DBCompactionTestWithParam, LevelCompactionCFPathUse) {
  // Check that default column family uses db_paths.
  // And Column family "one" uses cf_paths.

-  // The compaction in level0 outputs the sst files in level1.
-  // The first path cannot hold level1's data(400KB+400KB > 500KB),
-  // so every compaction move a sst file to second path. Please
-  // refer to LevelCompactionBuilder::GetPathId.
+  // First three 110KB files are not going to second path.
+  // After that, (100K, 200K)
  for (int num = 0; num < 3; num++) {
    generate_file();
  }
-  check_sstfilecount(0, 1);
-  check_sstfilecount(1, 2);

+  // Another 110KB triggers a compaction to 400K file to fill up first path
  generate_file();
  check_sstfilecount(1, 3);

@@ -3015,7 +3009,7 @@ TEST_P(DBCompactionTestWithParam, CompressLevelCompaction) {
  }
  Options options = CurrentOptions();
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.compaction_style = kCompactionStyleLevel;
  options.write_buffer_size = 110 << 10;  // 110KB
  options.arena_block_size = 4 << 10;
@@ -3606,41 +3600,6 @@ TEST_F(DBCompactionTest, CompactFilesOverlapInL0Bug) {
  ASSERT_EQ("new_val", Get(Key(0)));
 }

-TEST_F(DBCompactionTest, DeleteFilesInRangeConflictWithCompaction) {
-  Options options = CurrentOptions();
-  DestroyAndReopen(options);
-  const Snapshot* snapshot = nullptr;
-  const int kMaxKey = 10;
-
-  for (int i = 0; i < kMaxKey; i++) {
-    ASSERT_OK(Put(Key(i), Key(i)));
-    ASSERT_OK(Delete(Key(i)));
-    if (!snapshot) {
-      snapshot = db_->GetSnapshot();
-    }
-  }
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-  ASSERT_OK(Put(Key(kMaxKey), Key(kMaxKey)));
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  // test DeleteFilesInRange() deletes the files already picked for compaction
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"VersionSet::LogAndApply:WriteManifestStart",
-        "BackgroundCallCompaction:0"},
-       {"DBImpl::BackgroundCompaction:Finish",
-        "VersionSet::LogAndApply:WriteManifestDone"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // release snapshot which mark bottommost file for compaction
-  db_->ReleaseSnapshot(snapshot);
-  std::string begin_string = Key(0);
-  std::string end_string = Key(kMaxKey + 1);
-  Slice begin(begin_string);
-  Slice end(end_string);
-  ASSERT_OK(DeleteFilesInRange(db_, db_->DefaultColumnFamily(), &begin, &end));
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBCompactionTest, CompactBottomLevelFilesWithDeletions) {
  // bottom-level files may contain deletions due to snapshots protecting the
  // deleted keys. Once the snapshot is released, we should see files with many
@@ -4818,8 +4777,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
  options.level0_slowdown_writes_trigger = 64;
  options.level0_stop_writes_trigger = 64;
  options.max_background_jobs = kMaxBackgroundThreads; // Enough threads
-  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(kNumKeysPerFile));
+  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
  options.max_write_buffer_number = 10; // Enough memtables
  DestroyAndReopen(options);

@@ -5012,7 +4970,7 @@ class CompactionPriTest : public DBTestBase,
                          public testing::WithParamInterface<uint32_t> {
 public:
  CompactionPriTest()
-      : DBTestBase("compaction_pri_test", /*env_do_fsync=*/true) {
+      : DBTestBase("/compaction_pri_test", /*env_do_fsync=*/true) {
    compaction_pri_ = GetParam();
  }

@@ -5250,12 +5208,11 @@ TEST_F(DBCompactionTest, ManualCompactionMax) {
  ASSERT_TRUE(num_compactions.load() == 1);

  // split the compaction to 5
+  uint64_t total = (l1_avg_size * 10) + (l2_avg_size * 100);
  int num_split = 5;
+  opts.max_compaction_bytes = total / num_split;
  DestroyAndReopen(opts);
  generate_sst_func();
-  uint64_t total_size = (l1_avg_size * 10) + (l2_avg_size * 100);
-  opts.max_compaction_bytes = total_size / num_split;
-  Reopen(opts);
  num_compactions.store(0);
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
  ASSERT_TRUE(num_compactions.load() == num_split);
@@ -5273,9 +5230,8 @@ TEST_F(DBCompactionTest, ManualCompactionMax) {
  opts.max_compaction_bytes = 0;
  DestroyAndReopen(opts);
  generate_sst_func();
-  total_size = (l1_avg_size * 10) + (l2_avg_size * 100);
  Status s = db_->SetOptions(
-      {{"max_compaction_bytes", std::to_string(total_size / num_split)}});
+      {{"max_compaction_bytes", std::to_string(total / num_split)}});
  ASSERT_OK(s);

  num_compactions.store(0);
@@ -5342,8 +5298,7 @@ TEST_P(DBCompactionTestWithParam, FixFileIngestionCompactionDeadlock) {
  options.level0_file_num_compaction_trigger =
      options.level0_stop_writes_trigger;
  options.max_subcompactions = max_subcompactions_;
-  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(kNumKeysPerFile));
+  options.memtable_factory.reset(new SpecialSkipListFactory(kNumKeysPerFile));
  DestroyAndReopen(options);
  Random rnd(301);

@@ -5869,7 +5824,7 @@ TEST_F(DBCompactionTest, ChangeLevelCompactRangeConflictsWithManual) {
  // `Status::Incomplete`.
  Options options = CurrentOptions();
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 3;
  Reopen(options);
@@ -5957,7 +5912,7 @@ TEST_F(DBCompactionTest, ChangeLevelErrorPathTest) {
  // succeeds
  Options options = CurrentOptions();
  options.memtable_factory.reset(
-      test::NewSpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
+      new SpecialSkipListFactory(KNumKeysByGenerateNewFile - 1));
  options.level0_file_num_compaction_trigger = 2;
  options.num_levels = 3;
  Reopen(options);
@@ -6754,112 +6709,6 @@ TEST_F(DBCompactionTest, CompactionWithChecksumHandoffManifest2) {
  Destroy(options);
 }

-TEST_F(DBCompactionTest, FIFOWarm) {
-  Options options = CurrentOptions();
-  options.compaction_style = kCompactionStyleFIFO;
-  options.num_levels = 1;
-  options.max_open_files = -1;
-  options.level0_file_num_compaction_trigger = 2;
-  options.create_if_missing = true;
-  CompactionOptionsFIFO fifo_options;
-  fifo_options.age_for_warm = 1000;
-  fifo_options.max_table_files_size = 100000000;
-  options.compaction_options_fifo = fifo_options;
-  env_->SetMockSleep();
-  Reopen(options);
-
-  int total_warm = 0;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "NewWritableFile::FileOptions.temperature", [&](void* arg) {
-        Temperature temperature = *(static_cast<Temperature*>(arg));
-        if (temperature == Temperature::kWarm) {
-          total_warm++;
-        }
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  // The file system does not support checksum handoff. The check
-  // will be ignored.
-  ASSERT_OK(Put(Key(0), "value1"));
-  env_->MockSleepForSeconds(800);
-  ASSERT_OK(Put(Key(2), "value2"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(Key(0), "value1"));
-  env_->MockSleepForSeconds(800);
-  ASSERT_OK(Put(Key(2), "value2"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(Put(Key(0), "value1"));
-  env_->MockSleepForSeconds(800);
-  ASSERT_OK(Put(Key(2), "value2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ASSERT_OK(Put(Key(0), "value1"));
-  env_->MockSleepForSeconds(800);
-  ASSERT_OK(Put(Key(2), "value2"));
-  ASSERT_OK(Flush());
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-
-  ColumnFamilyMetaData metadata;
-  db_->GetColumnFamilyMetaData(&metadata);
-  ASSERT_EQ(4, metadata.file_count);
-  ASSERT_EQ(Temperature::kUnknown, metadata.levels[0].files[0].temperature);
-  ASSERT_EQ(Temperature::kUnknown, metadata.levels[0].files[1].temperature);
-  ASSERT_EQ(Temperature::kWarm, metadata.levels[0].files[2].temperature);
-  ASSERT_EQ(Temperature::kWarm, metadata.levels[0].files[3].temperature);
-  ASSERT_EQ(2, total_warm);
-
-  Destroy(options);
-}
-
-TEST_F(DBCompactionTest,
-       DisableManualCompactionDoesNotWaitForDrainingAutomaticCompaction) {
-  // When `CompactRangeOptions::exclusive_manual_compaction == true`, we wait
-  // for automatic compactions to drain before starting the manual compaction.
-  // This test verifies `DisableManualCompaction()` can cancel such a compaction
-  // without waiting for the drain to complete.
-  const int kNumL0Files = 4;
-
-  // Enforces manual compaction enters wait loop due to pending automatic
-  // compaction.
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::BGWorkCompaction", "DBImpl::RunManualCompaction:NotScheduled"},
-       {"DBImpl::RunManualCompaction:WaitScheduled",
-        "BackgroundCallCompaction:0"}});
-  // The automatic compaction will cancel the waiting manual compaction.
-  // Completing this implies the cancellation did not wait on automatic
-  // compactions to finish.
-  bool callback_completed = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "BackgroundCallCompaction:0", [&](void* /*arg*/) {
-        db_->DisableManualCompaction();
-        callback_completed = true;
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-
-  Options options = CurrentOptions();
-  options.level0_file_num_compaction_trigger = kNumL0Files;
-  Reopen(options);
-
-  for (int i = 0; i < kNumL0Files; ++i) {
-    ASSERT_OK(Put(Key(1), "value1"));
-    ASSERT_OK(Put(Key(2), "value2"));
-    ASSERT_OK(Flush());
-  }
-
-  CompactRangeOptions cro;
-  cro.exclusive_manual_compaction = true;
-  ASSERT_TRUE(db_->CompactRange(cro, nullptr, nullptr).IsIncomplete());
-
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  ASSERT_TRUE(callback_completed);
-}
-
 #endif  // !defined(ROCKSDB_LITE)

 }  // namespace ROCKSDB_NAMESPACE
@@ -22,7 +22,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBTestDynamicLevel : public DBTestBase {
 public:
  DBTestDynamicLevel()
-      : DBTestBase("db_dynamic_level_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_dynamic_level_test", /*env_do_fsync=*/true) {}
 };

 TEST_F(DBTestDynamicLevel, DynamicLevelMaxBytesBase) {
@@ -17,7 +17,7 @@ namespace ROCKSDB_NAMESPACE {
 class DBEncryptionTest : public DBTestBase {
 public:
  DBEncryptionTest()
-      : DBTestBase("db_encryption_test", /*env_do_fsync=*/true) {}
+      : DBTestBase("/db_encryption_test", /*env_do_fsync=*/true) {}
  Env* GetTargetEnv() {
    if (encrypted_env_ != nullptr) {
      return (static_cast<EnvWrapper*>(encrypted_env_))->target();
@@ -127,22 +127,7 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
      bg_cv_.Wait();
    }
  }
-
-  // Disable deletion in order to avoid the case where a file is deleted in
-  // the middle of the process so IO error is returned.
-  Status s = DisableFileDeletions();
-  bool file_deletion_supported = !s.IsNotSupported();
-  if (s.ok() || !file_deletion_supported) {
-    s = wal_manager_.GetSortedWalFiles(files);
-    if (file_deletion_supported) {
-      Status s2 = EnableFileDeletions(false);
-      if (!s2.ok() && s.ok()) {
-        s = s2;
-      }
-    }
-  }
-
-  return s;
+  return wal_manager_.GetSortedWalFiles(files);
 }

 Status DBImpl::GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) {
Author	SHA1	Message	Date
Peter Dillinger	623774b6b5	Update version and HISTORY for 6.21.3	2021-07-19 08:30:36 -07:00
Peter Dillinger	d25f018223	Don't hold DB mutex for block cache entry stat scans (#8538 ) Summary: I previously didn't notice the DB mutex was being held during block cache entry stat scans, probably because I primarily checked for read performance regressions, because they require the block cache and are traditionally latency-sensitive. This change does some refactoring to avoid holding DB mutex and to avoid triggering and waiting for a scan in GetProperty("rocksdb.cfstats"). Some tests have to be updated because now the stats collector is populated in the Cache aggressively on DB startup rather than lazily. (I hope to clean up some of this added complexity in the future.) This change also ensures proper treatment of need_out_of_mutex for non-int DB properties. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8538 Test Plan: Added unit test logic that uses sync points to fail if the DB mutex is held during a scan, covering the various ways that a scan might be triggered. Performance test - the known impact to holding the DB mutex is on TransactionDB, and the easiest way to see the impact is to hack the scan code to almost always miss and take an artificially long time scanning. Here I've injected an unconditional 5s sleep at the call to ApplyToAllEntries. Before (hacked): $ TEST_TMPDIR=/dev/shm ./db_bench.base_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 433.219 micros/op 2308 ops/sec; 0.1 MB/s ( transactions:78999 aborts:0) rocksdb.db.write.micros P50 : 16.135883 P95 : 36.622503 P99 : 66.036115 P100 : 5000614.000000 COUNT : 149677 SUM : 8364856 $ TEST_TMPDIR=/dev/shm ./db_bench.base_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 448.802 micros/op 2228 ops/sec; 0.1 MB/s ( transactions:75999 aborts:0) rocksdb.db.write.micros P50 : 16.629221 P95 : 37.320607 P99 : 72.144341 P100 : 5000871.000000 COUNT : 143995 SUM : 13472323 Notice the 5s P100 write time. After (hacked): $ TEST_TMPDIR=/dev/shm ./db_bench.new_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 303.645 micros/op 3293 ops/sec; 0.1 MB/s ( transactions:98999 aborts:0) rocksdb.db.write.micros P50 : 16.061871 P95 : 33.978834 P99 : 60.018017 P100 : 616315.000000 COUNT : 187619 SUM : 4097407 $ TEST_TMPDIR=/dev/shm ./db_bench.new_xxx -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 310.383 micros/op 3221 ops/sec; 0.1 MB/s ( transactions:96999 aborts:0) rocksdb.db.write.micros P50 : 16.270026 P95 : 35.786844 P99 : 64.302878 P100 : 603088.000000 COUNT : 183819 SUM : 4095918 P100 write is now ~0.6s. Not good, but it's the same even if I completely bypass all the scanning code: $ TEST_TMPDIR=/dev/shm ./db_bench.new_skip -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 311.365 micros/op 3211 ops/sec; 0.1 MB/s ( transactions:96999 aborts:0) rocksdb.db.write.micros P50 : 16.274362 P95 : 36.221184 P99 : 68.809783 P100 : 649808.000000 COUNT : 183819 SUM : 4156767 $ TEST_TMPDIR=/dev/shm ./db_bench.new_skip -benchmarks=randomtransaction,stats -cache_index_and_filter_blocks=1 -bloom_bits=10 -partition_index_and_filters=1 -duration=30 -stats_dump_period_sec=12 -cache_size=100000000 -statistics -transaction_db 2>&1 \| egrep 'db.db.write.micros\|micros/op' randomtransaction : 308.395 micros/op 3242 ops/sec; 0.1 MB/s ( transactions:97999 aborts:0) rocksdb.db.write.micros P50 : 16.106222 P95 : 37.202403 P99 : 67.081875 P100 : 598091.000000 COUNT : 185714 SUM : 4098832 No substantial difference. Reviewed By: siying Differential Revision: D29738847 Pulled By: pdillinger fbshipit-source-id: 1c5c155f5a1b62e4fea0fd4eeb515a8b7474027b	2021-07-19 08:26:18 -07:00
Peter Dillinger	61b95f999a	Fix double-dumping CF stats to log (#8380 ) Summary: DBImpl::DumpStats is supposed to do this: Dump DB stats to LOG For each CF, dump CFStatsNoFileHistogram to LOG For each CF, dump CFFileHistogram to LOG Instead, due to a longstanding bug from 2017 (https://github.com/facebook/rocksdb/issues/2126), it would dump CFStats, which includes both CFStatsNoFileHistogram and CFFileHistogram, in both loops, resulting in near-duplicate output. This fixes the bug. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8380 Test Plan: Manual inspection of LOG after db_bench Reviewed By: jay-zhuang Differential Revision: D29017535 Pulled By: pdillinger fbshipit-source-id: 3010604c4a629a80347f129cd746ce9b0d0cbda6	2021-07-19 08:09:13 -07:00
Peter Dillinger	c58a32b30d	Standardize on GCC for TSAN conditional compilation (#8543 ) Summary: In https://github.com/facebook/rocksdb/issues/8539 I accidentally only checked for GCC TSAN, which is what I tested locally, while CircleCI and FB CI use clang TSAN. Related: other existing code like in stack_trace.cc only check for clang TSAN. I've now standardized these to the GCC convention in port/lang.h, so now #ifdef __SANITIZE_THREAD__ can check for any TSAN (assuming lang.h include) Pull Request resolved: https://github.com/facebook/rocksdb/pull/8543 Test Plan: Put an assert(false) in slice_test and look for the NOTE about "signal-unsafe call", both GCC and clang. Eventually, CircleCI TSAN in https://github.com/facebook/rocksdb/issues/8538 Reviewed By: zhichao-cao Differential Revision: D29728483 Pulled By: pdillinger fbshipit-source-id: 8a3b8015c2ed48078214c3ee17146a2c3f11c9f7	2021-07-19 08:05:40 -07:00
Peter Dillinger	7c70ceed14	Work around falsely reported data race on LRUHandle::flags (#8539 ) Summary: Some bits are mutated and read while holding a lock, other immutable bits (esp. secondary cache compatibility) can be read by arbitrary threads without holding a lock. AFAIK, this doesn't cause an issue on any architecture we care about, because you will get some legitimate version of the value that includes the initialization, as long as synchronization guarantees the initialization happens before the read. I've only seen this in https://github.com/facebook/rocksdb/issues/8538 so far, but it should be fixed regardless. Otherwise, we'll surely get these false reports again some time. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8539 Test Plan: some local TSAN test runs and in CircleCI Reviewed By: zhichao-cao Differential Revision: D29720262 Pulled By: pdillinger fbshipit-source-id: 365fd7e565577c648815161f71b339bcb5ce12d5	2021-07-19 08:05:27 -07:00
Peter Dillinger	392d72739a	Update version and HISTORY for 6.21.2	2021-06-14 15:17:14 -07:00
Peter Dillinger	95168f3514	Pin CacheEntryStatsCollector to fix performance bug (#8385 ) Summary: If the block Cache is full with strict_capacity_limit=false, then our CacheEntryStatsCollector could be immediately evicted on release, so iterating through column families with shared block cache could trigger re-scan for each CF. This change fixes that problem by pinning the CacheEntryStatsCollector from InternalStats so that it's not evicted. I had originally thought that this object could participate in LRU like everything else, but even though a re-load+re-scan only touches memory, it can be orders of magnitude more expensive than other cache misses. One service in Facebook has scans that take ~20s over 100GB block cache that is mostly 4KB entries. (The up-side of this bug and https://github.com/facebook/rocksdb/issues/8369 is that we had a natural experiment on the effect on some service metrics even with block cache scans running continuously in the background--a kind of worst case scenario. Metrics like latency were not affected enough to trigger warnings.) Other smaller fixes: 20s is already a sizable portion of 600s stats dump period, or 180s default max age to force re-scan, so added logic to ensure that (for each block cache) we don't spend more than 0.2% of our background thread time scanning it. Nevertheless, "foreground" requests for cache entry stats (calls to `db->GetMapProperty(DB::Properties::kBlockCacheEntryStats)`) are permitted to consume more CPU. Renamed field to cache_entry_stats_ to match code style. This change is intended for patching in 6.21 release. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8385 Test Plan: unit test expanded to cover new logic (detect regression), some manual testing with db_bench Reviewed By: ajkr Differential Revision: D29042759 Pulled By: pdillinger fbshipit-source-id: 236faa902397f50038c618f50fbc8cf3f277308c	2021-06-14 15:06:50 -07:00
Peter Dillinger	b47bbbf768	Fix runtime linkage with libasan in Facebook platform009 (#8402 ) Summary: Was seeing ./cache_test: error while loading shared libraries: libasan.so.5: cannot open shared object file: No such file or directory etc. using COMPILE_WITH_ASAN=1 without USE_CLANG=1 Now including compiler libs in runtime ld path. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8402 Test Plan: reproduced with local builds Reviewed By: akankshamahajan15 Differential Revision: D29107729 Pulled By: pdillinger fbshipit-source-id: 13805b87b846b39522c9dd6a231ca245c58f1c71	2021-06-14 15:06:32 -07:00
Peter Dillinger	ba98c17de6	Fix^2 use of binutils in Facebook platform009 (#8399 ) (#8401 ) Summary: Internal builds still failing, this time with ld Pull Request resolved: https://github.com/facebook/rocksdb/pull/8401 Test Plan: Like https://github.com/facebook/rocksdb/issues/8399 but letting build run to completion Reviewed By: bjlemaire Differential Revision: D29103512 Pulled By: pdillinger fbshipit-source-id: 0fcad2c63518cf2b721e749881da40b90f5d3133	2021-06-14 15:06:14 -07:00
Peter Dillinger	8a33ede20f	Fix use of binutils in Facebook platform009 (#8399 ) Summary: Internal builds failing Pull Request resolved: https://github.com/facebook/rocksdb/pull/8399 Test Plan: I can reproduce a failure by putting a bad version of `as` in my PATH. This indicates that before this change, the custom compiler is falsely relying on host `as`. This change fixes that, ignoring the bad `as` on PATH. Reviewed By: akankshamahajan15 Differential Revision: D29094159 Pulled By: pdillinger fbshipit-source-id: c432e90404ea4d39d885a685eebbb08be9eda1c8	2021-06-14 15:05:59 -07:00
Peter Dillinger	5023dc5991	Make platform009 default for FB developers (#8389 ) Summary: platform007 being phased out and sometimes broken Pull Request resolved: https://github.com/facebook/rocksdb/pull/8389 Test Plan: `make V=1` to see which compiler is being used Reviewed By: jay-zhuang Differential Revision: D29067183 Pulled By: pdillinger fbshipit-source-id: d1b07267cbc55baa9395f2f4fe3967cc6dad52f7	2021-06-11 11:37:48 -07:00
Stepan Koltsov	bfb9496af0	Modify script which generates TARGETS (#8366 ) Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/8366 Test Plan: Run it, `TARGETS` now unchanged. Reviewed By: jay-zhuang Differential Revision: D28914138 Pulled By: stepancheg fbshipit-source-id: 04d24cdf1439edf4204a3ba1f646e9e75a00d92b	2021-06-08 10:04:33 -07:00
Stiopa Koltsov	d216050bd4	Enable Starlark for fbcode//i* Summary: #forcetdhashing Reviewed By: ndmitchell Differential Revision: D28873060 fbshipit-source-id: 7d3be3e7d38619ec5b0b117f462ca1b9f427aa94	2021-06-08 10:04:22 -07:00
Peter Dillinger	8c2f72a440	Update version and HISTORY for 6.21.1	2021-06-08 08:56:21 -07:00
Peter Dillinger	229640f88d	Fix a major performance bug in 6.21 for cache entry stats (#8369 ) Summary: In final polishing of https://github.com/facebook/rocksdb/issues/8297 (after most manual testing), I broke my own caching layer by sanitizing an input parameter with std::min(0, x) instead of std::max(0, x). I resisted unit testing the timing part of the result caching because historically, these test are either flaky or difficult to write, and this was not a correctness issue. This bug is essentially unnoticeable with a small number of column families but can explode background work with a large number of column families. This change fixes the logical error, removes some unnecessary related optimization, and adds mock time/sleeps to the unit test to ensure we can cache hit within the age limit. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8369 Test Plan: added time testing logic to existing unit test Reviewed By: ajkr Differential Revision: D28950892 Pulled By: pdillinger fbshipit-source-id: e79cd4ff3eec68fd0119d994f1ed468c38026c3b	2021-06-08 08:53:02 -07:00
sdong	c7f8ae9f17	SequenceIterWrapper should use internal comparator (#8328 ) Summary: https://github.com/facebook/rocksdb/pull/8288 introduces a bug: SequenceIterWrapper should do next for seek key using internal key comparator rather than user comparator. Fix it. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8328 Test Plan: Pass all existing tests Reviewed By: ltamasi Differential Revision: D28647263 fbshipit-source-id: 4081d684fd8a86d248c485ef8a1563c7af136447	2021-05-24 13:15:22 -07:00
Zhichao Cao	5d44932358	fix lru caching test and fix reference binding to null pointer (#8326 ) Summary: Fix for https://github.com/facebook/rocksdb/issues/8315. Inhe lru caching test, 5100 is not enough to hold meta block and first block in some random case, increase to 6100. Fix the reference binding to null pointer, use template. Pull Request resolved: https://github.com/facebook/rocksdb/pull/8326 Test Plan: make check Reviewed By: pdillinger Differential Revision: D28625666 Pulled By: zhichao-cao fbshipit-source-id: 97b85306ae3d09bfb74addc7c65e57fe55a976a5	2021-05-24 11:04:54 -07:00
anand76	436e4f1e4d	Update version and HISTORY.md	2021-05-21 22:37:18 -07:00