Bump up version to 7.5.4

Summary:
During compaction, blobs are currently read using the default
`ReadOptions`, which has the `fill_cache` flag set to true. Earlier,
this didn't make any difference since we didn't have a blob cache;
however, now we have to explicitly set this flag to false to avoid
polluting the cache during compaction.

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

Test Plan: `make check`

Reviewed By: riversand963

Differential Revision: D38333528

Pulled By: ltamasi

fbshipit-source-id: 5b4d49a1e39543bee73c7df2aa9194fb101875e2

.circleci/config.yml

@@ -3,6 +3,11 @@ version: 2.1
 orbs:
   win: circleci/windows@2.4.0
 
+aliases:
+  - &notify-on-main-failure
+    fail_only: true
+    only_for_branches: main
+
 commands:
   install-cmake-on-macos:
     steps:
@@ -56,21 +61,61 @@ commands:
       - store_artifacts: # store LOG for debugging if there's any
           path: LOG
       - run: # on fail, compress Test Logs for diagnosing the issue
-          name: Compress Test Logs
-          command: tar -cvzf t.tar.gz t
-          when: on_fail
+         name: Compress Test Logs
+         command: tar -cvzf t.tar.gz t
+         when: on_fail
       - store_artifacts: # on fail, store Test Logs for diagnosing the issue
           path: t.tar.gz
           destination: test_logs
           when: on_fail
-      - run: # store core dumps if there's any
+
+  install-clang-10:
+    steps:
+      - run:
+          name: Install Clang 10
           command: |
-            mkdir -p /tmp/core_dumps
-            cp core.* /tmp/core_dumps
-          when: on_fail
-      - store_artifacts:
-          path: /tmp/core_dumps
-          when: on_fail
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+            echo "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-10 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb-src http://apt.llvm.org/focal/ llvm-toolchain-focal-10 main" | sudo tee -a /etc/apt/sources.list
+            echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+            sudo apt-get update -y && sudo apt-get install -y clang-10
+
+  install-clang-13:
+    steps:
+      - run:
+          name: Install Clang 13
+          command: |
+            echo "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb-src http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main" | sudo tee -a /etc/apt/sources.list
+            echo "APT::Acquire::Retries \"10\";" | sudo tee -a /etc/apt/apt.conf.d/80-retries # llvm.org unreliable
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+            sudo apt-get update -y && sudo apt-get install -y clang-13
+
+  install-gflags:
+    steps:
+      - run:
+          name: Install gflags
+          command: |
+            sudo apt-get update -y && sudo apt-get install -y libgflags-dev
+
+  install-benchmark:
+    steps:
+      - run:
+          name: Install ninja build
+          command: sudo apt-get update -y && sudo apt-get install -y ninja-build
+      - run:
+          name: Install benchmark
+          command: |
+            git clone --depth 1 --branch v1.6.1 https://github.com/google/benchmark.git ~/benchmark
+            cd ~/benchmark && mkdir build && cd build
+            cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release -DBENCHMARK_ENABLE_GTEST_TESTS=0
+            ninja && sudo ninja install
+
+  install-valgrind:
+    steps:
+      - run:
+          name: Install valgrind
+          command: sudo apt-get update -y && sudo apt-get install -y valgrind
 
   upgrade-cmake:
     steps:
@@ -80,13 +125,6 @@ commands:
             sudo apt remove --purge cmake
             sudo snap install cmake --classic
 
-  install-gflags:
-    steps:
-      - run:
-          name: Install gflags
-          command: |
-            sudo apt-get update -y && sudo apt-get install -y libgflags-dev
-
   install-gflags-on-macos:
     steps:
       - run:
@@ -94,20 +132,53 @@ commands:
           command: |
             HOMEBREW_NO_AUTO_UPDATE=1 brew install gflags
 
+  install-gtest-parallel:
+    steps:
+      - run:
+          name: Install gtest-parallel
+          command: |
+            git clone --single-branch --branch master --depth 1 https://github.com/google/gtest-parallel.git ~/gtest-parallel
+            echo 'export PATH=$HOME/gtest-parallel:$PATH' >> $BASH_ENV
+
+  install-compression-libs:
+    steps:
+      - run:
+          name: Install compression libs
+          command: |
+            sudo apt-get update -y && sudo apt-get install -y libsnappy-dev zlib1g-dev libbz2-dev liblz4-dev libzstd-dev
+
+  install-streaming-compress-libs:
+    steps:
+      - run:
+          name: Install streaming compression libs
+          command: |
+            sudo apt-get update -y && sudo apt-get install -y libzstd-dev
+
+  install-libprotobuf-mutator:
+    steps:
+      - run:
+          name: Install libprotobuf-mutator libs
+          command: |
+            git clone -b v1.0 git@github.com:google/libprotobuf-mutator.git ~/libprotobuf-mutator
+            cd ~/libprotobuf-mutator && git checkout ffd86a32874e5c08a143019aad1aaf0907294c9f && mkdir build && cd build
+            cmake .. -GNinja -DCMAKE_C_COMPILER=clang-13 -DCMAKE_CXX_COMPILER=clang++-13 -DCMAKE_BUILD_TYPE=Release -DLIB_PROTO_MUTATOR_DOWNLOAD_PROTOBUF=ON
+            ninja && sudo ninja install
+      - run:
+          name: Setup environment variables
+          command: |
+            echo "export PKG_CONFIG_PATH=/usr/local/OFF/:~/libprotobuf-mutator/build/external.protobuf/lib/pkgconfig/" >> $BASH_ENV
+            echo "export PROTOC_BIN=~/libprotobuf-mutator/build/external.protobuf/bin/protoc" >> $BASH_ENV
   setup-folly:
     steps:
+      - run:
+          name: Install folly dependencies
+          command: |
+            sudo apt-get install libgoogle-glog-dev
       - run:
           name: Checkout folly sources
           command: |
             make checkout_folly
 
-  build-folly:
-    steps:
-      - run:
-          name: Build folly and dependencies
-          command: |
-            make build_folly
-
   build-for-benchmarks:
     steps:
       - pre-steps
@@ -119,26 +190,14 @@ commands:
   perform-benchmarks:
     steps:
       - run:
-          name: "Test low-variance benchmarks"
-          command: ./tools/benchmark_ci.py --db_dir /tmp/rocksdb-benchmark-datadir --output_dir /tmp/benchmark-results --num_keys 50000
+          name: "Run basic benchmark, 5 min"
+          command: ./tools/benchmark.sh fillseq_enable_wal
           environment:
             LD_LIBRARY_PATH: /usr/local/lib
-            # How long to run parts of the test(s)
-            DURATION_RO: 400
-            DURATION_RW: 700
-            # Keep threads within physical capacity of server (much lower than default)
-            NUM_THREADS: 1
-            MAX_BACKGROUND_JOBS: 3
-            # Don't run a couple of "optional" initial tests
-            CI_TESTS_ONLY: "true"
-            # Reduce configured size of levels to ensure more levels in the leveled compaction LSM tree
-            WRITE_BUFFER_SIZE_MB: 16
-            TARGET_FILE_SIZE_BASE_MB: 16
-            MAX_BYTES_FOR_LEVEL_BASE_MB: 64
-            # The benchmark host has 32GB memory
-            # The following values are tailored to work with that
-            # Note, tests may not exercise the targeted issues if the memory is increased on new test hosts.
-
+            DB_DIR: /tmp/rocksdb-benchmark-datadir
+            WAL_DIR: /tmp/rocksdb-benchmark-waldir
+            OUTPUT_DIR: /tmp/benchmark-results
+            NUM_KEYS: 10000000
 
   post-benchmarks:
     steps:
@@ -150,7 +209,7 @@ commands:
           command: |
             set +e
             set +o pipefail
-            ./build_tools/benchmark_log_tool.py --tsvfile /tmp/benchmark-results/report.tsv --esdocument https://search-rocksdb-bench-k2izhptfeap2hjfxteolsgsynm.us-west-2.es.amazonaws.com/bench_test3_rix/_doc
+            ./build_tools/benchmark_log_tool.py --tsvfile /tmp/benchmark-results/report.tsv --esdocument https://search-rocksdb-bench-k2izhptfeap2hjfxteolsgsynm.us-west-2.es.amazonaws.com/bench_test3/_doc
             true
 
 executors:
@@ -159,21 +218,6 @@ executors:
       image: 'windows-server-2019-vs2019:stable'
       resource_class: windows.2xlarge
       shell: bash.exe
-  linux-docker:
-    docker:
-      # The image configuration is build_tools/ubuntu20_image/Dockerfile
-      # To update and build the image:
-      #  $ cd build_tools/ubuntu20_image
-      #  $ docker build -t zjay437/rocksdb:0.5 .
-      #  $ docker push zjay437/rocksdb:0.5
-      # `zjay437` is the account name for zjay@meta.com which readwrite token is shared internally. To login:
-      #  $ docker login --username zjay437
-      # Or please feel free to change it to your docker hub account for hosting the image, meta employee should already have the account and able to login with SSO.
-      # To avoid impacting the existing CI runs, please bump the version every time creating a new image
-      # to run the CI image environment locally:
-      #  $ docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -it zjay437/rocksdb:0.5 bash
-      # option `--cap-add=SYS_PTRACE --security-opt seccomp=unconfined` is used to enable gdb to attach an existing process
-      - image: zjay437/rocksdb:0.6
 
 jobs:
   build-macos:
@@ -225,132 +269,172 @@ jobs:
       - post-steps
 
   build-linux:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-streaming-compress-libs
       - run: make V=1 J=32 -j32 check
       - post-steps
 
   build-linux-encrypted_env-no_compression:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
       - run: ENCRYPTED_ENV=1 ROCKSDB_DISABLE_SNAPPY=1 ROCKSDB_DISABLE_ZLIB=1 ROCKSDB_DISABLE_BZIP=1 ROCKSDB_DISABLE_LZ4=1 ROCKSDB_DISABLE_ZSTD=1 make V=1 J=32 -j32 check
       - run: |
           ./sst_dump --help | egrep -q 'Supported compression types: kNoCompression$' # Verify no compiled in compression
       - post-steps
 
   build-linux-shared_lib-alt_namespace-status_checked:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
       - run: ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 ROCKSDB_MODIFY_NPHASH=1 LIB_MODE=shared OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" make V=1 -j32 check
       - post-steps
 
   build-linux-release:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - checkout # check out the code in the project directory
       - run: make V=1 -j32 release
-      - run: ./db_stress --version # ensure with gflags
-      - run: make clean
-      - run: apt-get remove -y libgflags-dev
-      - run: make V=1 -j32 release
       - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
+      - install-gflags
+      - run: make V=1 -j32 release
+      - run: ./db_stress --version # ensure with gflags
       - post-steps
 
   build-linux-release-rtti:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: xlarge
     steps:
       - checkout # check out the code in the project directory
-      - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
-      - run: ./db_stress --version # ensure with gflags
       - run: make clean
-      - run: apt-get remove -y libgflags-dev
       - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
       - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
+      - run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
+      - run: make clean
+      - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
+      - run: ./db_stress --version # ensure with gflags
 
   build-linux-lite:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - pre-steps
+      - install-gflags
       - run: LITE=1 make V=1 J=8 -j8 check
       - post-steps
 
   build-linux-lite-release:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - checkout # check out the code in the project directory
       - run: LITE=1 make V=1 -j8 release
-      - run: ./db_stress --version # ensure with gflags
-      - run: make clean
-      - run: apt-get remove -y libgflags-dev
-      - run: LITE=1 make V=1 -j8 release
       - run: if ./db_stress --version; then false; else true; fi # ensure without gflags
+      - install-gflags
+      - run: LITE=1 make V=1 -j8 release
+      - run: ./db_stress --version # ensure with gflags
       - post-steps
 
   build-linux-clang-no_test_run:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: xlarge
     steps:
       - checkout # check out the code in the project directory
+      - run: sudo apt-get update -y && sudo apt-get install -y clang libgflags-dev libtbb-dev
       - run: CC=clang CXX=clang++ USE_CLANG=1 PORTABLE=1 make V=1 -j16 all
       - post-steps
 
   build-linux-clang10-asan:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-clang-10
       - run: COMPILE_WITH_ASAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check # aligned new doesn't work for reason we haven't figured out
       - post-steps
 
   build-linux-clang10-mini-tsan:
-    executor: linux-docker
-    resource_class: 2xlarge+
+    machine:
+      image: ubuntu-2004:202111-02
+    resource_class: 2xlarge
+    # find test list by `make list_all_tests`
+    parameters:
+      start_test:
+        default: ""
+        type: string
+      end_test:
+        default: ""
+        type: string
     steps:
       - pre-steps
-      - run: COMPILE_WITH_TSAN=1 CC=clang-13 CXX=clang++-13 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check
+      - install-gflags
+      - install-clang-10
+      - install-gtest-parallel
+      - run:
+          name: "Build unit tests"
+          command: |
+            echo "env: $(env)"
+            ROCKSDBTESTS_START=<<parameters.start_test>> ROCKSDBTESTS_END=<<parameters.end_test>> ROCKSDBTESTS_SUBSET_TESTS_TO_FILE=/tmp/test_list COMPILE_WITH_TSAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 --output-sync=target build_subset_tests
+      - run:
+          name: "Run unit tests in parallel"
+          command: |
+            sed -i 's/[[:space:]]*$//; s/ / \.\//g; s/.*/.\/&/' /tmp/test_list
+            cat /tmp/test_list
+            gtest-parallel $(</tmp/test_list) --output_dir=/tmp | cat  # pipe to cat to continuously output status on circleci UI. Otherwise, no status will be printed while the job is running.
       - post-steps
 
   build-linux-clang10-ubsan:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-clang-10
       - run: COMPILE_WITH_UBSAN=1 OPT="-fsanitize-blacklist=.circleci/ubsan_suppression_list.txt" CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 ubsan_check # aligned new doesn't work for reason we haven't figured out
       - post-steps
 
   build-linux-valgrind:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-valgrind
       - run: PORTABLE=1 make V=1 -j32 valgrind_test
       - post-steps
 
   build-linux-clang10-clang-analyze:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-clang-10
+      - run: sudo apt-get update -y && sudo apt-get install -y clang-tools-10
       - 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 # 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
-      - run:
-          name: "compress test report"
-          command: tar -cvzf scan_build_report.tar.gz scan_build_report
-          when: on_fail
-      - store_artifacts:
-          path: scan_build_report.tar.gz
-          destination: scan_build_report
-          when: on_fail
 
   build-linux-runner:
     machine: true
@@ -365,30 +449,26 @@ jobs:
       - post-steps
 
   build-linux-cmake-with-folly:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - upgrade-cmake
       - setup-folly
-      - build-folly
-      - run: (mkdir build && cd build && cmake -DUSE_FOLLY=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 .. && make V=1 -j20 && ctest -j20)
-      - post-steps
-
-  build-linux-cmake-with-folly-lite-no-test:
-    executor: linux-docker
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - setup-folly
-      - run: (mkdir build && cd build && cmake -DUSE_FOLLY_LITE=1 -DWITH_GFLAGS=1 .. && make V=1 -j20)
+      - run: (mkdir build && cd build && cmake -DUSE_FOLLY=1 -DWITH_GFLAGS=1 .. && make V=1 -j20 && ctest -j20)
       - post-steps
 
   build-linux-cmake-with-benchmark:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
-      - run: mkdir build && cd build && cmake -DWITH_GFLAGS=1 -DWITH_BENCHMARK=1 .. && make V=1 -j20 && ctest -j20
+      - install-gflags
+      - install-benchmark
+      - run: (mkdir build && cd build && cmake -DWITH_GFLAGS=1 -DWITH_BENCHMARK=1 .. && make V=1 -j20 && ctest -j20)
       - post-steps
 
   build-linux-unity-and-headers:
@@ -405,117 +485,91 @@ jobs:
       - post-steps
 
   build-linux-gcc-7-with-folly:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test && sudo apt-get update -y && sudo apt-get install gcc-7 g++-7 libgflags-dev
       - setup-folly
-      - build-folly
       - run: USE_FOLLY=1 CC=gcc-7 CXX=g++-7 V=1 make -j32 check
       - post-steps
 
-  build-linux-gcc-7-with-folly-lite-no-test:
-    executor: linux-docker
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - setup-folly
-      - run: USE_FOLLY_LITE=1 CC=gcc-7 CXX=g++-7 V=1 make -j32 all
-      - post-steps
-
   build-linux-gcc-8-no_test_run:
-    executor: linux-docker
-    resource_class: 2xlarge
+    machine:
+      image: ubuntu-2004:202111-02
+    resource_class: xlarge
     steps:
       - pre-steps
-      - run: CC=gcc-8 CXX=g++-8 V=1 make -j32 all
-      - post-steps
-
-  build-linux-cmake-with-folly-coroutines:
-    executor: linux-docker
-    resource_class: 2xlarge
-    environment:
-      CC: gcc-10
-      CXX: g++-10
-    steps:
-      - pre-steps
-      - setup-folly
-      - build-folly
-      - run: (mkdir build && cd build && cmake -DUSE_COROUTINES=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 .. && make V=1 -j20 && ctest -j20)
+      - run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test && sudo apt-get update -y && sudo apt-get install gcc-8 g++-8 libgflags-dev
+      - run: CC=gcc-8 CXX=g++-8 V=1 make -j16 all
       - post-steps
 
   build-linux-gcc-10-cxx20-no_test_run:
-    executor: linux-docker
-    resource_class: 2xlarge
+    machine:
+      image: ubuntu-2004:202111-02
+    resource_class: xlarge
     steps:
       - pre-steps
-      - run: CC=gcc-10 CXX=g++-10 V=1 ROCKSDB_CXX_STANDARD=c++20 make -j32 all
+      - run: sudo apt-get update -y && sudo apt-get install gcc-10 g++-10 libgflags-dev
+      - run: CC=gcc-10 CXX=g++-10 V=1 ROCKSDB_CXX_STANDARD=c++20 make -j16 all
       - post-steps
 
   build-linux-gcc-11-no_test_run:
-    executor: linux-docker
-    resource_class: 2xlarge
+    machine:
+      image: ubuntu-2004:202111-02
+    resource_class: xlarge
     steps:
       - pre-steps
-      - run: CC=gcc-11 CXX=g++-11 V=1 make -j32 all microbench
+      - run: sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test && sudo apt-get update -y && sudo apt-get install gcc-11 g++-11 libgflags-dev
+      - install-benchmark
+      - run: CC=gcc-11 CXX=g++-11 V=1 make -j16 all microbench
       - post-steps
 
   build-linux-clang-13-no_test_run:
-    executor: linux-docker
-    resource_class: 2xlarge
+    machine:
+      image: ubuntu-2004:202111-02
+    resource_class: xlarge
     steps:
       - pre-steps
-      - run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j32 all microbench
+      - install-clang-13
+      - install-benchmark
+      - run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j16 all microbench
       - post-steps
 
   # Ensure ASAN+UBSAN with folly, and full testsuite with clang 13
   build-linux-clang-13-asan-ubsan-with-folly:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-clang-13
+      - install-gflags
       - setup-folly
-      - build-folly
       - run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 USE_FOLLY=1 COMPILE_WITH_UBSAN=1 COMPILE_WITH_ASAN=1 make -j32 check
       - 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-run-microbench:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-benchmark
       - run: DEBUG_LEVEL=0 make -j32 run_microbench
       - post-steps
 
   build-linux-mini-crashtest:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - pre-steps
-      - run: ulimit -S -n `ulimit -H -n` && make V=1 -j8 CRASH_TEST_EXT_ARGS='--duration=960 --max_key=2500000' blackbox_crash_test_with_atomic_flush
-      - post-steps
-
-  build-linux-crashtest-tiered-storage-bb:
-    executor: linux-docker
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - run:
-          name: "run crashtest"
-          command: ulimit -S -n `ulimit -H -n` && make V=1 -j32 CRASH_TEST_EXT_ARGS=--duration=10800 blackbox_crash_test_with_tiered_storage
-          no_output_timeout: 100m
-      - post-steps
-
-  build-linux-crashtest-tiered-storage-wb:
-    executor: linux-docker
-    resource_class: 2xlarge
-    steps:
-      - pre-steps
-      - run:
-          name: "run crashtest"
-          command: ulimit -S -n `ulimit -H -n` && make V=1 -j32 CRASH_TEST_EXT_ARGS=--duration=10800 whitebox_crash_test_with_tiered_storage
-          no_output_timeout: 100m
+      - install-gflags
+      - install-compression-libs
+      - run: ulimit -S -n `ulimit -H -n` && make V=1 -j8 CRASH_TEST_EXT_ARGS=--duration=960 blackbox_crash_test_with_atomic_flush
       - post-steps
 
   build-windows:
@@ -587,10 +641,14 @@ jobs:
             build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test -Concurrency 16
 
   build-linux-java:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
+    environment:
+      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
     steps:
       - pre-steps
+      - install-gflags
       - run:
           name: "Set Java Environment"
           command: |
@@ -604,10 +662,14 @@ jobs:
       - post-steps
 
   build-linux-java-static:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
+    environment:
+      JAVA_HOME: /usr/lib/jvm/java-1.8.0-openjdk-amd64
     steps:
       - pre-steps
+      - install-gflags
       - run:
           name: "Set Java Environment"
           command: |
@@ -642,7 +704,6 @@ jobs:
       - run:
           name: "Test RocksDBJava"
           command: make V=1 J=16 -j16 jtest
-          no_output_timeout: 20m
       - post-steps
 
   build-macos-java-static:
@@ -667,7 +728,6 @@ jobs:
       - run:
           name: "Build RocksDBJava x86 and ARM Static Libraries"
           command: make V=1 J=16 -j16 rocksdbjavastaticosx
-          no_output_timeout: 20m
       - post-steps
 
   build-macos-java-static-universal:
@@ -692,29 +752,37 @@ jobs:
       - run:
           name: "Build RocksDBJava Universal Binary Static Library"
           command: make V=1 J=16 -j16 rocksdbjavastaticosx_ub
-          no_output_timeout: 20m
       - post-steps
 
   build-examples:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - pre-steps
+      - install-gflags
       - run:
           name: "Build examples"
           command: |
-            make V=1 -j4 static_lib && cd examples && make V=1 -j4
+            OPT=-DTRAVIS V=1 make -j4 static_lib && cd examples && make -j4
       - post-steps
 
   build-cmake-mingw:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - pre-steps
-      - run: update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
+      - install-gflags
+      - run: sudo apt-get update -y && sudo apt-get install -y mingw-w64
+      - run: sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
       - run:
           name: "Build cmake-mingw"
           command: |
+            sudo apt-get install snapd && sudo snap install cmake --beta --classic
+            export PATH=/snap/bin:$PATH
+            sudo apt-get install -y openjdk-8-jdk
+            export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
             export PATH=$JAVA_HOME/bin:$PATH
             echo "JAVA_HOME=${JAVA_HOME}"
             which java && java -version
@@ -723,12 +791,14 @@ jobs:
       - post-steps
 
   build-linux-non-shm:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     environment:
       TEST_TMPDIR: /tmp/rocksdb_test_tmp
     steps:
       - pre-steps
+      - install-gflags
       - run: make V=1 -j32 check
       - post-steps
 
@@ -786,10 +856,13 @@ jobs:
       - post-steps
 
   build-format-compatible:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: 2xlarge
     steps:
       - pre-steps
+      - install-gflags
+      - install-compression-libs
       - run:
           name: "test"
           command: |
@@ -800,10 +873,14 @@ jobs:
       - post-steps
 
   build-fuzzers:
-    executor: linux-docker
+    machine:
+      image: ubuntu-2004:202111-02
     resource_class: large
     steps:
       - pre-steps
+      - install-clang-13
+      - run: sudo apt-get update -y && sudo apt-get install -y cmake ninja-build binutils liblzma-dev libz-dev pkg-config autoconf libtool
+      - install-libprotobuf-mutator
       - run:
           name: "Build rocksdb lib"
           command: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j4 static_lib
@@ -826,10 +903,7 @@ workflows:
     jobs:
       - build-linux
       - build-linux-cmake-with-folly
-      - build-linux-cmake-with-folly-lite-no-test
       - build-linux-gcc-7-with-folly
-      - build-linux-gcc-7-with-folly-lite-no-test
-      - build-linux-cmake-with-folly-coroutines
       - build-linux-cmake-with-benchmark
       - build-linux-encrypted_env-no_compression
       - build-linux-lite
@@ -837,7 +911,12 @@ workflows:
     jobs:
       - build-linux-clang10-asan
       - build-linux-clang10-ubsan
-      - build-linux-clang10-mini-tsan
+      - build-linux-clang10-mini-tsan:
+          start_test: ""
+          end_test: "env_test"
+      - build-linux-clang10-mini-tsan:
+          start_test: "env_test"
+          end_test: ""
       - build-linux-shared_lib-alt_namespace-status_checked
   jobs-linux-no-test-run:
     jobs:

.travis.yml

@@ -0,0 +1,280 @@
+dist: xenial
+language: cpp
+os:
+  - linux
+arch:
+  - arm64
+  - ppc64le
+  - s390x
+compiler:
+  - clang
+  - gcc
+cache:
+  - ccache
+
+addons:
+  apt:
+    update: true
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - libgflags-dev
+      - libbz2-dev
+      - liblz4-dev
+      - libsnappy-dev
+      - liblzma-dev  # xv
+      - libzstd-dev
+      - zlib1g-dev
+
+env:
+  - TEST_GROUP=platform_dependent # 16-18 minutes
+  - TEST_GROUP=1 # 33-35 minutes
+  - TEST_GROUP=2 # 18-20 minutes
+  - TEST_GROUP=3 # 20-22 minutes
+  - TEST_GROUP=4 # 12-14 minutes
+  # Run java tests
+  - JOB_NAME=java_test # 4-11 minutes
+  # Build ROCKSDB_LITE
+  - JOB_NAME=lite_build # 3-4 minutes
+  # Build examples
+  - JOB_NAME=examples # 5-7 minutes
+  - JOB_NAME=cmake # 3-5 minutes
+  - JOB_NAME=cmake-gcc8 # 3-5 minutes
+  - JOB_NAME=cmake-gcc9 # 3-5 minutes
+  - JOB_NAME=cmake-gcc9-c++20 # 3-5 minutes
+  - JOB_NAME=cmake-mingw # 3 minutes
+
+matrix:
+  exclude:
+  - os : linux
+    arch: arm64
+    env: JOB_NAME=cmake-mingw
+  - os: linux
+    arch: ppc64le
+    env: JOB_NAME=cmake-mingw
+  - os: linux
+    arch: s390x
+    env: JOB_NAME=cmake-mingw
+  - os: linux
+    compiler: clang
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: arm64
+    env: TEST_GROUP=platform_dependent
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: TEST_GROUP=1
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: TEST_GROUP=1
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: TEST_GROUP=1
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: TEST_GROUP=2
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: TEST_GROUP=2
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: TEST_GROUP=2
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: TEST_GROUP=3
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: TEST_GROUP=3
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: TEST_GROUP=3
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: TEST_GROUP=4
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: TEST_GROUP=4
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: TEST_GROUP=4
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=cmake
+  - if: type = pull_request AND commit_message !~ /FULL_CI/ AND commit_message !~ /java/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=java_test
+  - if: type = pull_request AND commit_message !~ /FULL_CI/ AND commit_message !~ /java/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=java_test
+  - if: type = pull_request AND commit_message !~ /FULL_CI/ AND commit_message !~ /java/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=java_test
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=lite_build
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=lite_build
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=lite_build
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=examples
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=examples
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=examples
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=cmake-gcc8
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=cmake-gcc8
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=cmake-gcc8
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=cmake-gcc9
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=cmake-gcc9
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=cmake-gcc9
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os : linux
+    arch: arm64
+    env: JOB_NAME=cmake-gcc9-c++20
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    env: JOB_NAME=cmake-gcc9-c++20
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: s390x
+    env: JOB_NAME=cmake-gcc9-c++20
+
+install:
+  -  CC=gcc-7 && CXX=g++-7
+  - if [ "${JOB_NAME}" == cmake-gcc8 ]; then
+      sudo apt-get install -y g++-8 || exit $?;
+      CC=gcc-8 && CXX=g++-8;
+    fi
+  - if [ "${JOB_NAME}" == cmake-gcc9 ] || [ "${JOB_NAME}" == cmake-gcc9-c++20 ]; then
+      sudo apt-get install -y g++-9 || exit $?;
+      CC=gcc-9 && CXX=g++-9;
+    fi
+  - if [ "${JOB_NAME}" == cmake-mingw ]; then
+      sudo apt-get install -y mingw-w64 || exit $?;
+    fi
+  - if [ "${CXX}" == "g++-7" ]; then
+      sudo apt-get install -y g++-7 || exit $?;
+    fi
+  - |
+    if [[ "${JOB_NAME}" == cmake* ]]; then
+      sudo apt-get remove -y cmake cmake-data
+      export CMAKE_DEB="cmake-3.14.5-Linux-$(uname -m).deb"
+      export CMAKE_DEB_URL="https://rocksdb-deps.s3-us-west-2.amazonaws.com/cmake/${CMAKE_DEB}"
+      curl --silent --fail --show-error --location --output "${CMAKE_DEB}" "${CMAKE_DEB_URL}" || exit $?
+      sudo dpkg -i "${CMAKE_DEB}" || exit $?
+      which cmake && cmake --version
+    fi
+  - |
+    if [[ "${JOB_NAME}" == java_test || "${JOB_NAME}" == cmake* ]]; then
+      # Ensure JDK 8
+      sudo apt-get install -y openjdk-8-jdk || exit $?
+      export PATH=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)/bin:$PATH
+      export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-$(dpkg --print-architecture)
+      echo "JAVA_HOME=${JAVA_HOME}"
+      which java && java -version
+      which javac && javac -version
+    fi
+
+before_script:
+  # Increase the maximum number of open file descriptors, since some tests use
+  # more FDs than the default limit.
+  - ulimit -n 8192
+
+script:
+  - date; ${CXX} --version
+  - if [ `command -v ccache` ]; then ccache -C; fi
+  - export MK_PARALLEL=4;
+    if [[ "$TRAVIS_CPU_ARCH" == s390x ]]; then
+      export MK_PARALLEL=1;
+    fi
+  - case $TEST_GROUP in
+    platform_dependent)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 ROCKSDBTESTS_PLATFORM_DEPENDENT=only make -j$MK_PARALLEL all_but_some_tests check_some
+      ;;
+    1)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 ROCKSDBTESTS_PLATFORM_DEPENDENT=exclude ROCKSDBTESTS_END=backup_engine_test make -j$MK_PARALLEL check_some
+      ;;
+    2)
+      OPT="-DTRAVIS -DROCKSDB_NAMESPACE=alternative_rocksdb_ns" LIB_MODE=shared V=1 make -j$MK_PARALLEL tools && OPT="-DTRAVIS -DROCKSDB_NAMESPACE=alternative_rocksdb_ns" LIB_MODE=shared V=1 ROCKSDBTESTS_PLATFORM_DEPENDENT=exclude ROCKSDBTESTS_START=backup_engine_test ROCKSDBTESTS_END=db_universal_compaction_test make -j$MK_PARALLEL check_some
+      ;;
+    3)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 ROCKSDBTESTS_PLATFORM_DEPENDENT=exclude ROCKSDBTESTS_START=db_universal_compaction_test ROCKSDBTESTS_END=table_properties_collector_test make -j$MK_PARALLEL check_some
+      ;;
+    4)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 ROCKSDBTESTS_PLATFORM_DEPENDENT=exclude ROCKSDBTESTS_START=table_properties_collector_test make -j$MK_PARALLEL check_some
+      ;;
+    esac
+  - case $JOB_NAME in
+    java_test)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 make rocksdbjava jtest
+      ;;
+    lite_build)
+      OPT='-DTRAVIS -DROCKSDB_LITE' LIB_MODE=shared V=1 make -j$MK_PARALLEL all
+      ;;
+    examples)
+      OPT=-DTRAVIS LIB_MODE=shared V=1 make -j$MK_PARALLEL static_lib && cd examples && make -j$MK_PARALLEL
+      ;;
+    cmake-mingw)
+      sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix;
+      mkdir build && cd build && cmake -DJNI=1 -DWITH_GFLAGS=OFF .. -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ -DCMAKE_SYSTEM_NAME=Windows && make -j4 rocksdb rocksdbjni
+      ;;
+    cmake*)
+      case $JOB_NAME in
+        *-c++20)
+          OPT=-DCMAKE_CXX_STANDARD=20
+          ;;
+      esac
+
+      mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=0 -DWITH_GFLAGS=0 -DWITH_BENCHMARK_TOOLS=0 -DWITH_TOOLS=0 -DWITH_CORE_TOOLS=1 .. && make -j$MK_PARALLEL && cd  .. && rm -rf build && mkdir build && cd build && cmake -DJNI=1 .. -DCMAKE_BUILD_TYPE=Release $OPT && make -j$MK_PARALLEL rocksdb rocksdbjni
+      ;;
+    esac
+notifications:
+    email:
+      - leveldb@fb.com

CMakeLists.txt

@@ -74,7 +74,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()
-option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
 
 if ($ENV{CIRCLECI})
   message(STATUS "Build for CircieCI env, a few tests may be disabled")
@@ -585,61 +584,10 @@ endif()
 
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
-
-if(USE_COROUTINES)
-  if(USE_FOLLY OR USE_FOLLY_LITE)
-    message(FATAL_ERROR "Please specify exactly one of USE_COROUTINES,"
-    " USE_FOLLY, and USE_FOLLY_LITE")
-  endif()
-  set(CMAKE_CXX_STANDARD 20)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcoroutines -Wno-maybe-uninitialized")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-redundant-move")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-invalid-memory-model")
-  add_compile_definitions(USE_COROUTINES)
-  set(USE_FOLLY 1)
-endif()
-
 if(USE_FOLLY)
-  if(USE_FOLLY_LITE)
-    message(FATAL_ERROR "Please specify one of USE_FOLLY or USE_FOLLY_LITE")
-  endif()
-  if(ROCKSDB_BUILD_SHARED)
-    message(FATAL_ERROR "Cannot build RocksDB shared library with folly")
-  endif()
-  set(ROCKSDB_BUILD_SHARED OFF)
-  set(GFLAGS_SHARED FALSE)
-  find_package(folly)
-  # If cmake could not find the folly-config.cmake file, fall back
-  # to looking in third-party/folly for folly and its dependencies
-  if(NOT FOLLY_LIBRARIES)
-    exec_program(python3 ${PROJECT_SOURCE_DIR}/third-party/folly ARGS
-    build/fbcode_builder/getdeps.py show-inst-dir OUTPUT_VARIABLE
-    FOLLY_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../boost* OUTPUT_VARIABLE
-    BOOST_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../fmt* OUTPUT_VARIABLE
-    FMT_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../gflags* OUTPUT_VARIABLE
-    GFLAGS_INST_PATH)
-    set(Boost_DIR ${BOOST_INST_PATH}/lib/cmake/Boost-1.78.0)
-    if(EXISTS ${FMT_INST_PATH}/lib64)
-      set(fmt_DIR ${FMT_INST_PATH}/lib64/cmake/fmt)
-    else()
-      set(fmt_DIR ${FMT_INST_PATH}/lib/cmake/fmt)
-    endif()
-    set(gflags_DIR ${GFLAGS_INST_PATH}/lib/cmake/gflags)
-
-    exec_program(sed ARGS -i 's/gflags_shared//g'
-    ${FOLLY_INST_PATH}/lib/cmake/folly/folly-targets.cmake)
-
-    include(${FOLLY_INST_PATH}/lib/cmake/folly/folly-config.cmake)
-  endif()
-
-  add_compile_definitions(USE_FOLLY FOLLY_NO_CONFIG HAVE_CXX11_ATOMIC)
-  list(APPEND THIRDPARTY_LIBS Folly::folly)
-  set(FOLLY_LIBS Folly::folly)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--copy-dt-needed-entries")
+  include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
+  add_definitions(-DUSE_FOLLY -DFOLLY_NO_CONFIG)
+  list(APPEND THIRDPARTY_LIBS glog)
 endif()
 find_package(Threads REQUIRED)
 
@@ -650,14 +598,12 @@ set(SOURCES
         cache/cache_entry_roles.cc
         cache/cache_key.cc
         cache/cache_reservation_manager.cc
-        cache/charged_cache.cc
         cache/clock_cache.cc
         cache/compressed_secondary_cache.cc
         cache/fast_lru_cache.cc
         cache/lru_cache.cc
         cache/sharded_cache.cc
         db/arena_wrapped_db_iter.cc
-        db/blob/blob_contents.cc
         db/blob/blob_fetcher.cc
         db/blob/blob_file_addition.cc
         db/blob/blob_file_builder.cc
@@ -720,7 +666,7 @@ set(SOURCES
         db/merge_helper.cc
         db/merge_operator.cc
         db/output_validator.cc
-        db/periodic_task_scheduler.cc
+        db/periodic_work_scheduler.cc
         db/range_del_aggregator.cc
         db/range_tombstone_fragmenter.cc
         db/repair.cc
@@ -737,7 +683,6 @@ set(SOURCES
         db/wal_edit.cc
         db/wal_manager.cc
         db/wide/wide_column_serialization.cc
-        db/wide/wide_columns.cc
         db/write_batch.cc
         db/write_batch_base.cc
         db/write_controller.cc
@@ -880,7 +825,6 @@ set(SOURCES
         util/slice.cc
         util/file_checksum_helper.cc
         util/status.cc
-        util/stderr_logger.cc
         util/string_util.cc
         util/thread_local.cc
         util/threadpool_imp.cc
@@ -1035,7 +979,7 @@ else()
     env/io_posix.cc)
 endif()
 
-if(USE_FOLLY_LITE)
+if(USE_FOLLY)
   list(APPEND SOURCES
     third-party/folly/folly/container/detail/F14Table.cpp
     third-party/folly/folly/detail/Futex.cpp
@@ -1045,14 +989,13 @@ if(USE_FOLLY_LITE)
     third-party/folly/folly/synchronization/AtomicNotification.cpp
     third-party/folly/folly/synchronization/DistributedMutex.cpp
     third-party/folly/folly/synchronization/ParkingLot.cpp)
-  include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
-  add_definitions(-DUSE_FOLLY -DFOLLY_NO_CONFIG)
-  list(APPEND THIRDPARTY_LIBS glog)
 endif()
 
 set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
 set(ROCKSDB_SHARED_LIB rocksdb-shared${ARTIFACT_SUFFIX})
 
+option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
+
 
 if(WIN32)
   set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
@@ -1063,8 +1006,9 @@ endif()
 set(ROCKSDB_PLUGIN_EXTERNS "")
 set(ROCKSDB_PLUGIN_BUILTINS "")
 message(STATUS "ROCKSDB PLUGINS TO BUILD ${ROCKSDB_PLUGINS}")
+list(APPEND PLUGINS ${ROCKSDB_PLUGINS})
 foreach(PLUGIN IN LISTS PLUGINS)
-  set(PLUGIN_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/plugin/${PLUGIN}/")
+  set(PLUGIN_ROOT "${CMAKE_SOURCE_DIR}/plugin/${PLUGIN}/")
   message("including rocksb plugin ${PLUGIN_ROOT}")
   set(PLUGINMKFILE "${PLUGIN_ROOT}${PLUGIN}.mk")
   if (NOT EXISTS ${PLUGINMKFILE})
@@ -1351,7 +1295,7 @@ if(WITH_TESTS)
         db/merge_test.cc
         db/options_file_test.cc
         db/perf_context_test.cc
-        db/periodic_task_scheduler_test.cc
+        db/periodic_work_scheduler_test.cc
         db/plain_table_db_test.cc
         db/seqno_time_test.cc
         db/prefix_test.cc
@@ -1478,7 +1422,7 @@ if(WITH_TESTS)
   add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})
   set(TESTUTILLIB testutillib${ARTIFACT_SUFFIX})
   add_library(${TESTUTILLIB} STATIC ${TESTUTIL_SOURCE})
-  target_link_libraries(${TESTUTILLIB} ${ROCKSDB_LIB} ${FOLLY_LIBS})
+  target_link_libraries(${TESTUTILLIB} ${ROCKSDB_LIB})
   if(MSVC)
     set_target_properties(${TESTUTILLIB} PROPERTIES COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/testutillib${ARTIFACT_SUFFIX}.pdb")
   endif()
@@ -1536,46 +1480,32 @@ if(WITH_BENCHMARK_TOOLS)
     cache/cache_bench.cc
     cache/cache_bench_tool.cc)
   target_link_libraries(cache_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(memtablerep_bench${ARTIFACT_SUFFIX}
     memtable/memtablerep_bench.cc)
   target_link_libraries(memtablerep_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(range_del_aggregator_bench${ARTIFACT_SUFFIX}
     db/range_del_aggregator_bench.cc)
   target_link_libraries(range_del_aggregator_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(table_reader_bench${ARTIFACT_SUFFIX}
     table/table_reader_bench.cc)
   target_link_libraries(table_reader_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} testharness ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} testharness ${GFLAGS_LIB})
 
   add_executable(filter_bench${ARTIFACT_SUFFIX}
     util/filter_bench.cc)
   target_link_libraries(filter_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(hash_table_bench${ARTIFACT_SUFFIX}
     utilities/persistent_cache/hash_table_bench.cc)
   target_link_libraries(hash_table_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-endif()
-
-option(WITH_TRACE_TOOLS "build with trace tools" ON)
-if(WITH_TRACE_TOOLS)
-  add_executable(block_cache_trace_analyzer_tool${ARTIFACT_SUFFIX}
-    tools/block_cache_analyzer/block_cache_trace_analyzer_tool.cc)
-  target_link_libraries(block_cache_trace_analyzer_tool${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-
-  add_executable(trace_analyzer${ARTIFACT_SUFFIX}
-    tools/trace_analyzer.cc)
-  target_link_libraries(trace_analyzer${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 endif()
 
 if(WITH_CORE_TOOLS OR WITH_TOOLS)

HISTORY.md

@@ -1,135 +1,17 @@
 # Rocksdb Change Log
-## 7.7.8 (11/27/2022)
-### Bug Fixes
-* Fix failed memtable flush retry bug that could cause wrongly ordered updates, which would surface to writers as `Status::Corruption` in case of `force_consistency_checks=true` (default). It affects use cases that enable both parallel flush (`max_background_flushes > 1` or `max_background_jobs >= 8`) and non-default memtable count (`max_write_buffer_number > 2`).
-* Tiered Storage: fixed excessive keys written to penultimate level in non-debug builds.
-* Fixed a regression in iterator where range tombstones after `iterate_upper_bound` is processed.
+## 7.5.4 (11/03/2022)
+* Fixed a bug where blobs read during compaction would pollute the cache.
 
-## 7.7.7 (11/15/2022)
-### Bug Fixes
-* Fixed a regression in scan for async_io. During seek, valid buffers were getting cleared causing a regression.
-
-## 7.7.6 (11/03/2022)
-### Bug Fixes
-* Fix memory corruption error in scans if async_io is enabled. Memory corruption happened if there is IOError while reading the data leading to empty buffer and other buffer already in progress of async read goes again for reading.
-
-## 7.7.5 (10/28/2022)
-### Bug Fixes
-* Fixed an iterator performance regression for delete range users when scanning through a consecutive sequence of range tombstones (#10877).
-
-## 7.7.4 (10/28/2022)
-### Bug Fixes
-* Fixed a case of calling malloc_usable_size on result of operator new[].
-
-## 7.7.3 (10/11/2022)
-### Bug Fixes
-* Fixed a memory safety bug in experimental HyperClockCache (#10768)
-
-## 7.7.2 (10/05/2022)
-### Bug Fixes
-* Fixed a bug in iterator refresh that was not freeing up SuperVersion, which could cause excessive resource pinniung (#10770).
-* Fixed a bug where RocksDB could be doing compaction endlessly when allow_ingest_behind is true and the bottommost level is not filled (#10767).
-
-### Behavior Changes
-* Sanitize min_write_buffer_number_to_merge to 1 if atomic flush is enabled to prevent unexpected data loss when WAL is disabled in a multi-column-family setting (#10773).
-
-## 7.7.1 (09/26/2022)
-### Bug Fixes
-* Fixed an optimistic transaction validation bug caused by DBImpl::GetLatestSequenceForKey() returning non-latest seq for merge (#10724).
-* Fixed a bug in iterator refresh which could segfault for DeleteRange users (#10739).
-
-## 7.7.0 (09/18/2022)
-### Bug Fixes
-* Fixed a hang when an operation such as `GetLiveFiles` or `CreateNewBackup` is asked to trigger and wait for memtable flush on a read-only DB. Such indirect requests for memtable flush are now ignored on a read-only DB.
-* Fixed bug where `FlushWAL(true /* sync */)` (used by `GetLiveFilesStorageInfo()`, which is used by checkpoint and backup) could cause parallel writes at the tail of a WAL file to never be synced.
-* Fix periodic_task unable to re-register the same task type, which may cause `SetOptions()` fail to update periodical_task time like: `stats_dump_period_sec`, `stats_persist_period_sec`.
-* Fixed a bug in the rocksdb.prefetched.bytes.discarded stat. It was counting the prefetch buffer size, rather than the actual number of bytes discarded from the buffer.
-* Fix bug where the directory containing CURRENT can left unsynced after CURRENT is updated to point to the latest MANIFEST, which leads to risk of unsync data loss of CURRENT.
-* Update rocksdb.multiget.io.batch.size stat in non-async MultiGet as well.
-* Fix a bug in key range overlap checking with concurrent compactions when user-defined timestamp is enabled. User-defined timestamps should be EXCLUDED when checking if two ranges overlap.
-* Fixed a bug where the blob cache prepopulating logic did not consider the secondary cache (see #10603).
-* Fixed the rocksdb.num.sst.read.per.level, rocksdb.num.index.and.filter.blocks.read.per.level and rocksdb.num.level.read.per.multiget stats in the MultiGet coroutines
-* Fix a bug in io_uring_prep_cancel in AbortIO API for posix which expects sqe->addr to match with read request submitted and wrong paramter was being passed.
-* Fixed a regression in iterator performance when the entire DB is a single memtable introduced in #10449. The fix is in #10705 and #10716.
-* Fix a bug in io_uring_prep_cancel in AbortIO API for posix which expects sqe->addr to match with read request submitted and wrong paramter was being passed.
-* Fixed a regression in iterator performance when the entire DB is a single memtable introduced in #10449. The fix is in #10705 and #10716.
-
-### Public API changes
-* Add `rocksdb_column_family_handle_get_id`, `rocksdb_column_family_handle_get_name` to get name, id of column family in C API
-* Add a new stat rocksdb.async.prefetch.abort.micros to measure time spent waiting for async prefetch reads to abort
-
-### Java API Changes
-* Add CompactionPriority.RoundRobin.
-* Revert to using the default metadata charge policy when creating an LRU cache via the Java API.
-
-### Behavior Change
-* DBOptions::verify_sst_unique_id_in_manifest is now an on-by-default feature that verifies SST file identity whenever they are opened by a DB, rather than only at DB::Open time.
-* Right now, when the option migration tool (OptionChangeMigration()) migrates to FIFO compaction, it compacts all the data into one single SST file and move to L0. This might create a problem for some users: the giant file may be soon deleted to satisfy max_table_files_size, and might cayse the DB to be almost empty. We change the behavior so that the files are cut to be smaller, but these files might not follow the data insertion order. With the change, after the migration, migrated data might not be dropped by insertion order by FIFO compaction.
-* When a block is firstly found from `CompressedSecondaryCache`, we just insert a dummy block into the primary cache and don’t erase the block from `CompressedSecondaryCache`. A standalone handle is returned to the caller. Only if the block is found again from `CompressedSecondaryCache` before the dummy block is evicted, we erase the block from `CompressedSecondaryCache` and insert it into the primary cache.
-* When a block is firstly evicted from the primary cache to `CompressedSecondaryCache`, we just insert a dummy block in `CompressedSecondaryCache`. Only if it is evicted again before the dummy block is evicted from the cache, it is treated as a hot block and is inserted into `CompressedSecondaryCache`.
-* Improved the estimation of memory used by cached blobs by taking into account the size of the object owning the blob value and also the allocator overhead if `malloc_usable_size` is available (see #10583).
-* Blob values now have their own category in the cache occupancy statistics, as opposed to being lumped into the "Misc" bucket (see #10601).
-* Change the optimize_multiget_for_io experimental ReadOptions flag to default on.
-
-### New Features
-*  RocksDB does internal auto prefetching if it notices 2 sequential reads if readahead_size is not specified. New option `num_file_reads_for_auto_readahead` is added in BlockBasedTableOptions which indicates after how many sequential reads internal auto prefetching should be start (default is 2).
-* Added new perf context counters `block_cache_standalone_handle_count`, `block_cache_real_handle_count`,`compressed_sec_cache_insert_real_count`, `compressed_sec_cache_insert_dummy_count`, `compressed_sec_cache_uncompressed_bytes`, and `compressed_sec_cache_compressed_bytes`.
-* Memory for blobs which are to be inserted into the blob cache is now allocated using the cache's allocator (see #10628 and #10647).
-* HyperClockCache is an experimental, lock-free Cache alternative for block cache that offers much improved CPU efficiency under high parallel load or high contention, with some caveats. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load.
-* `CompressedSecondaryCacheOptions::enable_custom_split_merge` is added for enabling the custom split and merge feature, which split the compressed value into chunks so that they may better fit jemalloc bins.
-
-### Performance Improvements
-* Iterator performance is improved for `DeleteRange()` users. Internally, iterator will skip to the end of a range tombstone when possible, instead of looping through each key and check individually if a key is range deleted.
-* Eliminated some allocations and copies in the blob read path. Also, `PinnableSlice` now only points to the blob value and pins the backing resource (cache entry or buffer) in all cases, instead of containing a copy of the blob value. See #10625 and #10647.
-* In case of scans with async_io enabled, few optimizations have been added to issue more asynchronous requests in parallel in order to avoid synchronous prefetching.
-* `DeleteRange()` users should see improvement in get/iterator performance from mutable memtable (see #10547).
-
-## 7.6.0 (08/19/2022)
-### New Features
-* Added `prepopulate_blob_cache` to ColumnFamilyOptions. If enabled, prepopulate warm/hot blobs which are already in memory into blob cache at the time of flush. On a flush, the blob that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this blob back into memory again, which is avoided by enabling this option. This further helps if the workload exhibits high temporal locality, where most of the reads go to recently written data. This also helps in case of the remote file system since it involves network traffic and higher latencies.
-* Support using secondary cache with the blob cache. When creating a blob cache, the user can set a secondary blob cache by configuring `secondary_cache` in LRUCacheOptions.
-* Charge memory usage of blob cache when the backing cache of the blob cache and the block cache are different. If an operation reserving memory for blob cache exceeds the avaible space left in the block cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kBlobCache` in `BlockBasedTableOptions::cache_usage_options`.
-* Improve subcompaction range partition so that it is likely to be more even. More evenly distribution of subcompaction will improve compaction throughput for some workloads. All input files' index blocks to sample some anchor key points from which we pick positions to partition the input range. This would introduce some CPU overhead in compaction preparation phase, if subcompaction is enabled, but it should be a small fraction of the CPU usage of the whole compaction process. This also brings a behavier change: subcompaction number is much more likely to maxed out than before.
-* Add CompactionPri::kRoundRobin, a compaction picking mode that cycles through all the files with a compact cursor in a round-robin manner. This feature is available since 7.5.
-* Provide support for subcompactions for user_defined_timestamp.
-* Added an option `memtable_protection_bytes_per_key` that turns on memtable per key-value checksum protection. Each memtable entry will be suffixed by a checksum that is computed during writes, and verified in reads/compaction. Detected corruption will be logged and with corruption status returned to user.
-* Added a blob-specific cache priority level - bottom level. Blobs are typically lower-value targets for caching than data blocks, since 1) with BlobDB, data blocks containing blob references conceptually form an index structure which has to be consulted before we can read the blob value, and 2) cached blobs represent only a single key-value, while cached data blocks generally contain multiple KVs. The user can specify the new option `low_pri_pool_ratio` in `LRUCacheOptions` to configure the ratio of capacity reserved for low priority cache entries (and therefore the remaining ratio is the space reserved for the bottom level), or configuring the new argument `low_pri_pool_ratio` in `NewLRUCache()` to achieve the same effect.
-
-### Public API changes
-* Removed Customizable support for RateLimiter and removed its CreateFromString() and Type() functions.
-* `CompactRangeOptions::exclusive_manual_compaction` is now false by default. This ensures RocksDB does not introduce artificial parallelism limitations by default.
-* Tiered Storage: change `bottommost_temperture` to `last_level_temperture`. The old option name is kept only for migration, please use the new option. The behavior is changed to apply temperature for the `last_level` SST files only.
-* Added a new experimental ReadOption flag called optimize_multiget_for_io, which when set attempts to reduce MultiGet latency by spawning coroutines for keys in multiple levels.
+## 7.5.3 (08/24/2022)
+* Fixed a regression where L0's compaction score could become very large.
 
+## 7.5.2 (08/02/2022)
 ### Bug Fixes
 * Fix a bug starting in 7.4.0 in which some fsync operations might be skipped in a DB after any DropColumnFamily on that DB, until it is re-opened. This can lead to data loss on power loss. (For custom FileSystem implementations, this could lead to `FSDirectory::Fsync` or `FSDirectory::Close` after the first `FSDirectory::Close`; Also, valgrind could report call to `close()` with `fd=-1`.)
-* Fix a bug where `GenericRateLimiter` could revert the bandwidth set dynamically using `SetBytesPerSecond()` when a user configures a structure enclosing it, e.g., using `GetOptionsFromString()` to configure an `Options` that references an existing `RateLimiter` object.
-* Fix race conditions in `GenericRateLimiter`.
-* Fix a bug in `FIFOCompactionPicker::PickTTLCompaction` where total_size calculating might cause underflow
-* Fix data race bug in hash linked list memtable. With this bug, read request might temporarily miss an old record in the memtable in a race condition to the hash bucket.
-* Fix a bug that `best_efforts_recovery` may fail to open the db with mmap read.
-* Fixed a bug where blobs read during compaction would pollute the cache.
-* Fixed a data race in LRUCache when used with a secondary_cache.
-* Fixed a bug where blobs read by iterators would be inserted into the cache even with the `fill_cache` read option set to false.
-* Fixed the segfault caused by `AllocateData()` in `CompressedSecondaryCache::SplitValueIntoChunks()` and `MergeChunksIntoValueTest`.
-* Fixed a bug in BlobDB where a mix of inlined and blob values could result in an incorrect value being passed to the compaction filter (see #10391).
-* Fixed a memory leak bug in stress tests caused by `FaultInjectionSecondaryCache`.
 
-### Behavior Change
-* Added checksum handshake during the copying of decompressed WAL fragment. This together with #9875, #10037, #10212, #10114 and #10319 provides end-to-end integrity protection for write batch during recovery.
-* To minimize the internal fragmentation caused by the variable size of the compressed blocks in `CompressedSecondaryCache`, the original block is split according to the jemalloc bin size in `Insert()` and then merged back in `Lookup()`.
-* PosixLogger is removed and by default EnvLogger will be used for info logging. The behavior of the two loggers should be very similar when using the default Posix Env.
-* Remove [min|max]_timestamp from VersionEdit for now since they are not tracked in MANIFEST anyway but consume two empty std::string (up to 64 bytes) for each file. Should they be added back in the future, we should store them more compactly.
-* Improve universal tiered storage compaction picker to avoid extra major compaction triggered by size amplification. If `preclude_last_level_data_seconds` is enabled, the size amplification is calculated within non last_level data only which skip the last level and use the penultimate level as the size base.
-* If an error is hit when writing to a file (append, sync, etc), RocksDB is more strict with not issuing more operations to it, except closing the file, with exceptions of some WAL file operations in error recovery path.
-* A `WriteBufferManager` constructed with `allow_stall == false` will no longer trigger write stall implicitly by thrashing until memtable count limit is reached. Instead, a column family can continue accumulating writes while that CF is flushing, which means memory may increase. Users who prefer stalling writes must now explicitly set `allow_stall == true`.
-* Add `CompressedSecondaryCache` into the stress tests.
-* Block cache keys have changed, which will cause any persistent caches to miss between versions.
-
-### Performance Improvements
-* Instead of constructing `FragmentedRangeTombstoneList` during every read operation, it is now constructed once and stored in immutable memtables. This improves speed of querying range tombstones from immutable memtables.
-* When using iterators with the integrated BlobDB implementation, blob cache handles are now released immediately when the iterator's position changes.
-* MultiGet can now do more IO in parallel by reading data blocks from SST files in multiple levels, if the optimize_multiget_for_io ReadOption flag is set.
+## 7.5.1 (08/01/2022)
+### Bug Fixes
+* Fix a bug where rate_limiter_parameter is not passed into `PartitionedFilterBlockReader::GetFilterPartitionBlock`.
 
 ## 7.5.0 (07/15/2022)
 ### New Features
@@ -152,14 +34,14 @@
 * When using block cache strict capacity limit (`LRUCache` with `strict_capacity_limit=true`), DB operations now fail with Status code `kAborted` subcode `kMemoryLimit` (`IsMemoryLimit()`) instead of `kIncomplete` (`IsIncomplete()`) when the capacity limit is reached, because Incomplete can mean other specific things for some operations. In more detail, `Cache::Insert()` now returns the updated Status code and this usually propagates through RocksDB to the user on failure.
 * NewClockCache calls temporarily return an LRUCache (with similar characteristics as the desired ClockCache). This is because ClockCache is being replaced by a new version (the old one had unknown bugs) but this is still under development.
 * Add two functions `int ReserveThreads(int threads_to_be_reserved)` and `int ReleaseThreads(threads_to_be_released)` into `Env` class. In the default implementation, both return 0. Newly added `xxxEnv` class that inherits `Env` should implement these two functions for thread reservation/releasing features.
-* Add `rocksdb_options_get_prepopulate_blob_cache` and `rocksdb_options_set_prepopulate_blob_cache` to C API.
-* Add `prepopulateBlobCache` and `setPrepopulateBlobCache` to Java API.
+* Removed Customizable support for RateLimiter and removed its CreateFromString() and Type() functions.
 
 ### Bug Fixes
 * Fix a bug in which backup/checkpoint can include a WAL deleted by RocksDB.
 * Fix a bug where concurrent compactions might cause unnecessary further write stalling. In some cases, this might cause write rate to drop to minimum.
 * Fix a bug in Logger where if dbname and db_log_dir are on different filesystems, dbname creation would fail wrt to db_log_dir path returning an error and fails to open the DB.
-* Fix a CPU and memory efficiency issue introduce by https://github.com/facebook/rocksdb/pull/8336 which made InternalKeyComparator configurable as an unintended side effect.
+* Fix a CPU and memory efficiency issue introduce by https://github.com/facebook/rocksdb/pull/8336 which made InternalKeyComparator configurable as an unintended side effect
+* Fix a bug where `GenericRateLimiter` could revert the bandwidth set dynamically using `SetBytesPerSecond()` when a user configures a structure enclosing it, e.g., using `GetOptionsFromString()` to configure an `Options` that references an existing `RateLimiter` object.
 
 ## Behavior Change
 * In leveled compaction with dynamic levelling, level multiplier is not anymore adjusted due to oversized L0. Instead, compaction score is adjusted by increasing size level target by adding incoming bytes from upper levels. This would deprioritize compactions from upper levels if more data from L0 is coming. This is to fix some unnecessary full stalling due to drastic change of level targets, while not wasting write bandwidth for compaction while writes are overloaded.
@@ -219,7 +101,6 @@
 
 ### Behavior changes
 * DB::Open(), DB::OpenAsSecondary() will fail if a Logger cannot be created (#9984)
-* DB::Write does not hold global `mutex_` if this db instance does not need to switch wal and mem-table (#7516).
 * Removed support for reading Bloom filters using obsolete block-based filter format. (Support for writing such filters was dropped in 7.0.) For good read performance on old DBs using these filters, a full compaction is required.
 * Per KV checksum in write batch is verified before a write batch is written to WAL to detect any corruption to the write batch (#10114).
 

LANGUAGE-BINDINGS.md

@@ -6,9 +6,7 @@ This is the list of all known third-party language bindings for RocksDB. If some
     * http://pyrocksdb.readthedocs.org/en/latest/ (unmaintained)
 * Perl - https://metacpan.org/pod/RocksDB
 * Node.js - https://npmjs.org/package/rocksdb
-* Go 
-  * https://github.com/linxGnu/grocksdb
-  * https://github.com/tecbot/gorocksdb (unmaintained)
+* Go - https://github.com/tecbot/gorocksdb
 * Ruby - http://rubygems.org/gems/rocksdb-ruby
 * Haskell - https://hackage.haskell.org/package/rocksdb-haskell
 * PHP - https://github.com/Photonios/rocksdb-php

Makefile

@@ -139,14 +139,9 @@ endif
 GIT_COMMAND ?= git
 ifeq ($(USE_COROUTINES), 1)
 	USE_FOLLY = 1
-	# glog/logging.h requires HAVE_CXX11_ATOMIC
-	OPT += -DUSE_COROUTINES -DHAVE_CXX11_ATOMIC
+	OPT += -DUSE_COROUTINES
 	ROCKSDB_CXX_STANDARD = c++2a
 	USE_RTTI = 1
-ifneq ($(USE_CLANG), 1)
-	ROCKSDB_CXX_STANDARD = c++20
-	PLATFORM_CXXFLAGS += -fcoroutines
-endif
 endif
 
 # if we're compiling for release, compile without debug code (-DNDEBUG)
@@ -190,16 +185,6 @@ ifeq ($(USE_LTO), 1)
 	LDFLAGS += -flto -fuse-linker-plugin
 endif
 
-# `COERCE_CONTEXT_SWITCH=1` will inject spurious wakeup and
-# random length of sleep or context switch at critical
-# points (e.g, before acquring db mutex) in RocksDB.
-# In this way, it coerces as many excution orders as possible in the hope of
-# exposing the problematic excution order
-COERCE_CONTEXT_SWITCH ?= 0
-ifeq ($(COERCE_CONTEXT_SWITCH), 1)
-OPT += -DCOERCE_CONTEXT_SWITCH
-endif
-
 #-----------------------------------------------
 include src.mk
 
@@ -250,7 +235,6 @@ dummy := $(shell (export ROCKSDB_ROOT="$(CURDIR)"; \
                   export USE_CLANG="$(USE_CLANG)"; \
                   export LIB_MODE="$(LIB_MODE)"; \
 		  export ROCKSDB_CXX_STANDARD="$(ROCKSDB_CXX_STANDARD)"; \
-		  export USE_FOLLY="$(USE_FOLLY)"; \
                   "$(CURDIR)/build_tools/build_detect_platform" "$(CURDIR)/make_config.mk"))
 # this file is generated by the previous line to set build flags and sources
 include make_config.mk
@@ -431,10 +415,6 @@ ifndef DISABLE_JEMALLOC
 			PLATFORM_CXXFLAGS += -DUSE_JEMALLOC
 			PLATFORM_CCFLAGS  += -DUSE_JEMALLOC
 		endif
-		ifeq ($(USE_FOLLY_LITE),1)
-			PLATFORM_CXXFLAGS += -DUSE_JEMALLOC
-			PLATFORM_CCFLAGS  += -DUSE_JEMALLOC
-		endif
 	endif
 	ifdef WITH_JEMALLOC_FLAG
 		PLATFORM_LDFLAGS += -ljemalloc
@@ -468,57 +448,10 @@ endif
 
 # This provides a Makefile simulation of a Meta-internal folly integration.
 # It is not validated for general use.
-#
-# USE_FOLLY links the build targets with libfolly.a. The latter could be
-# built using 'make build_folly', or built externally and specified in
-# the CXXFLAGS and EXTRA_LDFLAGS env variables. The build_detect_platform
-# script tries to detect if an external folly dependency has been specified.
-# If not, it exports FOLLY_PATH to the path of the installed Folly and
-# dependency libraries.
-#
-# USE_FOLLY_LITE cherry picks source files from Folly to include in the
-# RocksDB library. Its faster and has fewer dependencies on 3rd party
-# libraries, but with limited functionality. For example, coroutine
-# functionality is not available.
 ifeq ($(USE_FOLLY),1)
-ifeq ($(USE_FOLLY_LITE),1)
-$(error Please specify only one of USE_FOLLY and USE_FOLLY_LITE)
-endif
-ifneq ($(strip $(FOLLY_PATH)),)
-	BOOST_PATH = $(shell (ls -d $(FOLLY_PATH)/../boost*))
-	DBL_CONV_PATH = $(shell (ls -d $(FOLLY_PATH)/../double-conversion*))
-	GFLAGS_PATH = $(shell (ls -d $(FOLLY_PATH)/../gflags*))
-	GLOG_PATH = $(shell (ls -d $(FOLLY_PATH)/../glog*))
-	LIBEVENT_PATH = $(shell (ls -d $(FOLLY_PATH)/../libevent*))
-	XZ_PATH = $(shell (ls -d $(FOLLY_PATH)/../xz*))
-	LIBSODIUM_PATH = $(shell (ls -d $(FOLLY_PATH)/../libsodium*))
-	FMT_PATH = $(shell (ls -d $(FOLLY_PATH)/../fmt*))
-
-	# For some reason, glog and fmt libraries are under either lib or lib64
-	GLOG_LIB_PATH = $(shell (ls -d $(GLOG_PATH)/lib*))
-	FMT_LIB_PATH = $(shell (ls -d $(FMT_PATH)/lib*))
-
-	# AIX: pre-defined system headers are surrounded by an extern "C" block
-	ifeq ($(PLATFORM), OS_AIX)
-		PLATFORM_CCFLAGS += -I$(BOOST_PATH)/include -I$(DBL_CONV_PATH)/include -I$(GLOG_PATH)/include -I$(LIBEVENT_PATH)/include -I$(XZ_PATH)/include -I$(LIBSODIUM_PATH)/include -I$(FOLLY_PATH)/include -I$(FMT_PATH)/include
-		PLATFORM_CXXFLAGS += -I$(BOOST_PATH)/include -I$(DBL_CONV_PATH)/include -I$(GLOG_PATH)/include -I$(LIBEVENT_PATH)/include -I$(XZ_PATH)/include -I$(LIBSODIUM_PATH)/include -I$(FOLLY_PATH)/include -I$(FMT_PATH)/include
-	else
-		PLATFORM_CCFLAGS += -isystem $(BOOST_PATH)/include -isystem $(DBL_CONV_PATH)/include -isystem $(GLOG_PATH)/include -isystem $(LIBEVENT_PATH)/include -isystem $(XZ_PATH)/include -isystem $(LIBSODIUM_PATH)/include -isystem $(FOLLY_PATH)/include -isystem $(FMT_PATH)/include
-		PLATFORM_CXXFLAGS += -isystem $(BOOST_PATH)/include -isystem $(DBL_CONV_PATH)/include -isystem $(GLOG_PATH)/include -isystem $(LIBEVENT_PATH)/include -isystem $(XZ_PATH)/include -isystem $(LIBSODIUM_PATH)/include -isystem $(FOLLY_PATH)/include -isystem $(FMT_PATH)/include
+	ifeq (,$(FOLLY_DIR))
+		FOLLY_DIR = ./third-party/folly
 	endif
-
-	# Add -ldl at the end as gcc resolves a symbol in a library by searching only in libraries specified later
-	# in the command line
-	PLATFORM_LDFLAGS += $(BOOST_PATH)/lib/libboost_context.a $(BOOST_PATH)/lib/libboost_filesystem.a $(BOOST_PATH)/lib/libboost_atomic.a $(BOOST_PATH)/lib/libboost_program_options.a $(BOOST_PATH)/lib/libboost_regex.a $(BOOST_PATH)/lib/libboost_system.a $(BOOST_PATH)/lib/libboost_thread.a $(DBL_CONV_PATH)/lib/libdouble-conversion.a $(FOLLY_PATH)/lib/libfolly.a $(FMT_LIB_PATH)/libfmt.a $(GLOG_LIB_PATH)/libglog.so $(GFLAGS_PATH)/lib/libgflags.so.2.2 -ldl
-	PLATFORM_LDFLAGS += -Wl,-rpath=$(GFLAGS_PATH)/lib -Wl,-rpath=$(GLOG_LIB_PATH) -Wl,-rpath=$(LIBEVENT_PATH)/lib -Wl,-rpath=$(LIBSODIUM_PATH)/lib -Wl,-rpath=$(LIBEVENT_PATH)/lib
-endif
-	PLATFORM_CCFLAGS += -DUSE_FOLLY -DFOLLY_NO_CONFIG
-	PLATFORM_CXXFLAGS += -DUSE_FOLLY -DFOLLY_NO_CONFIG
-endif
-
-ifeq ($(USE_FOLLY_LITE),1)
-	# Path to the Folly source code and include files
-	FOLLY_DIR = ./third-party/folly
 	# AIX: pre-defined system headers are surrounded by an extern "C" block
 	ifeq ($(PLATFORM), OS_AIX)
 		PLATFORM_CCFLAGS += -I$(FOLLY_DIR)
@@ -617,7 +550,7 @@ LIB_OBJECTS += $(patsubst %.c, $(OBJ_DIR)/%.o, $(LIB_SOURCES_C))
 LIB_OBJECTS += $(patsubst %.S, $(OBJ_DIR)/%.o, $(LIB_SOURCES_ASM))
 endif
 
-ifeq ($(USE_FOLLY_LITE),1)
+ifeq ($(USE_FOLLY),1)
   LIB_OBJECTS += $(patsubst %.cpp, $(OBJ_DIR)/%.o, $(FOLLY_SOURCES))
 endif
 
@@ -1949,7 +1882,7 @@ blob_garbage_meter_test: $(OBJ_DIR)/db/blob/blob_garbage_meter_test.o $(TEST_LIB
 timer_test: $(OBJ_DIR)/util/timer_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
-periodic_task_scheduler_test: $(OBJ_DIR)/db/periodic_task_scheduler_test.o $(TEST_LIBRARY) $(LIBRARY)
+periodic_work_scheduler_test: $(OBJ_DIR)/db/periodic_work_scheduler_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
 testutil_test: $(OBJ_DIR)/test_util/testutil_test.o $(TEST_LIBRARY) $(LIBRARY)
@@ -2438,26 +2371,13 @@ checkout_folly:
 	@# need to worry about folly breaking our integration. Update periodically
 	cd third-party/folly && git reset --hard beacd86d63cd71c904632262e6c36f60874d78ba
 	@# A hack to remove boost dependency.
-	@# NOTE: this hack is only needed if building using USE_FOLLY_LITE
+	@# NOTE: this hack is not needed if using FBCODE compiler config
 	perl -pi -e 's/^(#include <boost)/\/\/$$1/' third-party/folly/folly/functional/Invoke.h
 	@# NOTE: this hack is required for clang in some cases
 	perl -pi -e 's/int rv = syscall/int rv = (int)syscall/' third-party/folly/folly/detail/Futex.cpp
 	@# NOTE: this hack is required for gcc in some cases
 	perl -pi -e 's/(__has_include.<experimental.memory_resource>.)/__cpp_rtti && $$1/' third-party/folly/folly/memory/MemoryResource.h
 
-build_folly:
-	FOLLY_INST_PATH=`cd third-party/folly; $(PYTHON) build/fbcode_builder/getdeps.py show-inst-dir`; \
-	if [ "$$FOLLY_INST_PATH" ]; then \
-		rm -rf $${FOLLY_INST_PATH}/../../*; \
-	else \
-		echo "Please run checkout_folly first"; \
-		false; \
-	fi
-	# Restore the original version of Invoke.h with boost dependency
-	cd third-party/folly && ${GIT_COMMAND} checkout folly/functional/Invoke.h
-	cd third-party/folly && MAYBE_AVX2=`echo $(CXXFLAGS) | grep -o -- -DHAVE_AVX2 | sed 's/-DHAVE_AVX2/-mavx2/g' || true` && \
-		CXXFLAGS=" $$MAYBE_AVX2 -DHAVE_CXX11_ATOMIC " $(PYTHON) build/fbcode_builder/getdeps.py build --no-tests
-
 # ---------------------------------------------------------------------------
 #   Build size testing
 # ---------------------------------------------------------------------------
@@ -2542,7 +2462,7 @@ endif
 ifneq ($(SKIP_DEPENDS), 1)
 DEPFILES = $(patsubst %.cc, $(OBJ_DIR)/%.cc.d, $(ALL_SOURCES))
 DEPFILES+ = $(patsubst %.c, $(OBJ_DIR)/%.c.d, $(LIB_SOURCES_C) $(TEST_MAIN_SOURCES_C))
-ifeq ($(USE_FOLLY_LITE),1)
+ifeq ($(USE_FOLLY),1)
   DEPFILES +=$(patsubst %.cpp, $(OBJ_DIR)/%.cpp.d, $(FOLLY_SOURCES))
 endif
 endif

README.md

@@ -1,6 +1,7 @@
 ## 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)
 [![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)
 

TARGETS

@@ -13,14 +13,12 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "cache/cache_entry_roles.cc",
         "cache/cache_key.cc",
         "cache/cache_reservation_manager.cc",
-        "cache/charged_cache.cc",
         "cache/clock_cache.cc",
         "cache/compressed_secondary_cache.cc",
         "cache/fast_lru_cache.cc",
         "cache/lru_cache.cc",
         "cache/sharded_cache.cc",
         "db/arena_wrapped_db_iter.cc",
-        "db/blob/blob_contents.cc",
         "db/blob/blob_fetcher.cc",
         "db/blob/blob_file_addition.cc",
         "db/blob/blob_file_builder.cc",
@@ -83,7 +81,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "db/merge_helper.cc",
         "db/merge_operator.cc",
         "db/output_validator.cc",
-        "db/periodic_task_scheduler.cc",
+        "db/periodic_work_scheduler.cc",
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
@@ -100,7 +98,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "db/wal_edit.cc",
         "db/wal_manager.cc",
         "db/wide/wide_column_serialization.cc",
-        "db/wide/wide_columns.cc",
         "db/write_batch.cc",
         "db/write_batch_base.cc",
         "db/write_controller.cc",
@@ -253,7 +250,6 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
         "util/ribbon_config.cc",
         "util/slice.cc",
         "util/status.cc",
-        "util/stderr_logger.cc",
         "util/string_util.cc",
         "util/thread_local.cc",
         "util/threadpool_imp.cc",
@@ -352,14 +348,12 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "cache/cache_entry_roles.cc",
         "cache/cache_key.cc",
         "cache/cache_reservation_manager.cc",
-        "cache/charged_cache.cc",
         "cache/clock_cache.cc",
         "cache/compressed_secondary_cache.cc",
         "cache/fast_lru_cache.cc",
         "cache/lru_cache.cc",
         "cache/sharded_cache.cc",
         "db/arena_wrapped_db_iter.cc",
-        "db/blob/blob_contents.cc",
         "db/blob/blob_fetcher.cc",
         "db/blob/blob_file_addition.cc",
         "db/blob/blob_file_builder.cc",
@@ -422,7 +416,7 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "db/merge_helper.cc",
         "db/merge_operator.cc",
         "db/output_validator.cc",
-        "db/periodic_task_scheduler.cc",
+        "db/periodic_work_scheduler.cc",
         "db/range_del_aggregator.cc",
         "db/range_tombstone_fragmenter.cc",
         "db/repair.cc",
@@ -439,7 +433,6 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "db/wal_edit.cc",
         "db/wal_manager.cc",
         "db/wide/wide_column_serialization.cc",
-        "db/wide/wide_columns.cc",
         "db/write_batch.cc",
         "db/write_batch_base.cc",
         "db/write_controller.cc",
@@ -592,7 +585,6 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
         "util/ribbon_config.cc",
         "util/slice.cc",
         "util/status.cc",
-        "util/stderr_logger.cc",
         "util/string_util.cc",
         "util/thread_local.cc",
         "util/threadpool_imp.cc",
@@ -5602,8 +5594,8 @@ cpp_unittest_wrapper(name="perf_context_test",
             extra_compiler_flags=[])
 
 
-cpp_unittest_wrapper(name="periodic_task_scheduler_test",
-            srcs=["db/periodic_task_scheduler_test.cc"],
+cpp_unittest_wrapper(name="periodic_work_scheduler_test",
+            srcs=["db/periodic_work_scheduler_test.cc"],
             deps=[":rocksdb_test_lib"],
             extra_compiler_flags=[])
 

build_tools/benchmark_log_tool.py

@@ -62,11 +62,7 @@ class BenchmarkUtils:
 
     def conform_opensearch(row):
         (dt, _) = parser.parse(row['date'], fuzzy_with_tokens=True)
-        # create a test_date field, which was previously what was expected
-        # repair the date field, which has what can be a WRONG ISO FORMAT, (no leading 0 on single-digit day-of-month)
-        # e.g. 2022-07-1T00:14:55 should be 2022-07-01T00:14:55
         row['test_date'] = dt.isoformat()
-        row['date'] = dt.isoformat()
         return dict((key.replace('.', '_'), value)
                     for (key, value) in row.items())
 

build_tools/build_detect_platform

@@ -277,7 +277,6 @@ if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
     if [ "$FBCODE_BUILD" = "true" ]; then
       # Enable backtrace on fbcode since the necessary libraries are present
       COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
-      FOLLY_DIR="third-party/folly"
     fi
     true
 else
@@ -602,17 +601,6 @@ EOF
             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbenchmark"
         fi
     fi
-    if test $USE_FOLLY; then
-        # Test whether libfolly library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
-          #include <folly/synchronization/DistributedMutex.h>
-          int main() {}
-EOF
-        if [ "$?" != 0 ]; then
-          FOLLY_DIR="./third-party/folly"
-        fi
-    fi
-
 fi
 
 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
@@ -839,13 +827,6 @@ fi
 
 rm -f test.o test_dl.o
 
-# Get the path for the folly installation dir
-if [ "$USE_FOLLY" ]; then
-  if [ "$FOLLY_DIR" ]; then
-    FOLLY_PATH=`cd $FOLLY_DIR && $PYTHON build/fbcode_builder/getdeps.py show-inst-dir folly`
-  fi
-fi
-
 PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"
 
@@ -885,8 +866,6 @@ echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
 echo "FIND=$FIND" >> "$OUTPUT"
 echo "WATCH=$WATCH" >> "$OUTPUT"
-echo "FOLLY_PATH=$FOLLY_PATH" >> "$OUTPUT"
-
 # This will enable some related identifiers for the preprocessor
 if test -n "$JEMALLOC"; then
   echo "JEMALLOC=1" >> "$OUTPUT"

build_tools/dependencies_platform009.sh

@@ -19,4 +19,8 @@ BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/08634589372fa5f237bfd374e8c644a836
 VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/6ae525939ad02e5e676855082fbbc7828dbafeac/3.15.0/platform009/7f3b187
 LUA_BASE=/mnt/gvfs/third-party2/lua/162efd9561a3d21f6869f4814011e9cf1b3ff4dc/5.3.4/platform009/a6271c4
 BENCHMARK_BASE=/mnt/gvfs/third-party2/benchmark/30bf49ad6414325e17f3425b0edcb64239427ae3/1.6.1/platform009/7f3b187
-GLOG_BASE=/mnt/gvfs/third-party2/glog/32d751bd5673375b438158717ab6a57c1cc57e3d/0.3.2_fb/platform009/10a364d
+BOOST_BASE=/mnt/gvfs/third-party2/boost/201b7d74941e54b436dfa364a063aa6d2cd7de4c/1.69.0/platform009/8a7ffdf
+GLOG_BASE=/mnt/gvfs/third-party2/glog/32d751bd5673375b438158717ab6a57c1cc57e3d/0.3.2_fb/platform009/10a364d/
+FMT_BASE=/mnt/gvfs/third-party2/fmt/ce0c25f67165f4d2c22a29b8ef50f5600d7873ca/6.1.1/platform009/7f3b187/
+DBL_CONV_BASE=/mnt/gvfs/third-party2/double_conversion/109b3d9696d71f1048678cd7da1e22505470543d/20141126/platform009/7f3b187/
+LIBEVENT_BASE=/mnt/gvfs/third-party2/libevent/4a4d3a79a76c2439b6bd471bf3586b3481dde75e/1.4.14b_hphp/platform009/7f3b187/

build_tools/fbcode_config_platform009.sh

@@ -68,9 +68,20 @@ CFLAGS+=" -DGFLAGS=gflags"
 BENCHMARK_INCLUDE=" -I $BENCHMARK_BASE/include/"
 BENCHMARK_LIBS=" $BENCHMARK_BASE/lib/libbenchmark${MAYBE_PIC}.a"
 
+BOOST_INCLUDE=" -I $BOOST_BASE/include/"
+
 GLOG_INCLUDE=" -I $GLOG_BASE/include/"
 GLOG_LIBS=" $GLOG_BASE/lib/libglog${MAYBE_PIC}.a"
 
+FMT_INCLUDE=" -I $FMT_BASE/include/"
+FMT_LIBS=" $FMT_BASE/lib/libfmt${MAYBE_PIC}.a"
+
+DBL_CONV_INCLUDE=" -I $DBL_CONV_BASE/include/"
+DBL_CONV_LIBS=" $DBL_CONV_BASE/lib/libdouble-conversion${MAYBE_PIC}.a"
+
+LIBEVENT_INCLUDE=" -I $LIBEVENT_BASE/include/"
+LIBEVENT_LIBS=" $LIBEVENT_BASE/lib/libevent${MAYBE_PIC}.a"
+
 # location of jemalloc
 JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
 JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc${MAYBE_PIC}.a"
@@ -102,7 +113,7 @@ 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 $BENCHMARK_INCLUDE $GLOG_INCLUDE"
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE $BOOST_INCLUDE $GLOG_INCLUDE $FMT_INCLUDE $DBL_CONV_INCLUDE $LIBEVENT_INCLUDE"
 
 STDLIBS="-L $GCC_BASE/lib64"
 

build_tools/format-diff.sh

@@ -170,6 +170,11 @@ echo "$diffs" |
   sed -e "s/\(^-.*$\)/`echo -e \"$COLOR_RED\1$COLOR_END\"`/" |
   sed -e "s/\(^+.*$\)/`echo -e \"$COLOR_GREEN\1$COLOR_END\"`/"
 
+if [[ "$OPT" == *"-DTRAVIS"* ]]
+then
+  exit 1
+fi
+
 echo -e "Would you like to fix the format automatically (y/n): \c"
 
 # Make sure under any mode, we can read user input.

build_tools/ubuntu20_image/Dockerfile

@@ -1,56 +0,0 @@
-# from official ubuntu 20.04
-FROM ubuntu:20.04
-# update system
-RUN apt-get update && apt-get upgrade -y
-# install basic tools
-RUN apt-get install -y vim wget curl
-# install tzdata noninteractive
-RUN DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt-get -y install tzdata
-# install git and default compilers
-RUN apt-get install -y git gcc g++ clang clang-tools
-# install basic package
-RUN apt-get install -y lsb-release software-properties-common gnupg
-# install gflags, tbb
-RUN apt-get install -y libgflags-dev libtbb-dev
-# install compression libs
-RUN apt-get install -y libsnappy-dev zlib1g-dev libbz2-dev liblz4-dev libzstd-dev
-# install cmake
-RUN apt-get install -y cmake
-# install clang-13
-WORKDIR /root
-RUN wget https://apt.llvm.org/llvm.sh
-RUN chmod +x llvm.sh
-RUN ./llvm.sh 13 all
-# install gcc-7, 8, 10, 11, default is 9
-RUN apt-get install -y gcc-7 g++-7
-RUN apt-get install -y gcc-8 g++-8
-RUN apt-get install -y gcc-10 g++-10
-RUN add-apt-repository -y ppa:ubuntu-toolchain-r/test
-RUN apt-get install -y gcc-11 g++-11
-# install apt-get install -y valgrind
-RUN apt-get install -y valgrind
-# install folly depencencies
-RUN apt-get install -y libgoogle-glog-dev
-# install openjdk 8
-RUN apt-get install -y openjdk-8-jdk
-ENV JAVA_HOME /usr/lib/jvm/java-1.8.0-openjdk-amd64
-# install mingw
-RUN apt-get install -y mingw-w64
-
-# install gtest-parallel package
-RUN git clone --single-branch --branch master --depth 1 https://github.com/google/gtest-parallel.git ~/gtest-parallel
-ENV PATH $PATH:/root/gtest-parallel
-
-# install libprotobuf for fuzzers test
-RUN apt-get install -y ninja-build binutils liblzma-dev libz-dev pkg-config autoconf libtool
-RUN git clone --branch v1.0 https://github.com/google/libprotobuf-mutator.git ~/libprotobuf-mutator && cd ~/libprotobuf-mutator && git checkout ffd86a32874e5c08a143019aad1aaf0907294c9f && mkdir build && cd build && cmake .. -GNinja -DCMAKE_C_COMPILER=clang-13 -DCMAKE_CXX_COMPILER=clang++-13 -DCMAKE_BUILD_TYPE=Release -DLIB_PROTO_MUTATOR_DOWNLOAD_PROTOBUF=ON && ninja && ninja install
-ENV PKG_CONFIG_PATH /usr/local/OFF/:/root/libprotobuf-mutator/build/external.protobuf/lib/pkgconfig/
-ENV PROTOC_BIN /root/libprotobuf-mutator/build/external.protobuf/bin/protoc
-
-# install the latest google benchmark
-RUN git clone --depth 1 --branch v1.7.0 https://github.com/google/benchmark.git ~/benchmark
-RUN cd ~/benchmark && mkdir build && cd build && cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release -DBENCHMARK_ENABLE_GTEST_TESTS=0 && ninja && ninja install
-
-# clean up
-RUN rm -rf /var/lib/apt/lists/*
-RUN rm -rf /root/benchmark

cache/cache.cc

@@ -33,10 +33,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct LRUCacheOptions, high_pri_pool_ratio),
           OptionType::kDouble, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
-        {"low_pri_pool_ratio",
-         {offsetof(struct LRUCacheOptions, low_pri_pool_ratio),
-          OptionType::kDouble, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
 };
 
 static std::unordered_map<std::string, OptionTypeInfo>
@@ -58,11 +54,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
                    compress_format_version),
           OptionType::kUInt32T, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
-        {"enable_custom_split_merge",
-         {offsetof(struct CompressedSecondaryCacheOptions,
-                   enable_custom_split_merge),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
 };
 #endif  // ROCKSDB_LITE
 

cache/cache_bench_tool.cc

@@ -13,6 +13,7 @@
 #include <set>
 #include <sstream>
 
+#include "cache/clock_cache.h"
 #include "cache/fast_lru_cache.h"
 #include "db/db_impl/db_impl.h"
 #include "monitoring/histogram.h"
@@ -113,8 +114,6 @@ DEFINE_uint32(
     "(-stress_cache_key) Simulated file size in MiB, for accounting purposes");
 DEFINE_uint32(sck_reopen_nfiles, 100,
               "(-stress_cache_key) Simulate DB re-open average every n files");
-DEFINE_uint32(sck_newdb_nreopen, 1000,
-              "(-stress_cache_key) Simulate new DB average every n re-opens");
 DEFINE_uint32(sck_restarts_per_day, 24,
               "(-stress_cache_key) Average simulated process restarts per day "
               "(across DBs)");
@@ -291,20 +290,19 @@ class CacheBench {
     }
 
     if (FLAGS_cache_type == "clock_cache") {
-      fprintf(stderr, "Old clock cache implementation has been removed.\n");
-      exit(1);
-    } else if (FLAGS_cache_type == "hyper_clock_cache") {
-      cache_ = HyperClockCacheOptions(FLAGS_cache_size, FLAGS_value_bytes,
-                                      FLAGS_num_shard_bits)
-                   .MakeSharedCache();
+      cache_ = ExperimentalNewClockCache(
+          FLAGS_cache_size, FLAGS_value_bytes, FLAGS_num_shard_bits,
+          false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
+      if (!cache_) {
+        fprintf(stderr, "Clock cache not supported.\n");
+        exit(1);
+      }
     } else if (FLAGS_cache_type == "fast_lru_cache") {
       cache_ = NewFastLRUCache(
           FLAGS_cache_size, FLAGS_value_bytes, FLAGS_num_shard_bits,
           false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
     } else if (FLAGS_cache_type == "lru_cache") {
-      LRUCacheOptions opts(FLAGS_cache_size, FLAGS_num_shard_bits,
-                           false /* strict_capacity_limit */,
-                           0.5 /* high_pri_pool_ratio */);
+      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(
@@ -439,8 +437,6 @@ class CacheBench {
     uint64_t total_key_size = 0;
     uint64_t total_charge = 0;
     uint64_t total_entry_count = 0;
-    uint64_t table_occupancy = 0;
-    uint64_t table_size = 0;
     std::set<Cache::DeleterFn> deleters;
     StopWatchNano timer(clock);
 
@@ -456,9 +452,6 @@ class CacheBench {
             std::ostringstream ostr;
             ostr << "Most recent cache entry stats:\n"
                  << "Number of entries: " << total_entry_count << "\n"
-                 << "Table occupancy: " << table_occupancy << " / "
-                 << table_size << " = "
-                 << (100.0 * table_occupancy / table_size) << "%\n"
                  << "Total charge: " << BytesToHumanString(total_charge) << "\n"
                  << "Average key size: "
                  << (1.0 * total_key_size / total_entry_count) << "\n"
@@ -495,8 +488,6 @@ class CacheBench {
       Cache::ApplyToAllEntriesOptions opts;
       opts.average_entries_per_lock = FLAGS_gather_stats_entries_per_lock;
       shared->GetCacheBench()->cache_->ApplyToAllEntries(fn, opts);
-      table_occupancy = shared->GetCacheBench()->cache_->GetOccupancyCount();
-      table_size = shared->GetCacheBench()->cache_->GetTableAddressCount();
       stats_hist->Add(timer.ElapsedNanos() / 1000);
     }
   }
@@ -789,7 +780,7 @@ class StressCacheKey {
 
   void RunOnce() {
     // Re-initialized simulated state
-    const size_t db_count = std::max(size_t{FLAGS_sck_db_count}, size_t{1});
+    const size_t db_count = FLAGS_sck_db_count;
     dbs_.reset(new TableProperties[db_count]{});
     const size_t table_mask = (size_t{1} << FLAGS_sck_table_bits) - 1;
     table_.reset(new uint64_t[table_mask + 1]{});
@@ -806,13 +797,13 @@ class StressCacheKey {
 
     process_count_ = 0;
     session_count_ = 0;
-    newdb_count_ = 0;
-    ResetProcess(/*newdbs*/ true);
+    ResetProcess();
 
     Random64 r{std::random_device{}()};
 
     uint64_t max_file_count =
         uint64_t{FLAGS_sck_files_per_day} * FLAGS_sck_days_per_run;
+    uint64_t file_size = FLAGS_sck_file_size_mb * uint64_t{1024} * 1024U;
     uint32_t report_count = 0;
     uint32_t collisions_this_run = 0;
     size_t db_i = 0;
@@ -825,9 +816,9 @@ class StressCacheKey {
       }
       // Any other periodic actions before simulating next file
       if (!FLAGS_sck_footer_unique_id && r.OneIn(FLAGS_sck_reopen_nfiles)) {
-        ResetSession(db_i, /*newdb*/ r.OneIn(FLAGS_sck_newdb_nreopen));
+        ResetSession(db_i);
       } else if (r.OneIn(restart_nfiles_)) {
-        ResetProcess(/*newdbs*/ false);
+        ResetProcess();
       }
       // Simulate next file
       OffsetableCacheKey ock;
@@ -840,7 +831,8 @@ class StressCacheKey {
       }
       bool is_stable;
       BlockBasedTable::SetupBaseCacheKey(&dbs_[db_i], /* ignored */ "",
-                                         /* ignored */ 42, &ock, &is_stable);
+                                         /* ignored */ 42, file_size, &ock,
+                                         &is_stable);
       assert(is_stable);
       // Get a representative cache key, which later we analytically generalize
       // to a range.
@@ -850,11 +842,13 @@ class StressCacheKey {
         reduced_key = GetSliceHash64(ck.AsSlice()) >> shift_away;
       } else if (FLAGS_sck_footer_unique_id) {
         // Special case: keep only file number, not session counter
-        reduced_key = DecodeFixed64(ck.AsSlice().data()) >> shift_away;
+        uint32_t a = DecodeFixed32(ck.AsSlice().data() + 4) >> shift_away_a;
+        uint32_t b = DecodeFixed32(ck.AsSlice().data() + 12) >> shift_away_b;
+        reduced_key = (uint64_t{a} << 32) + b;
       } else {
         // Try to keep file number and session counter (shift away other bits)
         uint32_t a = DecodeFixed32(ck.AsSlice().data()) << shift_away_a;
-        uint32_t b = DecodeFixed32(ck.AsSlice().data() + 4) >> shift_away_b;
+        uint32_t b = DecodeFixed32(ck.AsSlice().data() + 12) >> shift_away_b;
         reduced_key = (uint64_t{a} << 32) + b;
       }
       if (reduced_key == 0) {
@@ -876,7 +870,7 @@ class StressCacheKey {
         // Our goal is to predict probability of no collisions, not expected
         // number of collisions. To make the distinction, we have to get rid
         // of observing correlated collisions, which this takes care of:
-        ResetProcess(/*newdbs*/ false);
+        ResetProcess();
       } else {
         // Replace (end of lifetime for file that was in this slot)
         table_[pos] = reduced_key;
@@ -894,11 +888,10 @@ class StressCacheKey {
         }
         // Report
         printf(
-            "%" PRIu64 " days, %" PRIu64 " proc, %" PRIu64 " sess, %" PRIu64
-            " newdb, %u coll, occ %g%%, ejected %g%%      \r",
+            "%" PRIu64 " days, %" PRIu64 " proc, %" PRIu64
+            " sess, %u coll, occ %g%%, ejected %g%%   \r",
             file_count / FLAGS_sck_files_per_day, process_count_,
-            session_count_, newdb_count_ - FLAGS_sck_db_count,
-            collisions_this_run, 100.0 * sampled_count / 1000.0,
+            session_count_, collisions_this_run, 100.0 * sampled_count / 1000.0,
             100.0 * (1.0 - sampled_count / 1000.0 * table_mask / file_count));
         fflush(stdout);
       }
@@ -906,27 +899,16 @@ class StressCacheKey {
     collisions_ += collisions_this_run;
   }
 
-  void ResetSession(size_t i, bool newdb) {
+  void ResetSession(size_t i) {
     dbs_[i].db_session_id = DBImpl::GenerateDbSessionId(nullptr);
-    if (newdb) {
-      ++newdb_count_;
-      if (FLAGS_sck_footer_unique_id) {
-        // Simulate how footer id would behave
-        dbs_[i].db_id = "none";
-      } else {
-        // db_id might be ignored, depending on the implementation details
-        dbs_[i].db_id = std::to_string(newdb_count_);
-        dbs_[i].orig_file_number = 0;
-      }
-    }
     session_count_++;
   }
 
-  void ResetProcess(bool newdbs) {
+  void ResetProcess() {
     process_count_++;
     DBImpl::TEST_ResetDbSessionIdGen();
     for (size_t i = 0; i < FLAGS_sck_db_count; ++i) {
-      ResetSession(i, newdbs);
+      ResetSession(i);
     }
     if (FLAGS_sck_footer_unique_id) {
       // For footer unique ID, this tracks process-wide generated SST file
@@ -941,7 +923,6 @@ class StressCacheKey {
   std::unique_ptr<uint64_t[]> table_;
   uint64_t process_count_ = 0;
   uint64_t session_count_ = 0;
-  uint64_t newdb_count_ = 0;
   uint64_t collisions_ = 0;
   uint32_t restart_nfiles_ = 0;
   double multiplier_ = 0.0;

cache/cache_entry_roles.cc

@@ -23,8 +23,6 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
     "FilterConstruction",
     "BlockBasedTableReader",
     "FileMetadata",
-    "BlobValue",
-    "BlobCache",
     "Misc",
 }};
 
@@ -40,8 +38,6 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
     "filter-construction",
     "block-based-table-reader",
     "file-metadata",
-    "blob-value",
-    "blob-cache",
     "misc",
 }};
 

cache/cache_key.cc

@@ -17,7 +17,7 @@ namespace ROCKSDB_NAMESPACE {
 
 // Value space plan for CacheKey:
 //
-// file_num_etc64_ | offset_etc64_ | Only generated by
+// session_etc64_ | offset_etc64_ | Only generated by
 // ---------------+---------------+------------------------------------------
 //              0 |             0 | Reserved for "empty" CacheKey()
 //              0 |  > 0, < 1<<63 | CreateUniqueForCacheLifetime
@@ -44,7 +44,7 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
   return CacheKey(0, id);
 }
 
-// How we generate CacheKeys and base OffsetableCacheKey, assuming that
+// Value plan for CacheKeys from OffsetableCacheKey, assuming that
 // db_session_ids are generated from a base_session_id and
 // session_id_counter (by SemiStructuredUniqueIdGen+EncodeSessionId
 // in DBImpl::GenerateDbSessionId):
@@ -56,108 +56,63 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 //   base_session_id         (unstructured, from GenerateRawUniqueId)
 //   session_id_counter      (structured)
 //                           * usually much smaller than 2**24
-//   orig_file_number        (structured)
+//   file_number             (structured)
 //                           * usually smaller than 2**24
 //   offset_in_file          (structured, might skip lots of values)
 //                           * usually smaller than 2**32
+//   max_offset              determines placement of file_number to prevent
+//                           overlapping with offset
 //
-// Overall approach (see https://github.com/pdillinger/unique_id for
-// background):
+// Outputs come from bitwise-xor of the constituent pieces, low bits on left:
 //
-// First, we have three "structured" values, up to 64 bits each, that we
-// need to fit, without losses, into 128 bits. In practice, the values will
-// be small enough that they should fit. For example, applications generating
-// large SST files (large offsets) will naturally produce fewer files (small
-// file numbers). But we don't know ahead of time what bounds the values will
-// have.
-//
-// Second, we have unstructured inputs that enable distinct RocksDB processes
-// to pick a random point in space, likely very different from others. Xoring
-// the structured with the unstructured give us a cache key that is
-// structurally distinct between related keys (e.g. same file or same RocksDB
-// process) and distinct with high probability between unrelated keys.
-//
-// The problem of packing three structured values into the space for two is
-// complicated by the fact that we want to derive cache keys from SST unique
-// IDs, which have already combined structured and unstructured inputs in a
-// practically inseparable way. And we want a base cache key that works
-// with an offset of any size. So basically, we need to encode these three
-// structured values, each up to 64 bits, into 128 bits without knowing any
-// of their sizes. The DownwardInvolution() function gives us a mechanism to
-// accomplish this. (See its properties in math.h.) Specifically, for inputs
-// a, b, and c:
-//   lower64 = DownwardInvolution(a) ^ ReverseBits(b);
-//   upper64 = c ^ ReverseBits(a);
-// The 128-bit output is unique assuming there exist some i, j, and k
-// where a < 2**i, b < 2**j, c < 2**k, i <= 64, j <= 64, k <= 64, and
-// i + j + k <= 128. In other words, as long as there exist some bounds
-// that would allow us to pack the bits of a, b, and c into the output
-// if we know the bound, we can generate unique outputs without knowing
-// those bounds. To validate this claim, the inversion function (given
-// the bounds) has been implemented in CacheKeyDecoder in
-// db_block_cache_test.cc.
-//
-// With that in mind, the outputs in terms of the conceptual inputs look
-// like this, using bitwise-xor of the constituent pieces, low bits on left:
-//
-// |------------------------- file_num_etc64 -------------------------|
-// | +++++++++ base_session_id (lower 64 bits, involution) +++++++++ |
+// |------------------------- session_etc64 -------------------------|
+// | +++++++++++++++ base_session_id (lower 64 bits) +++++++++++++++ |
 // |-----------------------------------------------------------------|
-// | session_id_counter (involution) ..... |                         |
+// | session_id_counter ...|                                         |
 // |-----------------------------------------------------------------|
-// | hash of: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
-// |  * base_session_id (upper ~39 bits)                             |
-// |  * db_id (~122 bits entropy)                                    |
-// |-----------------------------------------------------------------|
-// |                             | ..... orig_file_number (reversed) |
+// |                                               | ... file_number |
+// |                                               | overflow & meta |
 // |-----------------------------------------------------------------|
 //
 //
 // |------------------------- offset_etc64 --------------------------|
-// | ++++++++++ base_session_id (lower 64 bits, reversed) ++++++++++ |
-// |-----------------------------------------------------------------|
-// |                           | ..... session_id_counter (reversed) |
+// | hash of: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
+// |  * base_session_id (upper ~39 bits)                             |
+// |  * db_id (~122 bits entropy)                                    |
 // |-----------------------------------------------------------------|
 // | offset_in_file ............... |                                |
 // |-----------------------------------------------------------------|
+// |                                              | file_number, 0-3 |
+// |                                              | lower bytes      |
+// |-----------------------------------------------------------------|
 //
-// Some oddities or inconveniences of this layout are due to deriving
-// the "base" cache key (without offset) from the SST unique ID (see
-// GetSstInternalUniqueId). Specifically,
-// * Lower 64 of base_session_id occurs in both output words (ok but
-//   weird)
-// * The inclusion of db_id is bad for the conditions under which we
-//   can guarantee uniqueness, but could be useful in some cases with
-//   few small files per process, to make up for db session id only having
-//   ~103 bits of entropy.
+// Based on max_offset, a maximal number of bytes 0..3 is chosen for
+// including from lower bits of file_number in offset_etc64. The choice
+// is encoded in two bits of metadata going into session_etc64, though
+// the common case of 3 bytes is encoded as 0 so that session_etc64
+// is unmodified by file_number concerns in the common case.
 //
-// In fact, if DB ids were not involved, we would be guaranteed unique
-// cache keys for files generated in a single process until total bits for
-// biggest session_id_counter, orig_file_number, and offset_in_file
-// reach 128 bits.
+// There is nothing preventing "file number overflow & meta" from meeting
+// and overlapping with session_id_counter, but reaching such a case requires
+// an intractable combination of large file offsets (thus at least some large
+// files), large file numbers (thus large number of files generated), and
+// large number of session IDs generated in a single process. A trillion each
+// (2**40) of session ids, offsets, and file numbers comes to 120 bits.
+// With two bits of metadata and byte granularity, this is on the verge of
+// overlap, but even in the overlap case, it doesn't seem likely that
+// a file from billions of files or session ids ago will still be live
+// or cached.
 //
-// With the DB id limitation, we only have nice guaranteed unique cache
-// keys for files generated in a single process until biggest
-// session_id_counter and offset_in_file reach combined 64 bits. This
-// is quite good in practice because we can have millions of DB Opens
-// with terabyte size SST files, or billions of DB Opens with gigabyte
-// size SST files.
+// In fact, if our SST files are all < 4TB (see
+// BlockBasedTable::kMaxFileSizeStandardEncoding), then SST files generated
+// in a single process are guaranteed to have unique cache keys, unless/until
+// number session ids * max file number = 2**86, e.g. 1 trillion DB::Open in
+// a single process and 64 trillion files generated. Even at that point, to
+// see a collision we would need a miraculous re-synchronization of session
+// id and file number, along with a live file or stale cache entry from
+// trillions of files ago.
 //
-// One of the considerations in the translation between existing SST unique
-// IDs and base cache keys is supporting better SST unique IDs in a future
-// format_version. If we use a process-wide file counter instead of
-// session counter and file numbers, we only need to combine two 64-bit values
-// instead of three. But we don't want to track unique ID versions in the
-// manifest, so we want to keep the same translation layer between SST unique
-// IDs and base cache keys, even with updated SST unique IDs. If the new
-// unique IDs put the file counter where the orig_file_number was, and
-// use no structured field where session_id_counter was, then our translation
-// layer works fine for two structured fields as well as three (for
-// compatibility). The small computation for the translation (one
-// DownwardInvolution(), two ReverseBits(), both ~log(64) instructions deep)
-// is negligible for computing as part of SST file reader open.
-//
-// More on how https://github.com/pdillinger/unique_id applies here:
+// How https://github.com/pdillinger/unique_id applies here:
 // Every bit of output always includes "unstructured" uniqueness bits and
 // often combines with "structured" uniqueness bits. The "unstructured" bits
 // change infrequently: only when we cannot guarantee our state tracking for
@@ -186,11 +141,12 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 // 128 bits cache key size
 // - 55 <- ideal size for byte offsets + file numbers
 // -  2 <- bits for offsets and file numbers not exactly powers of two
+// -  2 <- bits for file number encoding metadata
 // +  2 <- bits saved not using byte offsets in BlockBasedTable::GetCacheKey
 // ----
-//   73 <- bits remaining for distinguishing session IDs
-// The probability of a collision in 73 bits of session ID data is less than
-// 1 in 2**(73 - (2 * 16)), or roughly 1 in a trillion. And this assumes all
+//   71 <- bits remaining for distinguishing session IDs
+// The probability of a collision in 71 bits of session ID data is less than
+// 1 in 2**(71 - (2 * 16)), or roughly 1 in a trillion. And this assumes all
 // data from the last 180 days is in cache for potential collision, and that
 // cache keys under each session id exhaustively cover the remaining 57 bits
 // while in reality they'll only cover a small fraction of it.
@@ -204,7 +160,7 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 // Now suppose we have many DBs per host, say 2**10, with same host-wide write
 // rate and process/session lifetime. File numbers will be ~10 bits smaller
 // and we will have 2**10 times as many session IDs because of simultaneous
-// lifetimes. So now collision chance is less than 1 in 2**(83 - (2 * 26)),
+// lifetimes. So now collision chance is less than 1 in 2**(81 - (2 * 26)),
 // or roughly 1 in a billion.
 //
 // Suppose instead we generated random or hashed cache keys for each
@@ -220,17 +176,17 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 // activity over many months, by making some pessimistic simplifying
 // assumptions. See class StressCacheKey in cache_bench_tool.cc for details.
 // Here is some sample output with
-// `./cache_bench -stress_cache_key -sck_keep_bits=43`:
+// `./cache_bench -stress_cache_key -sck_keep_bits=40`:
 //
 //   Total cache or DBs size: 32TiB  Writing 925.926 MiB/s or 76.2939TiB/day
-//   Multiply by 1.15292e+18 to correct for simulation losses (but still
+//   Multiply by 9.22337e+18 to correct for simulation losses (but still
 //   assume whole file cached)
 //
 // These come from default settings of 2.5M files per day of 32 MB each, and
-// `-sck_keep_bits=43` means that to represent a single file, we are only
-// keeping 43 bits of the 128-bit (base) cache key.  With file size of 2**25
-// contiguous keys (pessimistic), our simulation is about 2\*\*(128-43-25) or
-// about 1 billion billion times more prone to collision than reality.
+// `-sck_keep_bits=40` means that to represent a single file, we are only
+// keeping 40 bits of the 128-bit (base) cache key.  With file size of 2**25
+// contiguous keys (pessimistic), our simulation is about 2\*\*(128-40-25) or
+// about 9 billion billion times more prone to collision than reality.
 //
 // More default assumptions, relatively pessimistic:
 // * 100 DBs in same process (doesn't matter much)
@@ -238,55 +194,49 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 // average every 100 files generated
 // * Restart process (all new session IDs unrelated to old) 24 times per day
 //
-// After enough data, we get a result at the end (-sck_keep_bits=43):
+// After enough data, we get a result at the end (-sck_keep_bits=40):
 //
-//   (keep 43 bits)  18 collisions after 2 x 90 days, est 10 days between
-//                   (1.15292e+19 corrected)
+//   (keep 40 bits)  17 collisions after 2 x 90 days, est 10.5882 days between
+//                   (9.76592e+19 corrected)
 //
 // If we believe the (pessimistic) simulation and the mathematical
-// extrapolation, we would need to run a billion machines all for 11 billion
+// extrapolation, we would need to run a billion machines all for 97 billion
 // days to expect a cache key collision. To help verify that our extrapolation
-// ("corrected") is robust, we can make our simulation more precise by
-// increasing the "keep" bits, which takes more running time to get enough
+// ("corrected") is robust, we can make our simulation more precise with
+// `-sck_keep_bits=41` and `42`, which takes more running time to get enough
 // collision data:
 //
-//   (keep 44 bits)  16 collisions after 5 x 90 days, est 28.125 days between
-//                   (1.6213e+19 corrected)
-//   (keep 45 bits)  15 collisions after 7 x 90 days, est 42 days between
-//                   (1.21057e+19 corrected)
-//   (keep 46 bits)  15 collisions after 17 x 90 days, est 102 days between
-//                   (1.46997e+19 corrected)
-//   (keep 47 bits)  15 collisions after 49 x 90 days, est 294 days between
-//                   (2.11849e+19 corrected)
+//   (keep 41 bits)  16 collisions after 4 x 90 days, est 22.5 days between
+//                   (1.03763e+20 corrected)
+//   (keep 42 bits)  19 collisions after 10 x 90 days, est 47.3684 days between
+//                   (1.09224e+20 corrected)
 //
-// The extrapolated prediction seems to be within noise (sampling error).
+// The extrapolated prediction is very close. If anything, we might have some
+// very small losses of structured data (see class StressCacheKey in
+// cache_bench_tool.cc) leading to more accurate & more attractive prediction
+// with more bits kept.
 //
 // With the `-sck_randomize` option, we can see that typical workloads like
 // above have lower collision probability than "random" cache keys (note:
-// offsets still non-randomized) by a modest amount (roughly 2-3x less
-// collision prone than random), which should make us reasonably comfortable
-// even in "degenerate" cases (e.g. repeatedly launch a process to generate
-// one file with SstFileWriter):
+// offsets still non-randomized) by a modest amount (roughly 20x less collision
+// prone than random), which should make us reasonably comfortable even in
+// "degenerate" cases (e.g. repeatedly launch a process to generate 1 file
+// with SstFileWriter):
 //
-//   (rand 43 bits) 22 collisions after 1 x 90 days, est 4.09091 days between
-//                  (4.7165e+18 corrected)
+//   (rand 40 bits) 197 collisions after 1 x 90 days, est 0.456853 days between
+//                  (4.21372e+18 corrected)
 //
-// We can see that with more frequent process restarts,
-// -sck_restarts_per_day=5000, which means more all-new session IDs, we get
-// closer to the "random" cache key performance:
+// We can see that with more frequent process restarts (all new session IDs),
+// we get closer to the "random" cache key performance:
 //
-// 15 collisions after 1 x 90 days, est 6 days between (6.91753e+18 corrected)
-//
-// And with less frequent process restarts and re-opens,
-// -sck_restarts_per_day=1 -sck_reopen_nfiles=1000, we get lower collision
-// probability:
-//
-// 18 collisions after 8 x 90 days, est 40 days between (4.61169e+19 corrected)
+//   (-sck_restarts_per_day=5000): 140 collisions after 1 x 90 days, ...
+//                  (5.92931e+18 corrected)
 //
 // Other tests have been run to validate other conditions behave as expected,
 // never behaving "worse than random" unless we start chopping off structured
 // data.
 //
+//
 // Conclusion: Even in extreme cases, rapidly burning through "all new" IDs
 // that only arise when a new process is started, the chance of any cache key
 // collisions in a giant fleet of machines is negligible. Especially when
@@ -299,66 +249,96 @@ CacheKey CacheKey::CreateUniqueForProcessLifetime() {
 // quantify) block cache corruptions, including collisions, should be added.
 OffsetableCacheKey::OffsetableCacheKey(const std::string &db_id,
                                        const std::string &db_session_id,
-                                       uint64_t file_number) {
-  UniqueId64x2 internal_id;
-  Status s = GetSstInternalUniqueId(db_id, db_session_id, file_number,
-                                    &internal_id, /*force=*/true);
-  assert(s.ok());
-  *this = FromInternalUniqueId(&internal_id);
-}
-
-OffsetableCacheKey OffsetableCacheKey::FromInternalUniqueId(UniqueIdPtr id) {
-  uint64_t session_lower = id.ptr[0];
-  uint64_t file_num_etc = id.ptr[1];
-
+                                       uint64_t file_number,
+                                       uint64_t max_offset) {
 #ifndef NDEBUG
-  bool is_empty = session_lower == 0 && file_num_etc == 0;
+  max_offset_ = max_offset;
 #endif
+  // Closely related to GetSstInternalUniqueId, but only need 128 bits and
+  // need to include an offset within the file.
+  // See also https://github.com/pdillinger/unique_id for background.
+  uint64_t session_upper = 0;  // Assignment to appease clang-analyze
+  uint64_t session_lower = 0;  // Assignment to appease clang-analyze
+  {
+    Status s = DecodeSessionId(db_session_id, &session_upper, &session_lower);
+    if (!s.ok()) {
+      // A reasonable fallback in case malformed
+      Hash2x64(db_session_id.data(), db_session_id.size(), &session_upper,
+               &session_lower);
+    }
+  }
+
+  // Hash the session upper (~39 bits entropy) and DB id (120+ bits entropy)
+  // for more global uniqueness entropy.
+  // (It is possible that many DBs descended from one common DB id are copied
+  // around and proliferate, in which case session id is critical, but it is
+  // more common for different DBs to have different DB ids.)
+  uint64_t db_hash = Hash64(db_id.data(), db_id.size(), session_upper);
+
+  // This establishes the db+session id part of the cache key.
+  //
+  // Exactly preserve (in common cases; see modifiers below) session lower to
+  // ensure that session ids generated during the same process lifetime are
+  // guaranteed unique.
+  //
+  // We put this first for CommonPrefixSlice(), so that a small-ish set of
+  // cache key prefixes to cover entries relevant to any DB.
+  session_etc64_ = session_lower;
+  // This provides extra entopy in case of different DB id or process
+  // generating a session id, but is also partly/variably obscured by
+  // file_number and offset (see below).
+  offset_etc64_ = db_hash;
+
+  // Into offset_etc64_ we are (eventually) going to pack & xor in an offset and
+  // a file_number, but we might need the file_number to overflow into
+  // session_etc64_. (There must only be one session_etc64_ value per
+  // file, and preferably shared among many files.)
+  //
+  // Figure out how many bytes of file_number we are going to be able to
+  // pack in with max_offset, though our encoding will only support packing
+  // in up to 3 bytes of file_number. (16M file numbers is enough for a new
+  // file number every second for half a year.)
+  int file_number_bytes_in_offset_etc =
+      (63 - FloorLog2(max_offset | 0x100000000U)) / 8;
+  int file_number_bits_in_offset_etc = file_number_bytes_in_offset_etc * 8;
+
+  // Assert two bits of metadata
+  assert(file_number_bytes_in_offset_etc >= 0 &&
+         file_number_bytes_in_offset_etc <= 3);
+  // Assert we couldn't have used a larger allowed number of bytes (shift
+  // would chop off bytes).
+  assert(file_number_bytes_in_offset_etc == 3 ||
+         (max_offset << (file_number_bits_in_offset_etc + 8) >>
+          (file_number_bits_in_offset_etc + 8)) != max_offset);
+
+  uint64_t mask = (uint64_t{1} << (file_number_bits_in_offset_etc)) - 1;
+  // Pack into high bits of etc so that offset can go in low bits of etc
+  // TODO: could be EndianSwapValue?
+  uint64_t offset_etc_modifier = ReverseBits(file_number & mask);
+  assert(offset_etc_modifier << file_number_bits_in_offset_etc == 0U);
+
+  // Overflow and 3 - byte count (likely both zero) go into session_id part
+  uint64_t session_etc_modifier =
+      (file_number >> file_number_bits_in_offset_etc << 2) |
+      static_cast<uint64_t>(3 - file_number_bytes_in_offset_etc);
+  // Packed into high bits to minimize interference with session id counter.
+  session_etc_modifier = ReverseBits(session_etc_modifier);
+
+  // Assert session_id part is only modified in extreme cases
+  assert(session_etc_modifier == 0 || file_number > /*3 bytes*/ 0xffffffU ||
+         max_offset > /*5 bytes*/ 0xffffffffffU);
+
+  // Xor in the modifiers
+  session_etc64_ ^= session_etc_modifier;
+  offset_etc64_ ^= offset_etc_modifier;
 
   // Although DBImpl guarantees (in recent versions) that session_lower is not
-  // zero, that's not entirely sufficient to guarantee that file_num_etc64_ is
+  // zero, that's not entirely sufficient to guarantee that session_etc64_ is
   // not zero (so that the 0 case can be used by CacheKey::CreateUnique*)
-  // However, if we are given an "empty" id as input, then we should produce
-  // "empty" as output.
-  // As a consequence, this function is only bijective assuming
-  // id[0] == 0 only if id[1] == 0.
-  if (session_lower == 0U) {
-    session_lower = file_num_etc;
+  if (session_etc64_ == 0U) {
+    session_etc64_ = session_upper | 1U;
   }
-
-  // See comments above for how DownwardInvolution and ReverseBits
-  // make this function invertible under various assumptions.
-  OffsetableCacheKey rv;
-  rv.file_num_etc64_ =
-      DownwardInvolution(session_lower) ^ ReverseBits(file_num_etc);
-  rv.offset_etc64_ = ReverseBits(session_lower);
-
-  // Because of these transformations and needing to allow arbitrary
-  // offset (thus, second 64 bits of cache key might be 0), we need to
-  // make some correction to ensure the first 64 bits is not 0.
-  // Fortunately, the transformation ensures the second 64 bits is not 0
-  // for non-empty base key, so we can swap in the case one is 0 without
-  // breaking bijectivity (assuming condition above).
-  assert(is_empty || rv.offset_etc64_ > 0);
-  if (rv.file_num_etc64_ == 0) {
-    std::swap(rv.file_num_etc64_, rv.offset_etc64_);
-  }
-  assert(is_empty || rv.file_num_etc64_ > 0);
-  return rv;
-}
-
-// Inverse of FromInternalUniqueId (assuming file_num_etc64 == 0 only if
-// offset_etc64 == 0)
-UniqueId64x2 OffsetableCacheKey::ToInternalUniqueId() {
-  uint64_t a = file_num_etc64_;
-  uint64_t b = offset_etc64_;
-  if (b == 0) {
-    std::swap(a, b);
-  }
-  UniqueId64x2 rv;
-  rv[0] = ReverseBits(b);
-  rv[1] = ReverseBits(a ^ DownwardInvolution(rv[0]));
-  return rv;
+  assert(session_etc64_ != 0);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

cache/cache_key.h

@@ -9,7 +9,6 @@
 
 #include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/slice.h"
-#include "table/unique_id_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -34,10 +33,10 @@ class CacheKey {
  public:
   // For convenience, constructs an "empty" cache key that is never returned
   // by other means.
-  inline CacheKey() : file_num_etc64_(), offset_etc64_() {}
+  inline CacheKey() : session_etc64_(), offset_etc64_() {}
 
   inline bool IsEmpty() const {
-    return (file_num_etc64_ == 0) & (offset_etc64_ == 0);
+    return (session_etc64_ == 0) & (offset_etc64_ == 0);
   }
 
   // Use this cache key as a Slice (byte order is endianness-dependent)
@@ -60,9 +59,9 @@ class CacheKey {
 
  protected:
   friend class OffsetableCacheKey;
-  CacheKey(uint64_t file_num_etc64, uint64_t offset_etc64)
-      : file_num_etc64_(file_num_etc64), offset_etc64_(offset_etc64) {}
-  uint64_t file_num_etc64_;
+  CacheKey(uint64_t session_etc64, uint64_t offset_etc64)
+      : session_etc64_(session_etc64), offset_etc64_(offset_etc64) {}
+  uint64_t session_etc64_;
   uint64_t offset_etc64_;
 };
 
@@ -86,58 +85,50 @@ class OffsetableCacheKey : private CacheKey {
   inline OffsetableCacheKey() : CacheKey() {}
 
   // Constructs an OffsetableCacheKey with the given information about a file.
-  // This constructor never generates an "empty" base key.
+  // max_offset is based on file size (see WithOffset) and is required here to
+  // choose an appropriate (sub-)encoding. This constructor never generates an
+  // "empty" base key.
   OffsetableCacheKey(const std::string &db_id, const std::string &db_session_id,
-                     uint64_t file_number);
-
-  // Creates an OffsetableCacheKey from an SST unique ID, so that cache keys
-  // can be derived from DB manifest data before reading the file from
-  // storage--so that every part of the file can potentially go in a persistent
-  // cache.
-  //
-  // Calling GetSstInternalUniqueId() on a db_id, db_session_id, and
-  // file_number and passing the result to this function produces the same
-  // base cache key as feeding those inputs directly to the constructor.
-  //
-  // This is a bijective transformation assuming either id is empty or
-  // lower 64 bits is non-zero:
-  // * Empty (all zeros) input -> empty (all zeros) output
-  // * Lower 64 input is non-zero -> lower 64 output (file_num_etc64_) is
-  //   non-zero
-  static OffsetableCacheKey FromInternalUniqueId(UniqueIdPtr id);
-
-  // This is the inverse transformation to the above, assuming either empty
-  // or lower 64 bits (file_num_etc64_) is non-zero. Perhaps only useful for
-  // testing.
-  UniqueId64x2 ToInternalUniqueId();
+                     uint64_t file_number, uint64_t max_offset);
 
   inline bool IsEmpty() const {
-    bool result = file_num_etc64_ == 0;
+    bool result = session_etc64_ == 0;
     assert(!(offset_etc64_ > 0 && result));
     return result;
   }
 
-  // Construct a CacheKey for an offset within a file. An offset is not
-  // necessarily a byte offset if a smaller unique identifier of keyable
-  // offsets is used.
+  // Construct a CacheKey for an offset within a file, which must be
+  // <= max_offset provided in constructor. An offset is not necessarily a
+  // byte offset if a smaller unique identifier of keyable offsets is used.
   //
   // This class was designed to make this hot code extremely fast.
   inline CacheKey WithOffset(uint64_t offset) const {
     assert(!IsEmpty());
-    return CacheKey(file_num_etc64_, offset_etc64_ ^ offset);
+    assert(offset <= max_offset_);
+    return CacheKey(session_etc64_, offset_etc64_ ^ offset);
   }
 
-  // The "common prefix" is a shared prefix for all the returned CacheKeys.
-  // It is specific to the file but the same for all offsets within the file.
+  // The "common prefix" is a shared prefix for all the returned CacheKeys,
+  // that also happens to usually be the same among many files in the same DB,
+  // so is efficient and highly accurate (not perfectly) for DB-specific cache
+  // dump selection (but not file-specific).
   static constexpr size_t kCommonPrefixSize = 8;
   inline Slice CommonPrefixSlice() const {
-    static_assert(sizeof(file_num_etc64_) == kCommonPrefixSize,
+    static_assert(sizeof(session_etc64_) == kCommonPrefixSize,
                   "8 byte common prefix expected");
     assert(!IsEmpty());
-    assert(&this->file_num_etc64_ == static_cast<const void *>(this));
+    assert(&this->session_etc64_ == static_cast<const void *>(this));
 
     return Slice(reinterpret_cast<const char *>(this), kCommonPrefixSize);
   }
+
+  // For any max_offset <= this value, the same encoding scheme is guaranteed.
+  static constexpr uint64_t kMaxOffsetStandardEncoding = 0xffffffffffU;
+
+ private:
+#ifndef NDEBUG
+  uint64_t max_offset_ = 0;
+#endif
 };
 
 }  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager.cc

@@ -181,5 +181,4 @@ template class CacheReservationManagerImpl<CacheEntryRole::kFilterConstruction>;
 template class CacheReservationManagerImpl<CacheEntryRole::kMisc>;
 template class CacheReservationManagerImpl<CacheEntryRole::kWriteBuffer>;
 template class CacheReservationManagerImpl<CacheEntryRole::kFileMetadata>;
-template class CacheReservationManagerImpl<CacheEntryRole::kBlobCache>;
 }  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager_test.cc

@@ -48,13 +48,13 @@ TEST_F(CacheReservationManagerTest, GenerateCacheKey) {
   // Next unique Cache key
   CacheKey ckey = CacheKey::CreateUniqueForCacheLifetime(cache.get());
   // Get to the underlying values
-  uint64_t* ckey_data = reinterpret_cast<uint64_t*>(&ckey);
+  using PairU64 = std::array<uint64_t, 2>;
+  auto& ckey_pair = *reinterpret_cast<PairU64*>(&ckey);
   // Back it up to the one used by CRM (using CacheKey implementation details)
-  ckey_data[1]--;
+  ckey_pair[1]--;
 
   // Specific key (subject to implementation details)
-  EXPECT_EQ(ckey_data[0], 0);
-  EXPECT_EQ(ckey_data[1], 2);
+  EXPECT_EQ(ckey_pair, PairU64({0, 2}));
 
   Cache::Handle* handle = cache->Lookup(ckey.AsSlice());
   EXPECT_NE(handle, nullptr)

cache/cache_test.cc

@@ -15,6 +15,7 @@
 #include <string>
 #include <vector>
 
+#include "cache/clock_cache.h"
 #include "cache/fast_lru_cache.h"
 #include "cache/lru_cache.h"
 #include "port/stack_trace.h"
@@ -22,11 +23,6 @@
 #include "util/coding.h"
 #include "util/string_util.h"
 
-// FastLRUCache and HyperClockCache only support 16-byte keys, so some of
-// the tests originally wrote for LRUCache do not work on the other caches.
-// Those tests were adapted to use 16-byte keys. We kept the original ones.
-// TODO: Remove the original tests if they ever become unused.
-
 namespace ROCKSDB_NAMESPACE {
 
 namespace {
@@ -62,22 +58,17 @@ int DecodeValue(void* v) {
   return static_cast<int>(reinterpret_cast<uintptr_t>(v));
 }
 
-void DumbDeleter(const Slice& /*key*/, void* /*value*/) {}
+const std::string kLRU = "lru";
+const std::string kClock = "clock";
+const std::string kFast = "fast";
 
-void EraseDeleter1(const Slice& /*key*/, void* value) {
+void dumbDeleter(const Slice& /*key*/, void* /*value*/) {}
+
+void eraseDeleter(const Slice& /*key*/, void* value) {
   Cache* cache = reinterpret_cast<Cache*>(value);
   cache->Erase("foo");
 }
 
-void EraseDeleter2(const Slice& /*key*/, void* value) {
-  Cache* cache = reinterpret_cast<Cache*>(value);
-  cache->Erase(EncodeKey16Bytes(1234));
-}
-
-const std::string kLRU = "lru";
-const std::string kHyperClock = "hyper_clock";
-const std::string kFast = "fast";
-
 }  // anonymous namespace
 
 class CacheTest : public testing::TestWithParam<std::string> {
@@ -86,7 +77,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
   static std::string type_;
 
   static void Deleter(const Slice& key, void* v) {
-    if (type_ == kFast || type_ == kHyperClock) {
+    if (type_ == kFast || type_ == kClock) {
       current_->deleted_keys_.push_back(DecodeKey16Bytes(key));
     } else {
       current_->deleted_keys_.push_back(DecodeKey32Bits(key));
@@ -105,8 +96,6 @@ class CacheTest : public testing::TestWithParam<std::string> {
   std::shared_ptr<Cache> cache_;
   std::shared_ptr<Cache> cache2_;
 
-  size_t estimated_value_size_ = 1;
-
   CacheTest()
       : cache_(NewCache(kCacheSize, kNumShardBits, false)),
         cache2_(NewCache(kCacheSize2, kNumShardBits2, false)) {
@@ -121,14 +110,14 @@ class CacheTest : public testing::TestWithParam<std::string> {
     if (type == kLRU) {
       return NewLRUCache(capacity);
     }
-    if (type == kHyperClock) {
-      return HyperClockCacheOptions(
-                 capacity, estimated_value_size_ /*estimated_value_size*/)
-          .MakeSharedCache();
+    if (type == kClock) {
+      return ExperimentalNewClockCache(
+          capacity, 1 /*estimated_value_size*/, -1 /*num_shard_bits*/,
+          false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
     }
     if (type == kFast) {
       return NewFastLRUCache(
-          capacity, estimated_value_size_, -1 /*num_shard_bits*/,
+          capacity, 1 /*estimated_value_size*/, -1 /*num_shard_bits*/,
           false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
     }
     return nullptr;
@@ -147,11 +136,10 @@ class CacheTest : public testing::TestWithParam<std::string> {
       co.metadata_charge_policy = charge_policy;
       return NewLRUCache(co);
     }
-    if (type == kHyperClock) {
-      return HyperClockCacheOptions(capacity, 1 /*estimated_value_size*/,
-                                    num_shard_bits, strict_capacity_limit,
-                                    nullptr /*allocator*/, charge_policy)
-          .MakeSharedCache();
+    if (type == kClock) {
+      return ExperimentalNewClockCache(capacity, 1 /*estimated_value_size*/,
+                                       num_shard_bits, strict_capacity_limit,
+                                       charge_policy);
     }
     if (type == kFast) {
       return NewFastLRUCache(capacity, 1 /*estimated_value_size*/,
@@ -163,11 +151,12 @@ class CacheTest : public testing::TestWithParam<std::string> {
 
   // These functions encode/decode keys in tests cases that use
   // int keys.
-  // Currently, HyperClockCache requires keys to be 16B long, whereas
-  // LRUCache doesn't, so the encoding depends on the cache type.
+  // Currently, FastLRUCache requires keys to be 16B long, whereas
+  // LRUCache and ClockCache don't, so the encoding depends on
+  // the cache type.
   std::string EncodeKey(int k) {
     auto type = GetParam();
-    if (type == kFast || type == kHyperClock) {
+    if (type == kFast || type == kClock) {
       return EncodeKey16Bytes(k);
     } else {
       return EncodeKey32Bits(k);
@@ -176,7 +165,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
 
   int DecodeKey(const Slice& k) {
     auto type = GetParam();
-    if (type == kFast || type == kHyperClock) {
+    if (type == kFast || type == kClock) {
       return DecodeKey16Bytes(k);
     } else {
       return DecodeKey32Bits(k);
@@ -234,93 +223,65 @@ class LRUCacheTest : public CacheTest {};
 
 TEST_P(CacheTest, UsageTest) {
   auto type = GetParam();
+  if (type == kFast || type == kClock) {
+    ROCKSDB_GTEST_BYPASS("FastLRUCache and ClockCache require 16-byte keys.");
+    return;
+  }
 
   // cache is std::shared_ptr and will be automatically cleaned up.
-  const size_t kCapacity = 100000;
+  const uint64_t kCapacity = 100000;
   auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
   auto precise_cache = NewCache(kCapacity, 0, false, kFullChargeCacheMetadata);
   ASSERT_EQ(0, cache->GetUsage());
-  size_t baseline_meta_usage = precise_cache->GetUsage();
-  if (type != kHyperClock) {
-    ASSERT_EQ(0, baseline_meta_usage);
-  }
+  ASSERT_EQ(0, precise_cache->GetUsage());
 
   size_t usage = 0;
   char value[10] = "abcdef";
   // make sure everything will be cached
   for (int i = 1; i < 100; ++i) {
-    std::string key;
-    if (type == kLRU) {
-      key = std::string(i, 'a');
-    } else {
-      key = EncodeKey(i);
-    }
+    std::string key(i, 'a');
     auto kv_size = key.size() + 5;
     ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), kv_size,
-                            DumbDeleter));
+                            dumbDeleter));
     ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    kv_size, DumbDeleter));
+                                    kv_size, dumbDeleter));
     usage += kv_size;
     ASSERT_EQ(usage, cache->GetUsage());
-    if (type == kHyperClock) {
-      ASSERT_EQ(baseline_meta_usage + usage, precise_cache->GetUsage());
-    } else {
-      ASSERT_LT(usage, precise_cache->GetUsage());
-    }
+    ASSERT_LT(usage, precise_cache->GetUsage());
   }
 
   cache->EraseUnRefEntries();
   precise_cache->EraseUnRefEntries();
   ASSERT_EQ(0, cache->GetUsage());
-  ASSERT_EQ(baseline_meta_usage, precise_cache->GetUsage());
+  ASSERT_EQ(0, precise_cache->GetUsage());
 
   // make sure the cache will be overloaded
-  for (size_t i = 1; i < kCapacity; ++i) {
-    std::string key;
-    if (type == kLRU) {
-      key = std::to_string(i);
-    } else {
-      key = EncodeKey(static_cast<int>(1000 + i));
-    }
+  for (uint64_t i = 1; i < kCapacity; ++i) {
+    auto key = std::to_string(i);
     ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                            DumbDeleter));
+                            dumbDeleter));
     ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    key.size() + 5, DumbDeleter));
+                                    key.size() + 5, dumbDeleter));
   }
 
   // the usage should be close to the capacity
   ASSERT_GT(kCapacity, cache->GetUsage());
   ASSERT_GT(kCapacity, precise_cache->GetUsage());
   ASSERT_LT(kCapacity * 0.95, cache->GetUsage());
-  if (type != kHyperClock) {
-    ASSERT_LT(kCapacity * 0.95, precise_cache->GetUsage());
-  } else {
-    // estimated value size of 1 is weird for clock cache, because
-    // almost all of the capacity will be used for metadata, and due to only
-    // using power of 2 table sizes, we might hit strict occupancy limit
-    // before hitting capacity limit.
-    ASSERT_LT(kCapacity * 0.80, precise_cache->GetUsage());
-  }
+  ASSERT_LT(kCapacity * 0.95, precise_cache->GetUsage());
 }
 
-// TODO: This test takes longer than expected on ClockCache. This is
-// because the values size estimate at construction is too sloppy.
-// Fix this.
-// Why is it so slow? The cache is constructed with an estimate of 1, but
-// then the charge is claimed to be 21. This will cause the hash table
-// to be extremely sparse, which in turn means clock needs to scan too
-// many slots to find victims.
 TEST_P(CacheTest, PinnedUsageTest) {
   auto type = GetParam();
+  if (type == kFast || type == kClock) {
+    ROCKSDB_GTEST_BYPASS("FastLRUCache and ClockCache require 16-byte keys.");
+    return;
+  }
 
   // cache is std::shared_ptr and will be automatically cleaned up.
-  const size_t kCapacity = 200000;
+  const uint64_t kCapacity = 200000;
   auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
   auto precise_cache = NewCache(kCapacity, 8, false, kFullChargeCacheMetadata);
-  size_t baseline_meta_usage = precise_cache->GetUsage();
-  if (type != kHyperClock) {
-    ASSERT_EQ(0, baseline_meta_usage);
-  }
 
   size_t pinned_usage = 0;
   char value[10] = "abcdef";
@@ -331,20 +292,15 @@ TEST_P(CacheTest, PinnedUsageTest) {
   // Add entries. Unpin some of them after insertion. Then, pin some of them
   // again. Check GetPinnedUsage().
   for (int i = 1; i < 100; ++i) {
-    std::string key;
-    if (type == kLRU) {
-      key = std::string(i, 'a');
-    } else {
-      key = EncodeKey(i);
-    }
+    std::string key(i, 'a');
     auto kv_size = key.size() + 5;
     Cache::Handle* handle;
     Cache::Handle* handle_in_precise_cache;
     ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), kv_size,
-                            DumbDeleter, &handle));
+                            dumbDeleter, &handle));
     assert(handle);
     ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    kv_size, DumbDeleter,
+                                    kv_size, dumbDeleter,
                                     &handle_in_precise_cache));
     assert(handle_in_precise_cache);
     pinned_usage += kv_size;
@@ -378,17 +334,12 @@ TEST_P(CacheTest, PinnedUsageTest) {
   ASSERT_LT(pinned_usage, precise_cache_pinned_usage);
 
   // check that overloading the cache does not change the pinned usage
-  for (size_t i = 1; i < 2 * kCapacity; ++i) {
-    std::string key;
-    if (type == kLRU) {
-      key = std::to_string(i);
-    } else {
-      key = EncodeKey(static_cast<int>(1000 + i));
-    }
+  for (uint64_t i = 1; i < 2 * kCapacity; ++i) {
+    auto key = std::to_string(i);
     ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                            DumbDeleter));
+                            dumbDeleter));
     ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    key.size() + 5, DumbDeleter));
+                                    key.size() + 5, dumbDeleter));
   }
   ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
   ASSERT_EQ(precise_cache_pinned_usage, precise_cache->GetPinnedUsage());
@@ -410,7 +361,7 @@ TEST_P(CacheTest, PinnedUsageTest) {
   cache->EraseUnRefEntries();
   precise_cache->EraseUnRefEntries();
   ASSERT_EQ(0, cache->GetUsage());
-  ASSERT_EQ(baseline_meta_usage, precise_cache->GetUsage());
+  ASSERT_EQ(0, precise_cache->GetUsage());
 }
 
 TEST_P(CacheTest, HitAndMiss) {
@@ -427,30 +378,16 @@ TEST_P(CacheTest, HitAndMiss) {
   ASSERT_EQ(-1,  Lookup(300));
 
   Insert(100, 102);
-  if (GetParam() == kHyperClock) {
-    // ClockCache usually doesn't overwrite on Insert
-    ASSERT_EQ(101, Lookup(100));
-  } else {
-    ASSERT_EQ(102, Lookup(100));
-  }
+  ASSERT_EQ(102, Lookup(100));
   ASSERT_EQ(201, Lookup(200));
   ASSERT_EQ(-1,  Lookup(300));
 
   ASSERT_EQ(1U, deleted_keys_.size());
   ASSERT_EQ(100, deleted_keys_[0]);
-  if (GetParam() == kHyperClock) {
-    ASSERT_EQ(102, deleted_values_[0]);
-  } else {
-    ASSERT_EQ(101, deleted_values_[0]);
-  }
+  ASSERT_EQ(101, deleted_values_[0]);
 }
 
 TEST_P(CacheTest, InsertSameKey) {
-  if (GetParam() == kHyperClock) {
-    ROCKSDB_GTEST_BYPASS(
-        "ClockCache doesn't guarantee Insert overwrite same key.");
-    return;
-  }
   Insert(1, 1);
   Insert(1, 2);
   ASSERT_EQ(2, Lookup(1));
@@ -476,11 +413,6 @@ TEST_P(CacheTest, Erase) {
 }
 
 TEST_P(CacheTest, EntriesArePinned) {
-  if (GetParam() == kHyperClock) {
-    ROCKSDB_GTEST_BYPASS(
-        "ClockCache doesn't guarantee Insert overwrite same key.");
-    return;
-  }
   Insert(100, 101);
   Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
   ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));
@@ -513,8 +445,9 @@ TEST_P(CacheTest, EntriesArePinned) {
 TEST_P(CacheTest, EvictionPolicy) {
   Insert(100, 101);
   Insert(200, 201);
+
   // Frequently used entry must be kept around
-  for (int i = 0; i < 2 * kCacheSize; i++) {
+  for (int i = 0; i < kCacheSize * 2; i++) {
     Insert(1000+i, 2000+i);
     ASSERT_EQ(101, Lookup(100));
   }
@@ -541,12 +474,6 @@ TEST_P(CacheTest, ExternalRefPinsEntries) {
     for (int j = 0; j < 2 * kCacheSize + 100; j++) {
       Insert(1000 + j, 2000 + j);
     }
-    // Clock cache is even more stateful and needs more churn to evict
-    if (GetParam() == kHyperClock) {
-      for (int j = 0; j < kCacheSize; j++) {
-        Insert(11000 + j, 11000 + j);
-      }
-    }
     if (i < 2) {
       ASSERT_EQ(101, Lookup(100));
     }
@@ -573,7 +500,9 @@ TEST_P(CacheTest, EvictionPolicyRef) {
   Insert(303, 104);
 
   // Insert entries much more than cache capacity.
-  for (int i = 0; i < 100 * kCacheSize; i++) {
+  double load_factor =
+      std::min(fast_lru_cache::kLoadFactor, clock_cache::kLoadFactor);
+  for (int i = 0; i < 2 * static_cast<int>(kCacheSize / load_factor); i++) {
     Insert(1000 + i, 2000 + i);
   }
 
@@ -604,40 +533,31 @@ TEST_P(CacheTest, EvictionPolicyRef) {
 
 TEST_P(CacheTest, EvictEmptyCache) {
   auto type = GetParam();
+  if (type == kFast || type == kClock) {
+    ROCKSDB_GTEST_BYPASS("FastLRUCache and ClockCache require 16-byte keys.");
+    return;
+  }
 
   // Insert item large than capacity to trigger eviction on empty cache.
   auto cache = NewCache(1, 0, false);
-  if (type == kLRU) {
-    ASSERT_OK(cache->Insert("foo", nullptr, 10, DumbDeleter));
-  } else {
-    ASSERT_OK(cache->Insert(EncodeKey(1000), nullptr, 10, DumbDeleter));
-  }
+  ASSERT_OK(cache->Insert("foo", nullptr, 10, dumbDeleter));
 }
 
 TEST_P(CacheTest, EraseFromDeleter) {
   auto type = GetParam();
+  if (type == kFast || type == kClock) {
+    ROCKSDB_GTEST_BYPASS("FastLRUCache and ClockCache require 16-byte keys.");
+    return;
+  }
 
   // Have deleter which will erase item from cache, which will re-enter
   // the cache at that point.
   std::shared_ptr<Cache> cache = NewCache(10, 0, false);
-  std::string foo, bar;
-  Cache::DeleterFn erase_deleter;
-  if (type == kLRU) {
-    foo = "foo";
-    bar = "bar";
-    erase_deleter = EraseDeleter1;
-  } else {
-    foo = EncodeKey(1234);
-    bar = EncodeKey(5678);
-    erase_deleter = EraseDeleter2;
-  }
-
-  ASSERT_OK(cache->Insert(foo, nullptr, 1, DumbDeleter));
-  ASSERT_OK(cache->Insert(bar, cache.get(), 1, erase_deleter));
-
-  cache->Erase(bar);
-  ASSERT_EQ(nullptr, cache->Lookup(foo));
-  ASSERT_EQ(nullptr, cache->Lookup(bar));
+  ASSERT_OK(cache->Insert("foo", nullptr, 1, dumbDeleter));
+  ASSERT_OK(cache->Insert("bar", cache.get(), 1, eraseDeleter));
+  cache->Erase("bar");
+  ASSERT_EQ(nullptr, cache->Lookup("foo"));
+  ASSERT_EQ(nullptr, cache->Lookup("bar"));
 }
 
 TEST_P(CacheTest, ErasedHandleState) {
@@ -670,9 +590,9 @@ TEST_P(CacheTest, HeavyEntries) {
   const int kHeavy = 10;
   int added = 0;
   int index = 0;
-  while (added < 2 * kCacheSize) {
+  while (added < 2*kCacheSize) {
     const int weight = (index & 1) ? kLight : kHeavy;
-    Insert(index, 1000 + index, weight);
+    Insert(index, 1000+index, weight);
     added += weight;
     index++;
   }
@@ -683,7 +603,7 @@ TEST_P(CacheTest, HeavyEntries) {
     int r = Lookup(i);
     if (r >= 0) {
       cached_weight += weight;
-      ASSERT_EQ(1000 + i, r);
+      ASSERT_EQ(1000+i, r);
     }
   }
   ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10);
@@ -695,6 +615,7 @@ TEST_P(CacheTest, NewId) {
   ASSERT_NE(a, b);
 }
 
+
 class Value {
  public:
   explicit Value(int v) : v_(v) {}
@@ -741,10 +662,9 @@ TEST_P(CacheTest, ReleaseWithoutErase) {
 
 TEST_P(CacheTest, SetCapacity) {
   auto type = GetParam();
-  if (type == kFast || type == kHyperClock) {
+  if (type == kFast || type == kClock) {
     ROCKSDB_GTEST_BYPASS(
-        "FastLRUCache and HyperClockCache don't support arbitrary capacity "
-        "adjustments.");
+        "FastLRUCache and ClockCache don't support capacity adjustments.");
     return;
   }
   // test1: increase capacity
@@ -796,9 +716,9 @@ TEST_P(CacheTest, SetCapacity) {
 
 TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
   auto type = GetParam();
-  if (type == kFast) {
+  if (type == kFast || type == kClock) {
     ROCKSDB_GTEST_BYPASS(
-        "FastLRUCache only supports a limited number of "
+        "FastLRUCache and ClockCache don't support an unbounded number of "
         "inserts beyond "
         "capacity.");
     return;
@@ -854,6 +774,12 @@ TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
 }
 
 TEST_P(CacheTest, OverCapacity) {
+  auto type = GetParam();
+  if (type == kFast || type == kClock) {
+    ROCKSDB_GTEST_BYPASS(
+        "FastLRUCache and ClockCache don't support capacity adjustments.");
+    return;
+  }
   size_t n = 10;
 
   // a LRUCache with n entries and one shard only
@@ -881,34 +807,23 @@ TEST_P(CacheTest, OverCapacity) {
   for (int i = 0; i < static_cast<int>(n + 1); i++) {
     cache->Release(handles[i]);
   }
+  // Make sure eviction is triggered.
+  cache->SetCapacity(n);
 
-  if (GetParam() == kHyperClock) {
-    // Make sure eviction is triggered.
-    ASSERT_OK(cache->Insert(EncodeKey(-1), nullptr, 1, &deleter, &handles[0]));
+  // cache is under capacity now since elements were released
+  ASSERT_EQ(n, cache->GetUsage());
 
-    // cache is under capacity now since elements were released
-    ASSERT_GE(n, cache->GetUsage());
-
-    // clean up
-    cache->Release(handles[0]);
-  } else {
-    // LRUCache checks for over-capacity in Release.
-
-    // cache is exactly at capacity now with minimal eviction
-    ASSERT_EQ(n, cache->GetUsage());
-
-    // element 0 is evicted and the rest is there
-    // This is consistent with the LRU policy since the element 0
-    // was released first
-    for (int i = 0; i < static_cast<int>(n + 1); i++) {
-      std::string key = EncodeKey(i + 1);
-      auto h = cache->Lookup(key);
-      if (h) {
-        ASSERT_NE(static_cast<size_t>(i), 0U);
-        cache->Release(h);
-      } else {
-        ASSERT_EQ(static_cast<size_t>(i), 0U);
-      }
+  // element 0 is evicted and the rest is there
+  // This is consistent with the LRU policy since the element 0
+  // was released first
+  for (int i = 0; i < static_cast<int>(n + 1); i++) {
+    std::string key = EncodeKey(i + 1);
+    auto h = cache->Lookup(key);
+    if (h) {
+      ASSERT_NE(static_cast<size_t>(i), 0U);
+      cache->Release(h);
+    } else {
+      ASSERT_EQ(static_cast<size_t>(i), 0U);
     }
   }
 }
@@ -1016,31 +931,19 @@ TEST_P(CacheTest, ApplyToAllEntriesDuringResize) {
 }
 
 TEST_P(CacheTest, DefaultShardBits) {
-  // Prevent excessive allocation (to save time & space)
-  estimated_value_size_ = 100000;
-  // Implementations use different minimum shard sizes
-  size_t min_shard_size =
-      (GetParam() == kHyperClock ? 32U * 1024U : 512U) * 1024U;
-
-  std::shared_ptr<Cache> cache = NewCache(32U * min_shard_size);
+  // test1: set the flag to false. Insert more keys than capacity. See if they
+  // all go through.
+  std::shared_ptr<Cache> cache = NewCache(16 * 1024L * 1024L);
   ShardedCache* sc = dynamic_cast<ShardedCache*>(cache.get());
   ASSERT_EQ(5, sc->GetNumShardBits());
 
-  cache = NewCache(min_shard_size / 1000U * 999U);
+  cache = NewLRUCache(511 * 1024L, -1, true);
   sc = dynamic_cast<ShardedCache*>(cache.get());
   ASSERT_EQ(0, sc->GetNumShardBits());
 
-  cache = NewCache(3U * 1024U * 1024U * 1024U);
+  cache = NewLRUCache(1024L * 1024L * 1024L, -1, true);
   sc = dynamic_cast<ShardedCache*>(cache.get());
-  // current maximum of 6
   ASSERT_EQ(6, sc->GetNumShardBits());
-
-  if constexpr (sizeof(size_t) > 4) {
-    cache = NewCache(128U * min_shard_size);
-    sc = dynamic_cast<ShardedCache*>(cache.get());
-    // current maximum of 6
-    ASSERT_EQ(6, sc->GetNumShardBits());
-  }
 }
 
 TEST_P(CacheTest, GetChargeAndDeleter) {
@@ -1052,8 +955,11 @@ TEST_P(CacheTest, GetChargeAndDeleter) {
   cache_->Release(h1);
 }
 
+std::shared_ptr<Cache> (*new_clock_cache_func)(size_t, size_t, int, bool,
+                                               CacheMetadataChargePolicy) =
+    ExperimentalNewClockCache;
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
-                        testing::Values(kLRU, kHyperClock, kFast));
+                        testing::Values(kLRU, kClock, kFast));
 INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest,
                         testing::Values(kLRU, kFast));
 

cache/charged_cache.cc

@@ -1,117 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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 "cache/charged_cache.h"
-
-#include "cache/cache_reservation_manager.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-ChargedCache::ChargedCache(std::shared_ptr<Cache> cache,
-                           std::shared_ptr<Cache> block_cache)
-    : cache_(cache),
-      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
-          std::make_shared<
-              CacheReservationManagerImpl<CacheEntryRole::kBlobCache>>(
-              block_cache))) {}
-
-Status ChargedCache::Insert(const Slice& key, void* value, size_t charge,
-                            DeleterFn deleter, Handle** handle,
-                            Priority priority) {
-  Status s = cache_->Insert(key, value, charge, deleter, handle, priority);
-  if (s.ok()) {
-    // Insert may cause the cache entry eviction if the cache is full. So we
-    // directly call the reservation manager to update the total memory used
-    // in the cache.
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Status ChargedCache::Insert(const Slice& key, void* value,
-                            const CacheItemHelper* helper, size_t charge,
-                            Handle** handle, Priority priority) {
-  Status s = cache_->Insert(key, value, helper, charge, handle, priority);
-  if (s.ok()) {
-    // Insert may cause the cache entry eviction if the cache is full. So we
-    // directly call the reservation manager to update the total memory used
-    // in the cache.
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Cache::Handle* ChargedCache::Lookup(const Slice& key, Statistics* stats) {
-  return cache_->Lookup(key, stats);
-}
-
-Cache::Handle* ChargedCache::Lookup(const Slice& key,
-                                    const CacheItemHelper* helper,
-                                    const CreateCallback& create_cb,
-                                    Priority priority, bool wait,
-                                    Statistics* stats) {
-  auto handle = cache_->Lookup(key, helper, create_cb, priority, wait, stats);
-  // Lookup may promote the KV pair from the secondary cache to the primary
-  // cache. So we directly call the reservation manager to update the total
-  // memory used in the cache.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-  return handle;
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool useful,
-                           bool erase_if_last_ref) {
-  size_t memory_used_delta = cache_->GetUsage(handle);
-  bool erased = cache_->Release(handle, useful, erase_if_last_ref);
-  if (erased) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_
-        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
-        .PermitUncheckedError();
-  }
-  return erased;
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool erase_if_last_ref) {
-  size_t memory_used_delta = cache_->GetUsage(handle);
-  bool erased = cache_->Release(handle, erase_if_last_ref);
-  if (erased) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_
-        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
-        .PermitUncheckedError();
-  }
-  return erased;
-}
-
-void ChargedCache::Erase(const Slice& key) {
-  cache_->Erase(key);
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::EraseUnRefEntries() {
-  cache_->EraseUnRefEntries();
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::SetCapacity(size_t capacity) {
-  cache_->SetCapacity(capacity);
-  // SetCapacity can result in evictions when the cache capacity is decreased,
-  // so we would want to update the cache reservation here as well.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/charged_cache.h

@@ -1,121 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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 <string>
-
-#include "port/port.h"
-#include "rocksdb/cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class ConcurrentCacheReservationManager;
-
-// A cache interface which wraps around another cache and takes care of
-// reserving space in block cache towards a single global memory limit, and
-// forwards all the calls to the underlying cache.
-class ChargedCache : public Cache {
- public:
-  ChargedCache(std::shared_ptr<Cache> cache,
-               std::shared_ptr<Cache> block_cache);
-  ~ChargedCache() override = default;
-
-  Status Insert(const Slice& key, void* value, size_t charge, DeleterFn deleter,
-                Handle** handle, Priority priority) override;
-  Status Insert(const Slice& key, void* value, const CacheItemHelper* helper,
-                size_t charge, Handle** handle = nullptr,
-                Priority priority = Priority::LOW) override;
-
-  Cache::Handle* Lookup(const Slice& key, Statistics* stats) override;
-  Cache::Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                        const CreateCallback& create_cb, Priority priority,
-                        bool wait, Statistics* stats = nullptr) override;
-
-  bool Release(Cache::Handle* handle, bool useful,
-               bool erase_if_last_ref = false) override;
-  bool Release(Cache::Handle* handle, bool erase_if_last_ref = false) override;
-
-  void Erase(const Slice& key) override;
-  void EraseUnRefEntries() override;
-
-  static const char* kClassName() { return "ChargedCache"; }
-  const char* Name() const override { return kClassName(); }
-
-  uint64_t NewId() override { return cache_->NewId(); }
-
-  void SetCapacity(size_t capacity) override;
-
-  void SetStrictCapacityLimit(bool strict_capacity_limit) override {
-    cache_->SetStrictCapacityLimit(strict_capacity_limit);
-  }
-
-  bool HasStrictCapacityLimit() const override {
-    return cache_->HasStrictCapacityLimit();
-  }
-
-  void* Value(Cache::Handle* handle) override { return cache_->Value(handle); }
-
-  bool IsReady(Cache::Handle* handle) override {
-    return cache_->IsReady(handle);
-  }
-
-  void Wait(Cache::Handle* handle) override { cache_->Wait(handle); }
-
-  void WaitAll(std::vector<Handle*>& handles) override {
-    cache_->WaitAll(handles);
-  }
-
-  bool Ref(Cache::Handle* handle) override { return cache_->Ref(handle); }
-
-  size_t GetCapacity() const override { return cache_->GetCapacity(); }
-
-  size_t GetUsage() const override { return cache_->GetUsage(); }
-
-  size_t GetUsage(Cache::Handle* handle) const override {
-    return cache_->GetUsage(handle);
-  }
-
-  size_t GetPinnedUsage() const override { return cache_->GetPinnedUsage(); }
-
-  size_t GetCharge(Cache::Handle* handle) const override {
-    return cache_->GetCharge(handle);
-  }
-
-  Cache::DeleterFn GetDeleter(Cache::Handle* handle) const override {
-    return cache_->GetDeleter(handle);
-  }
-
-  void ApplyToAllEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               Cache::DeleterFn deleter)>& callback,
-      const Cache::ApplyToAllEntriesOptions& opts) override {
-    cache_->ApplyToAllEntries(callback, opts);
-  }
-
-  void ApplyToAllCacheEntries(void (*callback)(void* value, size_t charge),
-                              bool thread_safe) override {
-    cache_->ApplyToAllCacheEntries(callback, thread_safe);
-  }
-
-  std::string GetPrintableOptions() const override {
-    return cache_->GetPrintableOptions();
-  }
-
-  void DisownData() override { return cache_->DisownData(); }
-
-  inline Cache* GetCache() const { return cache_.get(); }
-
-  inline ConcurrentCacheReservationManager* TEST_GetCacheReservationManager()
-      const {
-    return cache_res_mgr_.get();
-  }
-
- private:
-  std::shared_ptr<Cache> cache_;
-  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.cc

@@ -5,127 +5,91 @@
 
 #include "cache/compressed_secondary_cache.h"
 
-#include <algorithm>
-#include <cstdint>
 #include <memory>
 
 #include "memory/memory_allocator.h"
-#include "monitoring/perf_context_imp.h"
 #include "util/compression.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
 
+namespace {
+
+void DeletionCallback(const Slice& /*key*/, void* obj) {
+  delete reinterpret_cast<CacheAllocationPtr*>(obj);
+  obj = nullptr;
+}
+
+}  // namespace
+
 CompressedSecondaryCache::CompressedSecondaryCache(
     size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
+    double high_pri_pool_ratio,
     std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
     CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge)
+    CompressionType compression_type, uint32_t compress_format_version)
     : cache_options_(capacity, num_shard_bits, strict_capacity_limit,
-                     high_pri_pool_ratio, low_pri_pool_ratio, memory_allocator,
-                     use_adaptive_mutex, metadata_charge_policy,
-                     compression_type, compress_format_version,
-                     enable_custom_split_merge) {
-  cache_ =
-      NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
-                  high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                  metadata_charge_policy, low_pri_pool_ratio);
+                     high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
+                     metadata_charge_policy, compression_type,
+                     compress_format_version) {
+  cache_ = NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
+                       high_pri_pool_ratio, memory_allocator,
+                       use_adaptive_mutex, metadata_charge_policy);
 }
 
 CompressedSecondaryCache::~CompressedSecondaryCache() { cache_.reset(); }
 
 std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
     const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
-    bool advise_erase, bool& is_in_sec_cache) {
+    bool& is_in_sec_cache) {
   std::unique_ptr<SecondaryCacheResultHandle> handle;
   is_in_sec_cache = false;
   Cache::Handle* lru_handle = cache_->Lookup(key);
   if (lru_handle == nullptr) {
-    return nullptr;
-  }
-
-  void* handle_value = cache_->Value(lru_handle);
-  if (handle_value == nullptr) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-    return nullptr;
-  }
-
-  CacheAllocationPtr* ptr{nullptr};
-  CacheAllocationPtr merged_value;
-  size_t handle_value_charge{0};
-  if (cache_options_.enable_custom_split_merge) {
-    CacheValueChunk* value_chunk_ptr =
-        reinterpret_cast<CacheValueChunk*>(handle_value);
-    merged_value = MergeChunksIntoValue(value_chunk_ptr, handle_value_charge);
-    ptr = &merged_value;
-  } else {
-    ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
-    handle_value_charge = cache_->GetCharge(lru_handle);
+    return handle;
   }
 
+  CacheAllocationPtr* ptr =
+      reinterpret_cast<CacheAllocationPtr*>(cache_->Value(lru_handle));
+  void* value = nullptr;
+  size_t charge = 0;
   Status s;
-  void* value{nullptr};
-  size_t charge{0};
+
   if (cache_options_.compression_type == kNoCompression) {
-    s = create_cb(ptr->get(), handle_value_charge, &value, &charge);
+    s = create_cb(ptr->get(), cache_->GetCharge(lru_handle), &value, &charge);
   } else {
     UncompressionContext uncompression_context(cache_options_.compression_type);
     UncompressionInfo uncompression_info(uncompression_context,
                                          UncompressionDict::GetEmptyDict(),
                                          cache_options_.compression_type);
 
-    size_t uncompressed_size{0};
-    CacheAllocationPtr uncompressed = UncompressData(
-        uncompression_info, (char*)ptr->get(), handle_value_charge,
+    size_t uncompressed_size = 0;
+    CacheAllocationPtr uncompressed;
+    uncompressed = UncompressData(
+        uncompression_info, (char*)ptr->get(), cache_->GetCharge(lru_handle),
         &uncompressed_size, cache_options_.compress_format_version,
         cache_options_.memory_allocator.get());
 
     if (!uncompressed) {
-      cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-      return nullptr;
+      cache_->Release(lru_handle, /* erase_if_last_ref */ true);
+      return handle;
     }
     s = create_cb(uncompressed.get(), uncompressed_size, &value, &charge);
   }
 
   if (!s.ok()) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-    return nullptr;
+    cache_->Release(lru_handle, /* erase_if_last_ref */ true);
+    return handle;
   }
 
-  if (advise_erase) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-    // Insert a dummy handle.
-    cache_
-        ->Insert(key, /*value=*/nullptr, /*charge=*/0,
-                 GetDeletionCallback(cache_options_.enable_custom_split_merge))
-        .PermitUncheckedError();
-  } else {
-    is_in_sec_cache = true;
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
+  cache_->Release(lru_handle, /* erase_if_last_ref */ true);
   handle.reset(new CompressedSecondaryCacheResultHandle(value, charge));
+
   return handle;
 }
 
 Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
                                         const Cache::CacheItemHelper* helper) {
-  if (value == nullptr) {
-    return Status::InvalidArgument();
-  }
-
-  Cache::Handle* lru_handle = cache_->Lookup(key);
-  Cache::DeleterFn del_cb =
-      GetDeletionCallback(cache_options_.enable_custom_split_merge);
-  if (lru_handle == nullptr) {
-    PERF_COUNTER_ADD(compressed_sec_cache_insert_dummy_count, 1);
-    // Insert a dummy handle if the handle is evicted for the first time.
-    return cache_->Insert(key, /*value=*/nullptr, /*charge=*/0, del_cb);
-  } else {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
-
   size_t size = (*helper->size_cb)(value);
   CacheAllocationPtr ptr =
       AllocateBlock(size, cache_options_.memory_allocator.get());
@@ -138,10 +102,9 @@ Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
 
   std::string compressed_val;
   if (cache_options_.compression_type != kNoCompression) {
-    PERF_COUNTER_ADD(compressed_sec_cache_uncompressed_bytes, size);
     CompressionOptions compression_opts;
     CompressionContext compression_context(cache_options_.compression_type);
-    uint64_t sample_for_compression{0};
+    uint64_t sample_for_compression = 0;
     CompressionInfo compression_info(
         compression_opts, compression_context, CompressionDict::GetEmptyDict(),
         cache_options_.compression_type, sample_for_compression);
@@ -156,24 +119,13 @@ Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
 
     val = Slice(compressed_val);
     size = compressed_val.size();
-    PERF_COUNTER_ADD(compressed_sec_cache_compressed_bytes, size);
-
-    if (!cache_options_.enable_custom_split_merge) {
-      ptr = AllocateBlock(size, cache_options_.memory_allocator.get());
-      memcpy(ptr.get(), compressed_val.data(), size);
-    }
+    ptr = AllocateBlock(size, cache_options_.memory_allocator.get());
+    memcpy(ptr.get(), compressed_val.data(), size);
   }
 
-  PERF_COUNTER_ADD(compressed_sec_cache_insert_real_count, 1);
-  if (cache_options_.enable_custom_split_merge) {
-    size_t charge{0};
-    CacheValueChunk* value_chunks_head =
-        SplitValueIntoChunks(val, cache_options_.compression_type, charge);
-    return cache_->Insert(key, value_chunks_head, charge, del_cb);
-  } else {
-    CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    return cache_->Insert(key, buf, size, del_cb);
-  }
+  CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
+
+  return cache_->Insert(key, buf, size, DeletionCallback);
 }
 
 void CompressedSecondaryCache::Erase(const Slice& key) { cache_->Erase(key); }
@@ -181,7 +133,7 @@ void CompressedSecondaryCache::Erase(const Slice& key) { cache_->Erase(key); }
 std::string CompressedSecondaryCache::GetPrintableOptions() const {
   std::string ret;
   ret.reserve(20000);
-  const int kBufferSize{200};
+  const int kBufferSize = 200;
   char buffer[kBufferSize];
   ret.append(cache_->GetPrintableOptions());
   snprintf(buffer, kBufferSize, "    compression_type : %s\n",
@@ -193,108 +145,16 @@ std::string CompressedSecondaryCache::GetPrintableOptions() const {
   return ret;
 }
 
-CompressedSecondaryCache::CacheValueChunk*
-CompressedSecondaryCache::SplitValueIntoChunks(
-    const Slice& value, const CompressionType compression_type,
-    size_t& charge) {
-  assert(!value.empty());
-  const char* src_ptr = value.data();
-  size_t src_size{value.size()};
-
-  CacheValueChunk dummy_head = CacheValueChunk();
-  CacheValueChunk* current_chunk = &dummy_head;
-  // Do not split when value size is large or there is no compression.
-  size_t predicted_chunk_size{0};
-  size_t actual_chunk_size{0};
-  size_t tmp_size{0};
-  while (src_size > 0) {
-    predicted_chunk_size = sizeof(CacheValueChunk) - 1 + src_size;
-    auto upper =
-        std::upper_bound(malloc_bin_sizes_.begin(), malloc_bin_sizes_.end(),
-                         predicted_chunk_size);
-    // Do not split when value size is too small, too large, close to a bin
-    // size, or there is no compression.
-    if (upper == malloc_bin_sizes_.begin() ||
-        upper == malloc_bin_sizes_.end() ||
-        *upper - predicted_chunk_size < malloc_bin_sizes_.front() ||
-        compression_type == kNoCompression) {
-      tmp_size = predicted_chunk_size;
-    } else {
-      tmp_size = *(--upper);
-    }
-
-    CacheValueChunk* new_chunk =
-        reinterpret_cast<CacheValueChunk*>(new char[tmp_size]);
-    current_chunk->next = new_chunk;
-    current_chunk = current_chunk->next;
-    actual_chunk_size = tmp_size - sizeof(CacheValueChunk) + 1;
-    memcpy(current_chunk->data, src_ptr, actual_chunk_size);
-    current_chunk->size = actual_chunk_size;
-    src_ptr += actual_chunk_size;
-    src_size -= actual_chunk_size;
-    charge += tmp_size;
-  }
-  current_chunk->next = nullptr;
-
-  return dummy_head.next;
-}
-
-CacheAllocationPtr CompressedSecondaryCache::MergeChunksIntoValue(
-    const void* chunks_head, size_t& charge) {
-  const CacheValueChunk* head =
-      reinterpret_cast<const CacheValueChunk*>(chunks_head);
-  const CacheValueChunk* current_chunk = head;
-  charge = 0;
-  while (current_chunk != nullptr) {
-    charge += current_chunk->size;
-    current_chunk = current_chunk->next;
-  }
-
-  CacheAllocationPtr ptr =
-      AllocateBlock(charge, cache_options_.memory_allocator.get());
-  current_chunk = head;
-  size_t pos{0};
-  while (current_chunk != nullptr) {
-    memcpy(ptr.get() + pos, current_chunk->data, current_chunk->size);
-    pos += current_chunk->size;
-    current_chunk = current_chunk->next;
-  }
-
-  return ptr;
-}
-
-Cache::DeleterFn CompressedSecondaryCache::GetDeletionCallback(
-    bool enable_custom_split_merge) {
-  if (enable_custom_split_merge) {
-    return [](const Slice& /*key*/, void* obj) {
-      CacheValueChunk* chunks_head = reinterpret_cast<CacheValueChunk*>(obj);
-      while (chunks_head != nullptr) {
-        CacheValueChunk* tmp_chunk = chunks_head;
-        chunks_head = chunks_head->next;
-        tmp_chunk->Free();
-        obj = nullptr;
-      };
-    };
-  } else {
-    return [](const Slice& /*key*/, void* obj) {
-      delete reinterpret_cast<CacheAllocationPtr*>(obj);
-      obj = nullptr;
-    };
-  }
-}
-
 std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
     size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
+    double high_pri_pool_ratio,
     std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
     CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge) {
+    CompressionType compression_type, uint32_t compress_format_version) {
   return std::make_shared<CompressedSecondaryCache>(
       capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      low_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-      metadata_charge_policy, compression_type, compress_format_version,
-      enable_custom_split_merge);
+      memory_allocator, use_adaptive_mutex, metadata_charge_policy,
+      compression_type, compress_format_version);
 }
 
 std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
@@ -303,10 +163,9 @@ std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
   assert(opts.secondary_cache == nullptr);
   return NewCompressedSecondaryCache(
       opts.capacity, opts.num_shard_bits, opts.strict_capacity_limit,
-      opts.high_pri_pool_ratio, opts.low_pri_pool_ratio, opts.memory_allocator,
-      opts.use_adaptive_mutex, opts.metadata_charge_policy,
-      opts.compression_type, opts.compress_format_version,
-      opts.enable_custom_split_merge);
+      opts.high_pri_pool_ratio, opts.memory_allocator, opts.use_adaptive_mutex,
+      opts.metadata_charge_policy, opts.compression_type,
+      opts.compress_format_version);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.h

@@ -5,8 +5,6 @@
 
 #pragma once
 
-#include <array>
-#include <cstddef>
 #include <memory>
 
 #include "cache/lru_cache.h"
@@ -45,21 +43,7 @@ class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
 // The CompressedSecondaryCache is a concrete implementation of
 // rocksdb::SecondaryCache.
 //
-// When a block is found from CompressedSecondaryCache::Lookup, we check whether
-// there is a dummy block with the same key in the primary cache.
-// 1. If the dummy block exits, we erase the block from
-//    CompressedSecondaryCache and insert it into the primary cache.
-// 2. If not, we just insert a dummy block into the primary cache
-//    (charging the actual size of the block) and don not erase the block from
-//    CompressedSecondaryCache. A standalone handle is returned to the caller.
-//
-// When a block is evicted from the primary cache, we check whether
-// there is a dummy block with the same key in CompressedSecondaryCache.
-// 1. If the dummy block exits, the block is inserted into
-//    CompressedSecondaryCache.
-// 2. If not, we just insert a dummy block (size 0) in CompressedSecondaryCache.
-//
-// Users can also cast a pointer to CompressedSecondaryCache and call methods on
+// Users can also cast a pointer to it and call methods on
 // it directly, especially custom methods that may be added
 // in the future.  For example -
 // std::unique_ptr<rocksdb::SecondaryCache> cache =
@@ -70,14 +54,13 @@ class CompressedSecondaryCache : public SecondaryCache {
  public:
   CompressedSecondaryCache(
       size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      double high_pri_pool_ratio, double low_pri_pool_ratio,
+      double high_pri_pool_ratio,
       std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
       bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
       CacheMetadataChargePolicy metadata_charge_policy =
-          kDefaultCacheMetadataChargePolicy,
+          kDontChargeCacheMetadata,
       CompressionType compression_type = CompressionType::kLZ4Compression,
-      uint32_t compress_format_version = 2,
-      bool enable_custom_split_merge = false);
+      uint32_t compress_format_version = 2);
   virtual ~CompressedSecondaryCache() override;
 
   const char* Name() const override { return "CompressedSecondaryCache"; }
@@ -87,9 +70,7 @@ class CompressedSecondaryCache : public SecondaryCache {
 
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
-      bool advise_erase, bool& is_in_sec_cache) override;
-
-  bool SupportForceErase() const override { return true; }
+      bool& is_in_sec_cache) override;
 
   void Erase(const Slice& key) override;
 
@@ -98,34 +79,6 @@ class CompressedSecondaryCache : public SecondaryCache {
   std::string GetPrintableOptions() const override;
 
  private:
-  friend class CompressedSecondaryCacheTest;
-  static constexpr std::array<uint16_t, 8> malloc_bin_sizes_{
-      128, 256, 512, 1024, 2048, 4096, 8192, 16384};
-
-  struct CacheValueChunk {
-    // TODO try "CacheAllocationPtr next;".
-    CacheValueChunk* next;
-    size_t size;
-    // Beginning of the chunk data (MUST BE THE LAST FIELD IN THIS STRUCT!)
-    char data[1];
-
-    void Free() { delete[] reinterpret_cast<char*>(this); }
-  };
-
-  // Split value into chunks to better fit into jemalloc bins. The chunks
-  // are stored in CacheValueChunk and extra charge is needed for each chunk,
-  // so the cache charge is recalculated here.
-  CacheValueChunk* SplitValueIntoChunks(const Slice& value,
-                                        const CompressionType compression_type,
-                                        size_t& charge);
-
-  // After merging chunks, the extra charge for each chunk is removed, so
-  // the charge is recalculated.
-  CacheAllocationPtr MergeChunksIntoValue(const void* chunks_head,
-                                          size_t& charge);
-
-  // An implementation of Cache::DeleterFn.
-  static Cache::DeleterFn GetDeletionCallback(bool enable_custom_split_merge);
   std::shared_ptr<Cache> cache_;
   CompressedSecondaryCacheOptions cache_options_;
 };

cache/compressed_secondary_cache_test.cc

@@ -7,13 +7,9 @@
 
 #include <algorithm>
 #include <cstdint>
-#include <iterator>
-#include <tuple>
 
-#include "cache/lru_cache.h"
 #include "memory/jemalloc_nodump_allocator.h"
 #include "memory/memory_allocator.h"
-#include "rocksdb/compression_type.h"
 #include "rocksdb/convenience.h"
 #include "rocksdb/secondary_cache.h"
 #include "test_util/testharness.h"
@@ -85,91 +81,52 @@ class CompressedSecondaryCacheTest : public testing::Test {
 
   void SetFailCreate(bool fail) { fail_create_ = fail; }
 
-  void BasicTestHelper(std::shared_ptr<SecondaryCache> sec_cache,
-                       bool sec_cache_is_compressed) {
-    get_perf_context()->Reset();
+  void BasicTestHelper(std::shared_ptr<SecondaryCache> sec_cache) {
     bool is_in_sec_cache{true};
     // Lookup an non-existent key.
-    std::unique_ptr<SecondaryCacheResultHandle> handle0 = sec_cache->Lookup(
-        "k0", test_item_creator, true, /*advise_erase=*/true, is_in_sec_cache);
+    std::unique_ptr<SecondaryCacheResultHandle> handle0 =
+        sec_cache->Lookup("k0", test_item_creator, true, is_in_sec_cache);
     ASSERT_EQ(handle0, nullptr);
 
     Random rnd(301);
-    // Insert and Lookup the item k1 for the first time.
-    std::string str1(rnd.RandomString(1000));
+    // Insert and Lookup the first item.
+    std::string str1;
+    test::CompressibleString(&rnd, 0.25, 1000, &str1);
     TestItem item1(str1.data(), str1.length());
-    // A dummy handle is inserted if the item is inserted for the first time.
     ASSERT_OK(sec_cache->Insert("k1", &item1,
                                 &CompressedSecondaryCacheTest::helper_));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 1);
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
 
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_EQ(handle1_1, nullptr);
-
-    // Insert and Lookup the item k1 for the second time and advise erasing it.
-    ASSERT_OK(sec_cache->Insert("k1", &item1,
-                                &CompressedSecondaryCacheTest::helper_));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 1);
-
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_2 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/true, is_in_sec_cache);
-    ASSERT_NE(handle1_2, nullptr);
+    std::unique_ptr<SecondaryCacheResultHandle> handle1 =
+        sec_cache->Lookup("k1", test_item_creator, true, is_in_sec_cache);
+    ASSERT_NE(handle1, nullptr);
     ASSERT_FALSE(is_in_sec_cache);
-    if (sec_cache_is_compressed) {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes,
-                1000);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                1007);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
 
     std::unique_ptr<TestItem> val1 =
-        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle1_2->Value()));
+        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle1->Value()));
     ASSERT_NE(val1, nullptr);
     ASSERT_EQ(memcmp(val1->Buf(), item1.Buf(), item1.Size()), 0);
 
-    // Lookup the item k1 again.
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_3 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/true, is_in_sec_cache);
-    ASSERT_EQ(handle1_3, nullptr);
+    // Lookup the first item again.
+    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 =
+        sec_cache->Lookup("k1", test_item_creator, true, is_in_sec_cache);
+    ASSERT_EQ(handle1_1, nullptr);
 
-    // Insert and Lookup the item k2.
-    std::string str2(rnd.RandomString(1000));
+    // Insert and Lookup the second item.
+    std::string str2;
+    test::CompressibleString(&rnd, 0.5, 1000, &str2);
     TestItem item2(str2.data(), str2.length());
     ASSERT_OK(sec_cache->Insert("k2", &item2,
                                 &CompressedSecondaryCacheTest::helper_));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 2);
-    std::unique_ptr<SecondaryCacheResultHandle> handle2_1 = sec_cache->Lookup(
-        "k2", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_EQ(handle2_1, nullptr);
-
-    ASSERT_OK(sec_cache->Insert("k2", &item2,
-                                &CompressedSecondaryCacheTest::helper_));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 2);
-    if (sec_cache_is_compressed) {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes,
-                2000);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                2014);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-    std::unique_ptr<SecondaryCacheResultHandle> handle2_2 = sec_cache->Lookup(
-        "k2", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_NE(handle2_2, nullptr);
+    std::unique_ptr<SecondaryCacheResultHandle> handle2 =
+        sec_cache->Lookup("k2", test_item_creator, true, is_in_sec_cache);
+    ASSERT_NE(handle2, nullptr);
     std::unique_ptr<TestItem> val2 =
-        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle2_2->Value()));
+        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle2->Value()));
     ASSERT_NE(val2, nullptr);
     ASSERT_EQ(memcmp(val2->Buf(), item2.Buf(), item2.Size()), 0);
 
-    std::vector<SecondaryCacheResultHandle*> handles = {handle1_2.get(),
-                                                        handle2_2.get()};
+    std::vector<SecondaryCacheResultHandle*> handles = {handle1.get(),
+                                                        handle2.get()};
     sec_cache->WaitAll(handles);
 
     sec_cache.reset();
@@ -179,12 +136,12 @@ class CompressedSecondaryCacheTest : public testing::Test {
     CompressedSecondaryCacheOptions opts;
     opts.capacity = 2048;
     opts.num_shard_bits = 0;
+    opts.metadata_charge_policy = kDontChargeCacheMetadata;
 
     if (sec_cache_is_compressed) {
       if (!LZ4_Supported()) {
         ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
         opts.compression_type = CompressionType::kNoCompression;
-        sec_cache_is_compressed = false;
       }
     } else {
       opts.compression_type = CompressionType::kNoCompression;
@@ -205,8 +162,6 @@ class CompressedSecondaryCacheTest : public testing::Test {
     }
     std::shared_ptr<SecondaryCache> sec_cache =
         NewCompressedSecondaryCache(opts);
-
-    BasicTestHelper(sec_cache, sec_cache_is_compressed);
   }
 
   void FailsTest(bool sec_cache_is_compressed) {
@@ -222,6 +177,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
 
     secondary_cache_opts.capacity = 1100;
     secondary_cache_opts.num_shard_bits = 0;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
     std::shared_ptr<SecondaryCache> sec_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
 
@@ -229,152 +185,86 @@ class CompressedSecondaryCacheTest : public testing::Test {
     Random rnd(301);
     std::string str1(rnd.RandomString(1000));
     TestItem item1(str1.data(), str1.length());
-    // Insert a dummy handle.
-    ASSERT_OK(sec_cache->Insert("k1", &item1,
-                                &CompressedSecondaryCacheTest::helper_));
-    // Insert k1.
     ASSERT_OK(sec_cache->Insert("k1", &item1,
                                 &CompressedSecondaryCacheTest::helper_));
 
     // Insert and Lookup the second item.
     std::string str2(rnd.RandomString(200));
     TestItem item2(str2.data(), str2.length());
-    // Insert a dummy handle, k1 is not evicted.
+    // k1 is evicted.
     ASSERT_OK(sec_cache->Insert("k2", &item2,
                                 &CompressedSecondaryCacheTest::helper_));
     bool is_in_sec_cache{false};
-    std::unique_ptr<SecondaryCacheResultHandle> handle1 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_EQ(handle1, nullptr);
-
-    // Insert k2 and k1 is evicted.
-    ASSERT_OK(sec_cache->Insert("k2", &item2,
-                                &CompressedSecondaryCacheTest::helper_));
-    std::unique_ptr<SecondaryCacheResultHandle> handle2 = sec_cache->Lookup(
-        "k2", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
+    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 =
+        sec_cache->Lookup("k1", test_item_creator, true, is_in_sec_cache);
+    ASSERT_EQ(handle1_1, nullptr);
+    std::unique_ptr<SecondaryCacheResultHandle> handle2 =
+        sec_cache->Lookup("k2", test_item_creator, true, is_in_sec_cache);
     ASSERT_NE(handle2, nullptr);
     std::unique_ptr<TestItem> val2 =
         std::unique_ptr<TestItem>(static_cast<TestItem*>(handle2->Value()));
     ASSERT_NE(val2, nullptr);
     ASSERT_EQ(memcmp(val2->Buf(), item2.Buf(), item2.Size()), 0);
 
-    // Insert k1 again and a dummy handle is inserted.
-    ASSERT_OK(sec_cache->Insert("k1", &item1,
-                                &CompressedSecondaryCacheTest::helper_));
-
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_EQ(handle1_1, nullptr);
-
     // Create Fails.
     SetFailCreate(true);
-    std::unique_ptr<SecondaryCacheResultHandle> handle2_1 = sec_cache->Lookup(
-        "k2", test_item_creator, true, /*advise_erase=*/true, is_in_sec_cache);
+    std::unique_ptr<SecondaryCacheResultHandle> handle2_1 =
+        sec_cache->Lookup("k2", test_item_creator, true, is_in_sec_cache);
     ASSERT_EQ(handle2_1, nullptr);
 
     // Save Fails.
     std::string str3 = rnd.RandomString(10);
     TestItem item3(str3.data(), str3.length());
-    // The Status is OK because a dummy handle is inserted.
-    ASSERT_OK(sec_cache->Insert("k3", &item3,
-                                &CompressedSecondaryCacheTest::helper_fail_));
     ASSERT_NOK(sec_cache->Insert("k3", &item3,
                                  &CompressedSecondaryCacheTest::helper_fail_));
 
     sec_cache.reset();
   }
 
-  void BasicIntegrationTest(bool sec_cache_is_compressed,
-                            bool enable_custom_split_merge) {
+  void BasicIntegrationTest(bool sec_cache_is_compressed) {
     CompressedSecondaryCacheOptions secondary_cache_opts;
 
     if (sec_cache_is_compressed) {
       if (!LZ4_Supported()) {
         ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
         secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-        sec_cache_is_compressed = false;
       }
     } else {
       secondary_cache_opts.compression_type = CompressionType::kNoCompression;
     }
 
-    secondary_cache_opts.capacity = 6000;
+    secondary_cache_opts.capacity = 2300;
     secondary_cache_opts.num_shard_bits = 0;
-    secondary_cache_opts.enable_custom_split_merge = enable_custom_split_merge;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
     std::shared_ptr<SecondaryCache> secondary_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
-    LRUCacheOptions lru_cache_opts(
-        /*_capacity =*/1300, /*_num_shard_bits =*/0,
-        /*_strict_capacity_limit =*/false, /*_high_pri_pool_ratio =*/0.5,
-        /*_memory_allocator =*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio =*/0.0);
+    LRUCacheOptions lru_cache_opts(1024, 0, false, 0.5, nullptr,
+                                   kDefaultToAdaptiveMutex,
+                                   kDontChargeCacheMetadata);
     lru_cache_opts.secondary_cache = secondary_cache;
     std::shared_ptr<Cache> cache = NewLRUCache(lru_cache_opts);
     std::shared_ptr<Statistics> stats = CreateDBStatistics();
 
-    get_perf_context()->Reset();
     Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    TestItem* item1_1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_1, &CompressedSecondaryCacheTest::helper_, str1.length()));
 
-    std::string str2 = rnd.RandomString(1012);
-    TestItem* item2_1 = new TestItem(str2.data(), str2.length());
-    // After this Insert, primary cache contains k2 and secondary cache contains
-    // k1's dummy item.
-    ASSERT_OK(cache->Insert(
-        "k2", item2_1, &CompressedSecondaryCacheTest::helper_, str2.length()));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 1);
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
+    std::string str1 = rnd.RandomString(1010);
+    std::string str1_clone{str1};
+    TestItem* item1 = new TestItem(str1.data(), str1.length());
+    ASSERT_OK(cache->Insert("k1", item1, &CompressedSecondaryCacheTest::helper_,
+                            str1.length()));
 
-    std::string str3 = rnd.RandomString(1024);
-    TestItem* item3_1 = new TestItem(str3.data(), str3.length());
-    // After this Insert, primary cache contains k3 and secondary cache contains
-    // k1's dummy item and k2's dummy item.
-    ASSERT_OK(cache->Insert(
-        "k3", item3_1, &CompressedSecondaryCacheTest::helper_, str3.length()));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 2);
+    std::string str2 = rnd.RandomString(1020);
+    TestItem* item2 = new TestItem(str2.data(), str2.length());
+    // After Insert, lru cache contains k2 and secondary cache contains k1.
+    ASSERT_OK(cache->Insert("k2", item2, &CompressedSecondaryCacheTest::helper_,
+                            str2.length()));
 
-    // After this Insert, primary cache contains k1 and secondary cache contains
-    // k1's dummy item, k2's dummy item, and k3's dummy item.
-    TestItem* item1_2 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_2, &CompressedSecondaryCacheTest::helper_, str1.length()));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 3);
-
-    // After this Insert, primary cache contains k2 and secondary cache contains
-    // k1's item, k2's dummy item, and k3's dummy item.
-    TestItem* item2_2 = new TestItem(str2.data(), str2.length());
-    ASSERT_OK(cache->Insert(
-        "k2", item2_2, &CompressedSecondaryCacheTest::helper_, str2.length()));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 1);
-    if (sec_cache_is_compressed) {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes,
-                str1.length());
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                1008);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-
-    // After this Insert, primary cache contains k3 and secondary cache contains
-    // k1's item and k2's item.
-    TestItem* item3_2 = new TestItem(str3.data(), str3.length());
-    ASSERT_OK(cache->Insert(
-        "k3", item3_2, &CompressedSecondaryCacheTest::helper_, str3.length()));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 2);
-    if (sec_cache_is_compressed) {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes,
-                str1.length() + str2.length());
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                2027);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
+    std::string str3 = rnd.RandomString(1020);
+    TestItem* item3 = new TestItem(str3.data(), str3.length());
+    // After Insert, lru cache contains k3 and secondary cache contains k1 and
+    // k2
+    ASSERT_OK(cache->Insert("k3", item3, &CompressedSecondaryCacheTest::helper_,
+                            str3.length()));
 
     Cache::Handle* handle;
     handle = cache->Lookup("k3", &CompressedSecondaryCacheTest::helper_,
@@ -383,7 +273,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
     ASSERT_NE(handle, nullptr);
     TestItem* val3 = static_cast<TestItem*>(cache->Value(handle));
     ASSERT_NE(val3, nullptr);
-    ASSERT_EQ(memcmp(val3->Buf(), item3_2->Buf(), item3_2->Size()), 0);
+    ASSERT_EQ(memcmp(val3->Buf(), item3->Buf(), item3->Size()), 0);
     cache->Release(handle);
 
     // Lookup an non-existent key.
@@ -392,33 +282,22 @@ class CompressedSecondaryCacheTest : public testing::Test {
                            stats.get());
     ASSERT_EQ(handle, nullptr);
 
-    // This Lookup should just insert a dummy handle in the primary cache
-    // and the k1 is still in the secondary cache.
+    // This Lookup should promote k1 and erase k1 from the secondary cache,
+    // then k3 is demoted. So k2 and k3 are in the secondary cache.
     handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
                            test_item_creator, Cache::Priority::LOW, true,
                            stats.get());
+
     ASSERT_NE(handle, nullptr);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
     TestItem* val1_1 = static_cast<TestItem*>(cache->Value(handle));
     ASSERT_NE(val1_1, nullptr);
-    ASSERT_EQ(memcmp(val1_1->Buf(), str1.data(), str1.size()), 0);
+    ASSERT_EQ(memcmp(val1_1->Buf(), str1_clone.data(), str1_clone.size()), 0);
     cache->Release(handle);
 
-    // This Lookup should erase k1 from the secondary cache and insert
-    // it into primary cache; then k3 is demoted.
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
-                           stats.get());
-    ASSERT_NE(handle, nullptr);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
-    cache->Release(handle);
-
-    // k2 is still in secondary cache.
     handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
                            test_item_creator, Cache::Priority::LOW, true,
                            stats.get());
     ASSERT_NE(handle, nullptr);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 2);
     cache->Release(handle);
 
     cache.reset();
@@ -437,21 +316,19 @@ class CompressedSecondaryCacheTest : public testing::Test {
       secondary_cache_opts.compression_type = CompressionType::kNoCompression;
     }
 
-    secondary_cache_opts.capacity = 6000;
+    secondary_cache_opts.capacity = 2048;
     secondary_cache_opts.num_shard_bits = 0;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
     std::shared_ptr<SecondaryCache> secondary_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
 
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
+    LRUCacheOptions opts(1024, 0, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
+                         kDontChargeCacheMetadata);
     opts.secondary_cache = secondary_cache;
     std::shared_ptr<Cache> cache = NewLRUCache(opts);
 
     Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
+    std::string str1 = rnd.RandomString(1020);
     auto item1 =
         std::unique_ptr<TestItem>(new TestItem(str1.data(), str1.length()));
     ASSERT_NOK(cache->Insert("k1", item1.get(), nullptr, str1.length()));
@@ -484,28 +361,25 @@ class CompressedSecondaryCacheTest : public testing::Test {
       secondary_cache_opts.compression_type = CompressionType::kNoCompression;
     }
 
-    secondary_cache_opts.capacity = 6000;
+    secondary_cache_opts.capacity = 2048;
     secondary_cache_opts.num_shard_bits = 0;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
 
     std::shared_ptr<SecondaryCache> secondary_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
 
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
+    LRUCacheOptions opts(1024, 0, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
+                         kDontChargeCacheMetadata);
     opts.secondary_cache = secondary_cache;
     std::shared_ptr<Cache> cache = NewLRUCache(opts);
 
     Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
+    std::string str1 = rnd.RandomString(1020);
     TestItem* item1 = new TestItem(str1.data(), str1.length());
     ASSERT_OK(cache->Insert("k1", item1,
                             &CompressedSecondaryCacheTest::helper_fail_,
                             str1.length()));
-
-    std::string str2 = rnd.RandomString(1002);
+    std::string str2 = rnd.RandomString(1020);
     TestItem* item2 = new TestItem(str2.data(), str2.length());
     // k1 should be demoted to the secondary cache.
     ASSERT_OK(cache->Insert("k2", item2,
@@ -517,11 +391,11 @@ class CompressedSecondaryCacheTest : public testing::Test {
                            test_item_creator, Cache::Priority::LOW, true);
     ASSERT_NE(handle, nullptr);
     cache->Release(handle);
-    // This lookup should fail, since k1 demotion would have failed.
+    // This lookup should fail, since k1 demotion would have failed
     handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_fail_,
                            test_item_creator, Cache::Priority::LOW, true);
     ASSERT_EQ(handle, nullptr);
-    // Since k1 was not promoted, k2 should still be in cache.
+    // Since k1 didn't get promoted, k2 should still be in cache
     handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_fail_,
                            test_item_creator, Cache::Priority::LOW, true);
     ASSERT_NE(handle, nullptr);
@@ -543,27 +417,25 @@ class CompressedSecondaryCacheTest : public testing::Test {
       secondary_cache_opts.compression_type = CompressionType::kNoCompression;
     }
 
-    secondary_cache_opts.capacity = 6000;
+    secondary_cache_opts.capacity = 2048;
     secondary_cache_opts.num_shard_bits = 0;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
 
     std::shared_ptr<SecondaryCache> secondary_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
 
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
+    LRUCacheOptions opts(1024, 0, false, 0.5, nullptr, kDefaultToAdaptiveMutex,
+                         kDontChargeCacheMetadata);
     opts.secondary_cache = secondary_cache;
     std::shared_ptr<Cache> cache = NewLRUCache(opts);
 
     Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
+    std::string str1 = rnd.RandomString(1020);
     TestItem* item1 = new TestItem(str1.data(), str1.length());
     ASSERT_OK(cache->Insert("k1", item1, &CompressedSecondaryCacheTest::helper_,
                             str1.length()));
 
-    std::string str2 = rnd.RandomString(1002);
+    std::string str2 = rnd.RandomString(1020);
     TestItem* item2 = new TestItem(str2.data(), str2.length());
     // k1 should be demoted to the secondary cache.
     ASSERT_OK(cache->Insert("k2", item2, &CompressedSecondaryCacheTest::helper_,
@@ -601,55 +473,36 @@ class CompressedSecondaryCacheTest : public testing::Test {
       secondary_cache_opts.compression_type = CompressionType::kNoCompression;
     }
 
-    secondary_cache_opts.capacity = 6000;
+    secondary_cache_opts.capacity = 2048;
     secondary_cache_opts.num_shard_bits = 0;
+    secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
 
     std::shared_ptr<SecondaryCache> secondary_cache =
         NewCompressedSecondaryCache(secondary_cache_opts);
 
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
+    LRUCacheOptions opts(1024, 0, /*_strict_capacity_limit=*/true, 0.5, nullptr,
+                         kDefaultToAdaptiveMutex, kDontChargeCacheMetadata);
     opts.secondary_cache = secondary_cache;
     std::shared_ptr<Cache> cache = NewLRUCache(opts);
 
     Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    TestItem* item1_1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_1, &CompressedSecondaryCacheTest::helper_, str1.length()));
-
-    std::string str2 = rnd.RandomString(1002);
-    std::string str2_clone{str2};
+    std::string str1 = rnd.RandomString(1020);
+    TestItem* item1 = new TestItem(str1.data(), str1.length());
+    ASSERT_OK(cache->Insert("k1", item1, &CompressedSecondaryCacheTest::helper_,
+                            str1.length()));
+    std::string str2 = rnd.RandomString(1020);
     TestItem* item2 = new TestItem(str2.data(), str2.length());
-    // After this Insert, primary cache contains k2 and secondary cache contains
-    // k1's dummy item.
+    // k1 should be demoted to the secondary cache.
     ASSERT_OK(cache->Insert("k2", item2, &CompressedSecondaryCacheTest::helper_,
                             str2.length()));
 
-    // After this Insert, primary cache contains k1 and secondary cache contains
-    // k1's dummy item and k2's dummy item.
-    TestItem* item1_2 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_2, &CompressedSecondaryCacheTest::helper_, str1.length()));
-
-    TestItem* item2_2 = new TestItem(str2.data(), str2.length());
-    // After this Insert, primary cache contains k2 and secondary cache contains
-    // k1's item and k2's dummy item.
-    ASSERT_OK(cache->Insert(
-        "k2", item2_2, &CompressedSecondaryCacheTest::helper_, str2.length()));
-
     Cache::Handle* handle2;
     handle2 = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
                             test_item_creator, Cache::Priority::LOW, true);
     ASSERT_NE(handle2, nullptr);
     cache->Release(handle2);
-
-    // k1 promotion should fail because cache is at capacity and
-    // strict_capacity_limit is true, but the lookup should still succeed.
-    // A k1's dummy item is inserted into primary cache.
+    // k1 promotion should fail due to the block cache being at capacity,
+    // but the lookup should still succeed
     Cache::Handle* handle1;
     handle1 = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
                             test_item_creator, Cache::Priority::LOW, true);
@@ -666,123 +519,6 @@ class CompressedSecondaryCacheTest : public testing::Test {
     secondary_cache.reset();
   }
 
-  void SplitValueIntoChunksTest() {
-    JemallocAllocatorOptions jopts;
-    std::shared_ptr<MemoryAllocator> allocator;
-    std::string msg;
-    if (JemallocNodumpAllocator::IsSupported(&msg)) {
-      Status s = NewJemallocNodumpAllocator(jopts, &allocator);
-      if (!s.ok()) {
-        ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-      }
-    } else {
-      ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-    }
-
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
-    Random rnd(301);
-    // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
-    size_t str_size{8500};
-    std::string str = rnd.RandomString(static_cast<int>(str_size));
-    size_t charge{0};
-    CacheValueChunk* chunks_head =
-        sec_cache->SplitValueIntoChunks(str, kLZ4Compression, charge);
-    ASSERT_EQ(charge, str_size + 3 * (sizeof(CacheValueChunk) - 1));
-
-    CacheValueChunk* current_chunk = chunks_head;
-    ASSERT_EQ(current_chunk->size, 8192 - sizeof(CacheValueChunk) + 1);
-    current_chunk = current_chunk->next;
-    ASSERT_EQ(current_chunk->size, 256 - sizeof(CacheValueChunk) + 1);
-    current_chunk = current_chunk->next;
-    ASSERT_EQ(current_chunk->size, 98);
-
-    sec_cache->GetDeletionCallback(true)("dummy", chunks_head);
-  }
-
-  void MergeChunksIntoValueTest() {
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    Random rnd(301);
-    size_t size1{2048};
-    std::string str1 = rnd.RandomString(static_cast<int>(size1));
-    CacheValueChunk* current_chunk = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size1]);
-    CacheValueChunk* chunks_head = current_chunk;
-    memcpy(current_chunk->data, str1.data(), size1);
-    current_chunk->size = size1;
-
-    size_t size2{256};
-    std::string str2 = rnd.RandomString(static_cast<int>(size2));
-    current_chunk->next = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size2]);
-    current_chunk = current_chunk->next;
-    memcpy(current_chunk->data, str2.data(), size2);
-    current_chunk->size = size2;
-
-    size_t size3{31};
-    std::string str3 = rnd.RandomString(static_cast<int>(size3));
-    current_chunk->next = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size3]);
-    current_chunk = current_chunk->next;
-    memcpy(current_chunk->data, str3.data(), size3);
-    current_chunk->size = size3;
-    current_chunk->next = nullptr;
-
-    std::string str = str1 + str2 + str3;
-
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0);
-    size_t charge{0};
-    CacheAllocationPtr value =
-        sec_cache->MergeChunksIntoValue(chunks_head, charge);
-    ASSERT_EQ(charge, size1 + size2 + size3);
-    std::string value_str{value.get(), charge};
-    ASSERT_EQ(strcmp(value_str.data(), str.data()), 0);
-
-    while (chunks_head != nullptr) {
-      CacheValueChunk* tmp_chunk = chunks_head;
-      chunks_head = chunks_head->next;
-      tmp_chunk->Free();
-    }
-  }
-
-  void SplictValueAndMergeChunksTest() {
-    JemallocAllocatorOptions jopts;
-    std::shared_ptr<MemoryAllocator> allocator;
-    std::string msg;
-    if (JemallocNodumpAllocator::IsSupported(&msg)) {
-      Status s = NewJemallocNodumpAllocator(jopts, &allocator);
-      if (!s.ok()) {
-        ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-      }
-    } else {
-      ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-    }
-
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
-    Random rnd(301);
-    // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
-    size_t str_size{8500};
-    std::string str = rnd.RandomString(static_cast<int>(str_size));
-    size_t charge{0};
-    CacheValueChunk* chunks_head =
-        sec_cache->SplitValueIntoChunks(str, kLZ4Compression, charge);
-    ASSERT_EQ(charge, str_size + 3 * (sizeof(CacheValueChunk) - 1));
-
-    CacheAllocationPtr value =
-        sec_cache->MergeChunksIntoValue(chunks_head, charge);
-    ASSERT_EQ(charge, str_size);
-    std::string value_str{value.get(), charge};
-    ASSERT_EQ(strcmp(value_str.data(), str.data()), 0);
-
-    sec_cache->GetDeletionCallback(true)("dummy", chunks_head);
-  }
-
  private:
   bool fail_create_;
 };
@@ -797,161 +533,110 @@ Cache::CacheItemHelper CompressedSecondaryCacheTest::helper_fail_(
     CompressedSecondaryCacheTest::SaveToCallbackFail,
     CompressedSecondaryCacheTest::DeletionCallback);
 
-class CompressedSecCacheTestWithCompressAndAllocatorParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  CompressedSecCacheTestWithCompressAndAllocatorParam() {
-    sec_cache_is_compressed_ = std::get<0>(GetParam());
-    use_jemalloc_ = std::get<1>(GetParam());
-  }
-  bool sec_cache_is_compressed_;
-  bool use_jemalloc_;
-};
-
-TEST_P(CompressedSecCacheTestWithCompressAndAllocatorParam, BasicTes) {
-  BasicTest(sec_cache_is_compressed_, use_jemalloc_);
+TEST_F(CompressedSecondaryCacheTest, BasicTestWithNoCompression) {
+  BasicTest(false, false);
 }
 
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecCacheTestWithCompressAndAllocatorParam,
-                        ::testing::Combine(testing::Bool(), testing::Bool()));
+TEST_F(CompressedSecondaryCacheTest,
+       BasicTestWithMemoryAllocatorAndNoCompression) {
+  BasicTest(false, true);
+}
 
-class CompressedSecondaryCacheTestWithCompressionParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<bool> {
- public:
-  CompressedSecondaryCacheTestWithCompressionParam() {
-    sec_cache_is_compressed_ = GetParam();
-  }
-  bool sec_cache_is_compressed_;
-};
+TEST_F(CompressedSecondaryCacheTest, BasicTestWithCompression) {
+  BasicTest(true, false);
+}
+
+TEST_F(CompressedSecondaryCacheTest,
+       BasicTestWithMemoryAllocatorAndCompression) {
+  BasicTest(true, true);
+}
 
 #ifndef ROCKSDB_LITE
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam, BasicTestFromString) {
-  std::shared_ptr<SecondaryCache> sec_cache{nullptr};
+TEST_F(CompressedSecondaryCacheTest, BasicTestFromStringWithNoCompression) {
+  std::string sec_cache_uri =
+      "compressed_secondary_cache://"
+      "capacity=2048;num_shard_bits=0;compression_type=kNoCompression";
+  std::shared_ptr<SecondaryCache> sec_cache;
+  Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
+                                              &sec_cache);
+  EXPECT_OK(s);
+  BasicTestHelper(sec_cache);
+}
+
+TEST_F(CompressedSecondaryCacheTest, BasicTestFromStringWithCompression) {
   std::string sec_cache_uri;
-  if (sec_cache_is_compressed_) {
-    if (LZ4_Supported()) {
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kLZ4Compression;"
-          "compress_format_version=2";
-    } else {
-      ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kNoCompression";
-      sec_cache_is_compressed_ = false;
-    }
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
+  if (LZ4_Supported()) {
+    sec_cache_uri =
+        "compressed_secondary_cache://"
+        "capacity=2048;num_shard_bits=0;compression_type=kLZ4Compression;"
+        "compress_format_version=2";
   } else {
+    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
     sec_cache_uri =
         "compressed_secondary_cache://"
         "capacity=2048;num_shard_bits=0;compression_type=kNoCompression";
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
   }
-  BasicTestHelper(sec_cache, sec_cache_is_compressed_);
-}
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       BasicTestFromStringWithSplit) {
-  std::shared_ptr<SecondaryCache> sec_cache{nullptr};
-  std::string sec_cache_uri;
-  if (sec_cache_is_compressed_) {
-    if (LZ4_Supported()) {
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kLZ4Compression;"
-          "compress_format_version=2;enable_custom_split_merge=true";
-    } else {
-      ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kNoCompression;"
-          "enable_custom_split_merge=true";
-      sec_cache_is_compressed_ = false;
-    }
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  } else {
-    sec_cache_uri =
-        "compressed_secondary_cache://"
-        "capacity=2048;num_shard_bits=0;compression_type=kNoCompression;"
-        "enable_custom_split_merge=true";
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  }
-  BasicTestHelper(sec_cache, sec_cache_is_compressed_);
+  std::shared_ptr<SecondaryCache> sec_cache;
+  Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
+                                              &sec_cache);
+  EXPECT_OK(s);
+  BasicTestHelper(sec_cache);
 }
 
 #endif  // ROCKSDB_LITE
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam, FailsTest) {
-  FailsTest(sec_cache_is_compressed_);
+TEST_F(CompressedSecondaryCacheTest, FailsTestWithNoCompression) {
+  FailsTest(false);
 }
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       BasicIntegrationFailTest) {
-  BasicIntegrationFailTest(sec_cache_is_compressed_);
+TEST_F(CompressedSecondaryCacheTest, FailsTestWithCompression) {
+  FailsTest(true);
 }
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationSaveFailTest) {
-  IntegrationSaveFailTest(sec_cache_is_compressed_);
+TEST_F(CompressedSecondaryCacheTest, BasicIntegrationTestWithNoCompression) {
+  BasicIntegrationTest(false);
 }
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationCreateFailTest) {
-  IntegrationCreateFailTest(sec_cache_is_compressed_);
+TEST_F(CompressedSecondaryCacheTest, BasicIntegrationTestWithCompression) {
+  BasicIntegrationTest(true);
 }
 
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationFullCapacityTest) {
-  IntegrationFullCapacityTest(sec_cache_is_compressed_);
+TEST_F(CompressedSecondaryCacheTest,
+       BasicIntegrationFailTestWithNoCompression) {
+  BasicIntegrationFailTest(false);
 }
 
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecondaryCacheTestWithCompressionParam,
-                        testing::Bool());
-
-class CompressedSecCacheTestWithCompressAndSplitParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  CompressedSecCacheTestWithCompressAndSplitParam() {
-    sec_cache_is_compressed_ = std::get<0>(GetParam());
-    enable_custom_split_merge_ = std::get<1>(GetParam());
-  }
-  bool sec_cache_is_compressed_;
-  bool enable_custom_split_merge_;
-};
-
-TEST_P(CompressedSecCacheTestWithCompressAndSplitParam, BasicIntegrationTest) {
-  BasicIntegrationTest(sec_cache_is_compressed_, enable_custom_split_merge_);
+TEST_F(CompressedSecondaryCacheTest, BasicIntegrationFailTestWithCompression) {
+  BasicIntegrationFailTest(true);
 }
 
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecCacheTestWithCompressAndSplitParam,
-                        ::testing::Combine(testing::Bool(), testing::Bool()));
-
-TEST_F(CompressedSecondaryCacheTest, SplitValueIntoChunksTest) {
-  SplitValueIntoChunksTest();
+TEST_F(CompressedSecondaryCacheTest, IntegrationSaveFailTestWithNoCompression) {
+  IntegrationSaveFailTest(false);
 }
 
-TEST_F(CompressedSecondaryCacheTest, MergeChunksIntoValueTest) {
-  MergeChunksIntoValueTest();
+TEST_F(CompressedSecondaryCacheTest, IntegrationSaveFailTestWithCompression) {
+  IntegrationSaveFailTest(true);
 }
 
-TEST_F(CompressedSecondaryCacheTest, SplictValueAndMergeChunksTest) {
-  SplictValueAndMergeChunksTest();
+TEST_F(CompressedSecondaryCacheTest,
+       IntegrationCreateFailTestWithNoCompression) {
+  IntegrationCreateFailTest(false);
+}
+
+TEST_F(CompressedSecondaryCacheTest, IntegrationCreateFailTestWithCompression) {
+  IntegrationCreateFailTest(true);
+}
+
+TEST_F(CompressedSecondaryCacheTest,
+       IntegrationFullCapacityTestWithNoCompression) {
+  IntegrationFullCapacityTest(false);
+}
+
+TEST_F(CompressedSecondaryCacheTest,
+       IntegrationFullCapacityTestWithCompression) {
+  IntegrationFullCapacityTest(true);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

cache/fast_lru_cache.cc

@@ -173,13 +173,13 @@ inline int LRUHandleTable::FindSlot(const Slice& key,
 LRUCacheShard::LRUCacheShard(size_t capacity, size_t estimated_value_size,
                              bool strict_capacity_limit,
                              CacheMetadataChargePolicy metadata_charge_policy)
-    : CacheShard(metadata_charge_policy),
-      capacity_(capacity),
+    : capacity_(capacity),
       strict_capacity_limit_(strict_capacity_limit),
       table_(
           CalcHashBits(capacity, estimated_value_size, metadata_charge_policy)),
       usage_(0),
       lru_usage_(0) {
+  set_metadata_charge_policy(metadata_charge_policy);
   // Make empty circular linked list.
   lru_.next = &lru_;
   lru_.prev = &lru_;
@@ -299,12 +299,10 @@ int LRUCacheShard::CalcHashBits(
 }
 
 void LRUCacheShard::SetCapacity(size_t capacity) {
+  assert(false);  // Not supported. TODO(Guido) Support it?
   autovector<LRUHandle> last_reference_list;
   {
     DMutexLock l(mutex_);
-    if (capacity > capacity_) {
-      assert(false);  // Not supported.
-    }
     capacity_ = capacity;
     EvictFromLRU(0, &last_reference_list);
   }
@@ -525,16 +523,6 @@ size_t LRUCacheShard::GetPinnedUsage() const {
   return usage_ - lru_usage_;
 }
 
-size_t LRUCacheShard::GetOccupancyCount() const {
-  DMutexLock l(mutex_);
-  return table_.GetOccupancy();
-}
-
-size_t LRUCacheShard::GetTableAddressCount() const {
-  DMutexLock l(mutex_);
-  return table_.GetTableSize();
-}
-
 std::string LRUCacheShard::GetPrintableOptions() const { return std::string{}; }
 
 LRUCache::LRUCache(size_t capacity, size_t estimated_value_size,

cache/fast_lru_cache.h

@@ -368,8 +368,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 
   size_t GetUsage() const override;
   size_t GetPinnedUsage() const override;
-  size_t GetOccupancyCount() const override;
-  size_t GetTableAddressCount() const override;
 
   void ApplyToSomeEntries(
       const std::function<void(const Slice& key, void* value, size_t charge,

cache/lru_cache.cc

@@ -12,7 +12,6 @@
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
-#include <cstdlib>
 
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/statistics.h"
@@ -112,28 +111,24 @@ void LRUHandleTable::Resize() {
 
 LRUCacheShard::LRUCacheShard(
     size_t capacity, bool strict_capacity_limit, double high_pri_pool_ratio,
-    double low_pri_pool_ratio, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy, int max_upper_hash_bits,
+    bool use_adaptive_mutex, CacheMetadataChargePolicy metadata_charge_policy,
+    int max_upper_hash_bits,
     const std::shared_ptr<SecondaryCache>& secondary_cache)
-    : CacheShard(metadata_charge_policy),
-      capacity_(0),
+    : capacity_(0),
       high_pri_pool_usage_(0),
-      low_pri_pool_usage_(0),
       strict_capacity_limit_(strict_capacity_limit),
       high_pri_pool_ratio_(high_pri_pool_ratio),
       high_pri_pool_capacity_(0),
-      low_pri_pool_ratio_(low_pri_pool_ratio),
-      low_pri_pool_capacity_(0),
       table_(max_upper_hash_bits),
       usage_(0),
       lru_usage_(0),
       mutex_(use_adaptive_mutex),
       secondary_cache_(secondary_cache) {
+  set_metadata_charge_policy(metadata_charge_policy);
   // Make empty circular linked list.
   lru_.next = &lru_;
   lru_.prev = &lru_;
   lru_low_pri_ = &lru_;
-  lru_bottom_pri_ = &lru_;
   SetCapacity(capacity);
 }
 
@@ -197,12 +192,10 @@ void LRUCacheShard::ApplyToSomeEntries(
       index_begin, index_end);
 }
 
-void LRUCacheShard::TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri,
-                                    LRUHandle** lru_bottom_pri) {
+void LRUCacheShard::TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri) {
   DMutexLock l(mutex_);
   *lru = &lru_;
   *lru_low_pri = lru_low_pri_;
-  *lru_bottom_pri = lru_bottom_pri_;
 }
 
 size_t LRUCacheShard::TEST_GetLRUSize() {
@@ -221,32 +214,20 @@ double LRUCacheShard::GetHighPriPoolRatio() {
   return high_pri_pool_ratio_;
 }
 
-double LRUCacheShard::GetLowPriPoolRatio() {
-  DMutexLock l(mutex_);
-  return low_pri_pool_ratio_;
-}
-
 void LRUCacheShard::LRU_Remove(LRUHandle* e) {
   assert(e->next != nullptr);
   assert(e->prev != nullptr);
   if (lru_low_pri_ == e) {
     lru_low_pri_ = e->prev;
   }
-  if (lru_bottom_pri_ == e) {
-    lru_bottom_pri_ = e->prev;
-  }
   e->next->prev = e->prev;
   e->prev->next = e->next;
   e->prev = e->next = nullptr;
   assert(lru_usage_ >= e->total_charge);
   lru_usage_ -= e->total_charge;
-  assert(!e->InHighPriPool() || !e->InLowPriPool());
   if (e->InHighPriPool()) {
     assert(high_pri_pool_usage_ >= e->total_charge);
     high_pri_pool_usage_ -= e->total_charge;
-  } else if (e->InLowPriPool()) {
-    assert(low_pri_pool_usage_ >= e->total_charge);
-    low_pri_pool_usage_ -= e->total_charge;
   }
 }
 
@@ -260,34 +241,17 @@ void LRUCacheShard::LRU_Insert(LRUHandle* e) {
     e->prev->next = e;
     e->next->prev = e;
     e->SetInHighPriPool(true);
-    e->SetInLowPriPool(false);
     high_pri_pool_usage_ += e->total_charge;
     MaintainPoolSize();
-  } else if (low_pri_pool_ratio_ > 0 &&
-             (e->IsHighPri() || e->IsLowPri() || e->HasHit())) {
-    // Insert "e" to the head of low-pri pool.
+  } else {
+    // Insert "e" to the head of low-pri pool. Note that when
+    // high_pri_pool_ratio is 0, head of low-pri pool is also head of LRU list.
     e->next = lru_low_pri_->next;
     e->prev = lru_low_pri_;
     e->prev->next = e;
     e->next->prev = e;
     e->SetInHighPriPool(false);
-    e->SetInLowPriPool(true);
-    low_pri_pool_usage_ += e->total_charge;
-    MaintainPoolSize();
     lru_low_pri_ = e;
-  } else {
-    // Insert "e" to the head of bottom-pri pool.
-    e->next = lru_bottom_pri_->next;
-    e->prev = lru_bottom_pri_;
-    e->prev->next = e;
-    e->next->prev = e;
-    e->SetInHighPriPool(false);
-    e->SetInLowPriPool(false);
-    // if the low-pri pool is empty, lru_low_pri_ also needs to be updated.
-    if (lru_bottom_pri_ == lru_low_pri_) {
-      lru_low_pri_ = e;
-    }
-    lru_bottom_pri_ = e;
   }
   lru_usage_ += e->total_charge;
 }
@@ -298,20 +262,8 @@ void LRUCacheShard::MaintainPoolSize() {
     lru_low_pri_ = lru_low_pri_->next;
     assert(lru_low_pri_ != &lru_);
     lru_low_pri_->SetInHighPriPool(false);
-    lru_low_pri_->SetInLowPriPool(true);
     assert(high_pri_pool_usage_ >= lru_low_pri_->total_charge);
     high_pri_pool_usage_ -= lru_low_pri_->total_charge;
-    low_pri_pool_usage_ += lru_low_pri_->total_charge;
-  }
-
-  while (low_pri_pool_usage_ > low_pri_pool_capacity_) {
-    // Overflow last entry in low-pri pool to bottom-pri pool.
-    lru_bottom_pri_ = lru_bottom_pri_->next;
-    assert(lru_bottom_pri_ != &lru_);
-    lru_bottom_pri_->SetInHighPriPool(false);
-    lru_bottom_pri_->SetInLowPriPool(false);
-    assert(low_pri_pool_usage_ >= lru_bottom_pri_->total_charge);
-    low_pri_pool_usage_ -= lru_bottom_pri_->total_charge;
   }
 }
 
@@ -330,30 +282,25 @@ void LRUCacheShard::EvictFromLRU(size_t charge,
   }
 }
 
-void LRUCacheShard::TryInsertIntoSecondaryCache(
-    autovector<LRUHandle*> evicted_handles) {
-  for (auto entry : evicted_handles) {
-    if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
-        !entry->IsInSecondaryCache()) {
-      secondary_cache_->Insert(entry->key(), entry->value, entry->info_.helper)
-          .PermitUncheckedError();
-    }
-    // Free the entries here outside of mutex for performance reasons.
-    entry->Free();
-  }
-}
-
 void LRUCacheShard::SetCapacity(size_t capacity) {
   autovector<LRUHandle*> last_reference_list;
   {
     DMutexLock l(mutex_);
     capacity_ = capacity;
     high_pri_pool_capacity_ = capacity_ * high_pri_pool_ratio_;
-    low_pri_pool_capacity_ = capacity_ * low_pri_pool_ratio_;
     EvictFromLRU(0, &last_reference_list);
   }
 
-  TryInsertIntoSecondaryCache(last_reference_list);
+  // Try to insert the evicted entries into tiered cache.
+  // Free the entries outside of mutex for performance reasons.
+  for (auto entry : last_reference_list) {
+    if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
+        !entry->IsInSecondaryCache()) {
+      secondary_cache_->Insert(entry->key(), entry->value, entry->info_.helper)
+          .PermitUncheckedError();
+    }
+    entry->Free();
+  }
 }
 
 void LRUCacheShard::SetStrictCapacityLimit(bool strict_capacity_limit) {
@@ -382,7 +329,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
         last_reference_list.push_back(e);
       } else {
         if (free_handle_on_fail) {
-          free(e);
+          delete[] reinterpret_cast<char*>(e);
           *handle = nullptr;
         }
         s = Status::MemoryLimit("Insert failed due to LRU cache being full.");
@@ -416,7 +363,16 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
     }
   }
 
-  TryInsertIntoSecondaryCache(last_reference_list);
+  // Try to insert the evicted entries into the secondary cache.
+  // Free the entries here outside of mutex for performance reasons.
+  for (auto entry : last_reference_list) {
+    if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
+        !entry->IsInSecondaryCache()) {
+      secondary_cache_->Insert(entry->key(), entry->value, entry->info_.helper)
+          .PermitUncheckedError();
+    }
+    entry->Free();
+  }
 
   return s;
 }
@@ -426,70 +382,23 @@ void LRUCacheShard::Promote(LRUHandle* e) {
 
   assert(secondary_handle->IsReady());
   e->SetIncomplete(false);
-  e->SetInCache(false);
+  e->SetInCache(true);
   e->value = secondary_handle->Value();
   e->CalcTotalCharge(secondary_handle->Size(), metadata_charge_policy_);
   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) {
-    Status s;
-    if (secondary_cache_ && secondary_cache_->SupportForceErase() &&
-        e->IsStandalone()) {
-      // Insert a dummy handle and return a standalone handle to caller.
-      // Charge the standalone handle.
-      autovector<LRUHandle*> last_reference_list;
-      bool free_standalone_handle{false};
-      {
-        DMutexLock l(mutex_);
-
-        // Free the space following strict LRU policy until enough space
-        // is freed or the lru list is empty.
-        EvictFromLRU(e->total_charge, &last_reference_list);
-
-        if ((usage_ + e->total_charge) > capacity_ && strict_capacity_limit_) {
-          free_standalone_handle = true;
-        } else {
-          usage_ += e->total_charge;
-        }
-      }
-
-      TryInsertIntoSecondaryCache(last_reference_list);
-      if (free_standalone_handle) {
-        e->Unref();
-        e->Free();
-        e = nullptr;
-      } else {
-        PERF_COUNTER_ADD(block_cache_standalone_handle_count, 1);
-      }
-
-      // Insert a dummy handle into the primary cache. This dummy handle is
-      // not IsSecondaryCacheCompatible().
-      Cache::Priority priority =
-          e->IsHighPri() ? Cache::Priority::HIGH : Cache::Priority::LOW;
-      s = Insert(e->key(), e->hash, /*value=*/nullptr, 0,
-                 /*deleter=*/nullptr, /*helper=*/nullptr, /*handle=*/nullptr,
-                 priority);
-    } else {
-      e->SetInCache(true);
-      e->SetIsStandalone(false);
-      Cache::Handle* handle = reinterpret_cast<Cache::Handle*>(e);
-      // This InsertItem() 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 it from disk if we erase it
-      // here.
-      s = InsertItem(e, &handle, /*free_handle_on_fail=*/false);
-      if (s.ok()) {
-        PERF_COUNTER_ADD(block_cache_real_handle_count, 1);
-      }
-    }
-
+    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
@@ -497,7 +406,6 @@ void LRUCacheShard::Promote(LRUHandle* e) {
     // TODO
     e->CalcTotalCharge(0, metadata_charge_policy_);
     e->SetInCache(false);
-    e->SetIsStandalone(false);
   }
 }
 
@@ -507,61 +415,37 @@ Cache::Handle* LRUCacheShard::Lookup(
     const ShardedCache::CreateCallback& create_cb, Cache::Priority priority,
     bool wait, Statistics* stats) {
   LRUHandle* e = nullptr;
-  bool found_dummy_entry{false};
   {
     DMutexLock l(mutex_);
     e = table_.Lookup(key, hash);
     if (e != nullptr) {
       assert(e->InCache());
       if (!e->HasRefs()) {
-        // The entry is in LRU since it's in hash and has no external
-        // references.
+        // The entry is in LRU since it's in hash and has no external references
         LRU_Remove(e);
       }
       e->Ref();
       e->SetHit();
-
-      // For a dummy handle, if it was retrieved from secondary cache,
-      // it may still exist in secondary cache.
-      // If the handle exists in secondary cache, the value should be
-      // erased from sec cache and be inserted into primary cache.
-      if (!e->value && secondary_cache_ &&
-          secondary_cache_->SupportForceErase()) {
-        found_dummy_entry = true;
-      }
     }
   }
 
-  // If handle table lookup failed or the handle is a dummy one, allocate
-  // a handle outside the mutex if we re going to lookup in the secondary cache.
-  //
-  // When a block is firstly Lookup from CompressedSecondaryCache, we just
-  // insert a dummy block into the primary cache (charging the actual size of
-  // the block) and don't erase the block from CompressedSecondaryCache. A
-  // standalone handle is returned to the caller. Only if the block is hit
-  // again, we erase it from CompressedSecondaryCache and add it into the
-  // primary cache.
-  //
+  // If handle table lookup failed, then allocate a handle outside the
+  // 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 || found_dummy_entry) && secondary_cache_ && helper &&
-      helper->saveto_cb) {
+  if (!e && secondary_cache_ && helper && helper->saveto_cb) {
     // 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);
-    // Release the dummy handle.
-    if (e) {
-      Release(reinterpret_cast<Cache::Handle*>(e), true /*erase_if_last_ref*/);
-    }
     bool is_in_sec_cache{false};
     std::unique_ptr<SecondaryCacheResultHandle> secondary_handle =
-        secondary_cache_->Lookup(key, create_cb, wait, found_dummy_entry,
-                                 is_in_sec_cache);
+        secondary_cache_->Lookup(key, create_cb, wait, is_in_sec_cache);
     if (secondary_handle != nullptr) {
-      e = static_cast<LRUHandle*>(malloc(sizeof(LRUHandle) - 1 + key.size()));
+      e = reinterpret_cast<LRUHandle*>(
+          new char[sizeof(LRUHandle) - 1 + key.size()]);
 
       e->flags = 0;
       e->SetSecondaryCacheCompatible(true);
@@ -574,38 +458,30 @@ Cache::Handle* LRUCacheShard::Lookup(
       memcpy(e->key_data, key.data(), key.size());
       e->value = nullptr;
       e->sec_handle = secondary_handle.release();
-      e->total_charge = 0;
       e->Ref();
-      e->SetIsInSecondaryCache(is_in_sec_cache);
-
-      if (secondary_cache_->SupportForceErase() && !found_dummy_entry) {
-        e->SetIsStandalone(true);
-      }
 
       if (wait) {
         Promote(e);
-        if (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);
-          }
+        e->SetIsInSecondaryCache(is_in_sec_cache);
+        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);
+        e->SetIsInSecondaryCache(is_in_sec_cache);
         // 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);
       }
-    } else {
-      e = nullptr;
     }
   }
   return reinterpret_cast<Cache::Handle*>(e);
@@ -627,13 +503,6 @@ void LRUCacheShard::SetHighPriorityPoolRatio(double high_pri_pool_ratio) {
   MaintainPoolSize();
 }
 
-void LRUCacheShard::SetLowPriorityPoolRatio(double low_pri_pool_ratio) {
-  DMutexLock l(mutex_);
-  low_pri_pool_ratio_ = low_pri_pool_ratio;
-  low_pri_pool_capacity_ = capacity_ * low_pri_pool_ratio_;
-  MaintainPoolSize();
-}
-
 bool LRUCacheShard::Release(Cache::Handle* handle, bool erase_if_last_ref) {
   if (handle == nullptr) {
     return false;
@@ -660,7 +529,7 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool erase_if_last_ref) {
     // 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, that means the lookup
+    // 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)) {
       assert(usage_ >= e->total_charge);
@@ -683,8 +552,8 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
   // Allocate the memory here outside of the mutex.
   // If the cache is full, we'll have to release it.
   // It shouldn't happen very often though.
-  LRUHandle* e =
-      static_cast<LRUHandle*>(malloc(sizeof(LRUHandle) - 1 + key.size()));
+  LRUHandle* e = reinterpret_cast<LRUHandle*>(
+      new char[sizeof(LRUHandle) - 1 + key.size()]);
 
   e->value = value;
   e->flags = 0;
@@ -758,16 +627,6 @@ size_t LRUCacheShard::GetPinnedUsage() const {
   return usage_ - lru_usage_;
 }
 
-size_t LRUCacheShard::GetOccupancyCount() const {
-  DMutexLock l(mutex_);
-  return table_.GetOccupancyCount();
-}
-
-size_t LRUCacheShard::GetTableAddressCount() const {
-  DMutexLock l(mutex_);
-  return size_t{1} << table_.GetLengthBits();
-}
-
 std::string LRUCacheShard::GetPrintableOptions() const {
   const int kBufferSize = 200;
   char buffer[kBufferSize];
@@ -775,15 +634,12 @@ std::string LRUCacheShard::GetPrintableOptions() const {
     DMutexLock l(mutex_);
     snprintf(buffer, kBufferSize, "    high_pri_pool_ratio: %.3lf\n",
              high_pri_pool_ratio_);
-    snprintf(buffer + strlen(buffer), kBufferSize - strlen(buffer),
-             "    low_pri_pool_ratio: %.3lf\n", low_pri_pool_ratio_);
   }
   return std::string(buffer);
 }
 
 LRUCache::LRUCache(size_t capacity, int num_shard_bits,
                    bool strict_capacity_limit, double high_pri_pool_ratio,
-                   double low_pri_pool_ratio,
                    std::shared_ptr<MemoryAllocator> allocator,
                    bool use_adaptive_mutex,
                    CacheMetadataChargePolicy metadata_charge_policy,
@@ -797,7 +653,7 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
   for (int i = 0; i < num_shards_; i++) {
     new (&shards_[i]) LRUCacheShard(
         per_shard, strict_capacity_limit, high_pri_pool_ratio,
-        low_pri_pool_ratio, use_adaptive_mutex, metadata_charge_policy,
+        use_adaptive_mutex, metadata_charge_policy,
         /* max_upper_hash_bits */ 32 - num_shard_bits, secondary_cache);
   }
   secondary_cache_ = secondary_cache;
@@ -919,8 +775,7 @@ std::shared_ptr<Cache> NewLRUCache(
     double high_pri_pool_ratio,
     std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
     CacheMetadataChargePolicy metadata_charge_policy,
-    const std::shared_ptr<SecondaryCache>& secondary_cache,
-    double low_pri_pool_ratio) {
+    const std::shared_ptr<SecondaryCache>& secondary_cache) {
   if (num_shard_bits >= 20) {
     return nullptr;  // The cache cannot be sharded into too many fine pieces.
   }
@@ -928,40 +783,30 @@ std::shared_ptr<Cache> NewLRUCache(
     // Invalid high_pri_pool_ratio
     return nullptr;
   }
-  if (low_pri_pool_ratio < 0.0 || low_pri_pool_ratio > 1.0) {
-    // Invalid high_pri_pool_ratio
-    return nullptr;
-  }
-  if (low_pri_pool_ratio + high_pri_pool_ratio > 1.0) {
-    // Invalid high_pri_pool_ratio and low_pri_pool_ratio combination
-    return nullptr;
-  }
   if (num_shard_bits < 0) {
     num_shard_bits = GetDefaultCacheShardBits(capacity);
   }
   return std::make_shared<LRUCache>(
       capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      low_pri_pool_ratio, std::move(memory_allocator), use_adaptive_mutex,
-      metadata_charge_policy, secondary_cache);
+      std::move(memory_allocator), use_adaptive_mutex, metadata_charge_policy,
+      secondary_cache);
 }
 
 std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
-  return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
-                     cache_opts.strict_capacity_limit,
-                     cache_opts.high_pri_pool_ratio,
-                     cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
-                     cache_opts.metadata_charge_policy,
-                     cache_opts.secondary_cache, cache_opts.low_pri_pool_ratio);
+  return NewLRUCache(
+      cache_opts.capacity, cache_opts.num_shard_bits,
+      cache_opts.strict_capacity_limit, cache_opts.high_pri_pool_ratio,
+      cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
+      cache_opts.metadata_charge_policy, cache_opts.secondary_cache);
 }
 
 std::shared_ptr<Cache> NewLRUCache(
     size_t capacity, int num_shard_bits, bool strict_capacity_limit,
     double high_pri_pool_ratio,
     std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    double low_pri_pool_ratio) {
+    CacheMetadataChargePolicy metadata_charge_policy) {
   return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
                      high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                     metadata_charge_policy, nullptr, low_pri_pool_ratio);
+                     metadata_charge_policy, nullptr);
 }
 }  // namespace ROCKSDB_NAMESPACE

cache/lru_cache.h

@@ -40,11 +40,8 @@ namespace lru_cache {
 //    In that case the entry is not in the LRU list and not in hash table.
 //    The entry can be freed when refs becomes 0.
 //    (refs >= 1 && in_cache == false)
-// 4. The handle is never inserted into the LRUCache (both hash table and LRU
-//    list) and it doesn't experience the above three states.
-//    The entry can be freed when refs becomes 0.
-//    (refs >= 1 && in_cache == false && IS_STANDALONE == true)
-// All newly created LRUHandles are in state 1 or 4. If you call
+//
+// All newly created LRUHandles are in state 1. If you call
 // LRUCacheShard::Release on entry in state 1, it will go into state 2.
 // To move from state 1 to state 3, either call LRUCacheShard::Erase or
 // LRUCacheShard::Insert with the same key (but possibly different value).
@@ -77,7 +74,7 @@ struct LRUHandle {
   // The number of external refs to this entry. The cache itself is not counted.
   uint32_t refs;
 
-  enum Flags : uint16_t {
+  enum Flags : uint8_t {
     // Whether this entry is referenced by the hash table.
     IN_CACHE = (1 << 0),
     // Whether this entry is high priority entry.
@@ -92,16 +89,9 @@ struct LRUHandle {
     IS_PENDING = (1 << 5),
     // Whether this handle is still in a lower tier
     IS_IN_SECONDARY_CACHE = (1 << 6),
-    // Whether this entry is low priority entry.
-    IS_LOW_PRI = (1 << 7),
-    // Whether this entry is in low-pri pool.
-    IN_LOW_PRI_POOL = (1 << 8),
-    // Whether this entry is not inserted into the cache (both hash table and
-    // LRU list).
-    IS_STANDALONE = (1 << 9),
   };
 
-  uint16_t flags;
+  uint8_t flags;
 
 #ifdef __SANITIZE_THREAD__
   // TSAN can report a false data race on flags, where one thread is writing
@@ -132,8 +122,6 @@ struct LRUHandle {
   bool InCache() const { return flags & IN_CACHE; }
   bool IsHighPri() const { return flags & IS_HIGH_PRI; }
   bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
-  bool IsLowPri() const { return flags & IS_LOW_PRI; }
-  bool InLowPriPool() const { return flags & IN_LOW_PRI_POOL; }
   bool HasHit() const { return flags & HAS_HIT; }
   bool IsSecondaryCacheCompatible() const {
 #ifdef __SANITIZE_THREAD__
@@ -144,7 +132,6 @@ struct LRUHandle {
   }
   bool IsPending() const { return flags & IS_PENDING; }
   bool IsInSecondaryCache() const { return flags & IS_IN_SECONDARY_CACHE; }
-  bool IsStandalone() const { return flags & IS_STANDALONE; }
 
   void SetInCache(bool in_cache) {
     if (in_cache) {
@@ -157,13 +144,8 @@ struct LRUHandle {
   void SetPriority(Cache::Priority priority) {
     if (priority == Cache::Priority::HIGH) {
       flags |= IS_HIGH_PRI;
-      flags &= ~IS_LOW_PRI;
-    } else if (priority == Cache::Priority::LOW) {
-      flags &= ~IS_HIGH_PRI;
-      flags |= IS_LOW_PRI;
     } else {
       flags &= ~IS_HIGH_PRI;
-      flags &= ~IS_LOW_PRI;
     }
   }
 
@@ -175,14 +157,6 @@ struct LRUHandle {
     }
   }
 
-  void SetInLowPriPool(bool in_low_pri_pool) {
-    if (in_low_pri_pool) {
-      flags |= IN_LOW_PRI_POOL;
-    } else {
-      flags &= ~IN_LOW_PRI_POOL;
-    }
-  }
-
   void SetHit() { flags |= HAS_HIT; }
 
   void SetSecondaryCacheCompatible(bool compat) {
@@ -212,14 +186,6 @@ struct LRUHandle {
     }
   }
 
-  void SetIsStandalone(bool is_standalone) {
-    if (is_standalone) {
-      flags |= IS_STANDALONE;
-    } else {
-      flags &= ~IS_STANDALONE;
-    }
-  }
-
   void Free() {
     assert(refs == 0);
 #ifdef __SANITIZE_THREAD__
@@ -241,8 +207,7 @@ struct LRUHandle {
         (*info_.helper->del_cb)(key(), value);
       }
     }
-
-    free(this);
+    delete[] reinterpret_cast<char*>(this);
   }
 
   inline size_t CalcuMetaCharge(
@@ -306,8 +271,6 @@ class LRUHandleTable {
 
   int GetLengthBits() const { return length_bits_; }
 
-  size_t GetOccupancyCount() const { return elems_; }
-
  private:
   // Return a pointer to slot that points to a cache entry that
   // matches key/hash.  If there is no such cache entry, return a
@@ -335,8 +298,7 @@ class LRUHandleTable {
 class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  public:
   LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                double high_pri_pool_ratio, double low_pri_pool_ratio,
-                bool use_adaptive_mutex,
+                double high_pri_pool_ratio, bool use_adaptive_mutex,
                 CacheMetadataChargePolicy metadata_charge_policy,
                 int max_upper_hash_bits,
                 const std::shared_ptr<SecondaryCache>& secondary_cache);
@@ -353,9 +315,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   // Set percentage of capacity reserved for high-pri cache entries.
   void SetHighPriorityPoolRatio(double high_pri_pool_ratio);
 
-  // Set percentage of capacity reserved for low-pri cache entries.
-  void SetLowPriorityPoolRatio(double low_pri_pool_ratio);
-
   // Like Cache methods, but with an extra "hash" parameter.
   virtual Status Insert(const Slice& key, uint32_t hash, void* value,
                         size_t charge, Cache::DeleterFn deleter,
@@ -397,8 +356,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 
   virtual size_t GetUsage() const override;
   virtual size_t GetPinnedUsage() const override;
-  virtual size_t GetOccupancyCount() const override;
-  virtual size_t GetTableAddressCount() const override;
 
   virtual void ApplyToSomeEntries(
       const std::function<void(const Slice& key, void* value, size_t charge,
@@ -409,19 +366,15 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 
   virtual std::string GetPrintableOptions() const override;
 
-  void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri,
-                       LRUHandle** lru_bottom_pri);
+  void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri);
 
-  // Retrieves number of elements in LRU, for unit test purpose only.
-  // Not threadsafe.
+  //  Retrieves number of elements in LRU, for unit test purpose only.
+  //  Not threadsafe.
   size_t TEST_GetLRUSize();
 
-  // Retrieves high pri pool ratio
+  //  Retrieves high pri pool ratio
   double GetHighPriPoolRatio();
 
-  // Retrieves low pri pool ratio
-  double GetLowPriPoolRatio();
-
  private:
   friend class LRUCache;
   // Insert an item into the hash table and, if handle is null, insert into
@@ -455,18 +408,12 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   // holding the mutex_.
   void EvictFromLRU(size_t charge, autovector<LRUHandle*>* deleted);
 
-  // Try to insert the evicted handles into the secondary cache.
-  void TryInsertIntoSecondaryCache(autovector<LRUHandle*> evicted_handles);
-
   // Initialized before use.
   size_t capacity_;
 
   // Memory size for entries in high-pri pool.
   size_t high_pri_pool_usage_;
 
-  // Memory size for entries in low-pri pool.
-  size_t low_pri_pool_usage_;
-
   // Whether to reject insertion if cache reaches its full capacity.
   bool strict_capacity_limit_;
 
@@ -477,13 +424,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   // Remember the value to avoid recomputing each time.
   double high_pri_pool_capacity_;
 
-  // Ratio of capacity reserved for low priority cache entries.
-  double low_pri_pool_ratio_;
-
-  // Low-pri pool size, equals to capacity * low_pri_pool_ratio.
-  // Remember the value to avoid recomputing each time.
-  double low_pri_pool_capacity_;
-
   // Dummy head of LRU list.
   // lru.prev is newest entry, lru.next is oldest entry.
   // LRU contains items which can be evicted, ie reference only by cache
@@ -492,9 +432,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
   // Pointer to head of low-pri pool in LRU list.
   LRUHandle* lru_low_pri_;
 
-  // Pointer to head of bottom-pri pool in LRU list.
-  LRUHandle* lru_bottom_pri_;
-
   // ------------^^^^^^^^^^^^^-----------
   // Not frequently modified data members
   // ------------------------------------
@@ -529,7 +466,7 @@ class LRUCache
     : public ShardedCache {
  public:
   LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-           double high_pri_pool_ratio, double low_pri_pool_ratio,
+           double high_pri_pool_ratio,
            std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
            bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
            CacheMetadataChargePolicy metadata_charge_policy =
@@ -547,9 +484,9 @@ class LRUCache
   virtual void WaitAll(std::vector<Handle*>& handles) override;
   std::string GetPrintableOptions() const override;
 
-  // Retrieves number of elements in LRU, for unit test purpose only.
+  //  Retrieves number of elements in LRU, for unit test purpose only.
   size_t TEST_GetLRUSize();
-  // Retrieves high pri pool ratio.
+  //  Retrieves high pri pool ratio.
   double GetHighPriPoolRatio();
 
  private:

cache/sharded_cache.cc

@@ -213,9 +213,9 @@ std::string ShardedCache::GetPrintableOptions() const {
   ret.append(GetShard(0)->GetPrintableOptions());
   return ret;
 }
-
-int GetDefaultCacheShardBits(size_t capacity, size_t min_shard_size) {
+int GetDefaultCacheShardBits(size_t capacity) {
   int num_shard_bits = 0;
+  size_t min_shard_size = 512L * 1024L;  // Every shard is at least 512KB.
   size_t num_shards = capacity / min_shard_size;
   while (num_shards >>= 1) {
     if (++num_shard_bits >= 6) {
@@ -230,21 +230,4 @@ int ShardedCache::GetNumShardBits() const { return BitsSetToOne(shard_mask_); }
 
 uint32_t ShardedCache::GetNumShards() const { return shard_mask_ + 1; }
 
-size_t ShardedCache::GetOccupancyCount() const {
-  size_t oc = 0;
-  uint32_t num_shards = GetNumShards();
-  for (uint32_t s = 0; s < num_shards; s++) {
-    oc += GetShard(s)->GetOccupancyCount();
-  }
-  return oc;
-}
-size_t ShardedCache::GetTableAddressCount() const {
-  size_t tac = 0;
-  uint32_t num_shards = GetNumShards();
-  for (uint32_t s = 0; s < num_shards; s++) {
-    tac += GetShard(s)->GetTableAddressCount();
-  }
-  return tac;
-}
-
 }  // namespace ROCKSDB_NAMESPACE

cache/sharded_cache.h

@@ -20,8 +20,7 @@ namespace ROCKSDB_NAMESPACE {
 // Single cache shard interface.
 class CacheShard {
  public:
-  explicit CacheShard(CacheMetadataChargePolicy metadata_charge_policy)
-      : metadata_charge_policy_(metadata_charge_policy) {}
+  CacheShard() = default;
   virtual ~CacheShard() = default;
 
   using DeleterFn = Cache::DeleterFn;
@@ -48,8 +47,6 @@ class CacheShard {
   virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
   virtual size_t GetUsage() const = 0;
   virtual size_t GetPinnedUsage() const = 0;
-  virtual size_t GetOccupancyCount() const = 0;
-  virtual size_t GetTableAddressCount() const = 0;
   // Handles iterating over roughly `average_entries_per_lock` entries, using
   // `state` to somehow record where it last ended up. Caller initially uses
   // *state == 0 and implementation sets *state = UINT32_MAX to indicate
@@ -60,9 +57,13 @@ class CacheShard {
       uint32_t average_entries_per_lock, uint32_t* state) = 0;
   virtual void EraseUnRefEntries() = 0;
   virtual std::string GetPrintableOptions() const { return ""; }
+  void set_metadata_charge_policy(
+      CacheMetadataChargePolicy metadata_charge_policy) {
+    metadata_charge_policy_ = metadata_charge_policy;
+  }
 
  protected:
-  const CacheMetadataChargePolicy metadata_charge_policy_;
+  CacheMetadataChargePolicy metadata_charge_policy_ = kDontChargeCacheMetadata;
 };
 
 // Generic cache interface which shards cache by hash of keys. 2^num_shard_bits
@@ -85,7 +86,7 @@ class ShardedCache : public Cache {
                         DeleterFn deleter, Handle** handle,
                         Priority priority) override;
   virtual Status Insert(const Slice& key, void* value,
-                        const CacheItemHelper* helper, size_t charge,
+                        const CacheItemHelper* helper, size_t chargge,
                         Handle** handle = nullptr,
                         Priority priority = Priority::LOW) override;
   virtual Handle* Lookup(const Slice& key, Statistics* stats) override;
@@ -105,8 +106,6 @@ class ShardedCache : public Cache {
   virtual size_t GetUsage() const override;
   virtual size_t GetUsage(Handle* handle) const override;
   virtual size_t GetPinnedUsage() const override;
-  virtual size_t GetOccupancyCount() const override;
-  virtual size_t GetTableAddressCount() const override;
   virtual void ApplyToAllEntries(
       const std::function<void(const Slice& key, void* value, size_t charge,
                                DeleterFn deleter)>& callback,
@@ -128,8 +127,6 @@ class ShardedCache : public Cache {
   std::atomic<uint64_t> last_id_;
 };
 
-// 512KB is traditional minimum shard size.
-int GetDefaultCacheShardBits(size_t capacity,
-                             size_t min_shard_size = 512U * 1024U);
+extern int GetDefaultCacheShardBits(size_t capacity);
 
 }  // namespace ROCKSDB_NAMESPACE

crash_test.mk

@@ -18,9 +18,7 @@ CRASHTEST_PY=$(PYTHON) -u tools/db_crashtest.py --stress_cmd=$(DB_STRESS_CMD)
 	whitebox_crash_test whitebox_crash_test_with_atomic_flush \
 	whitebox_crash_test_with_txn whitebox_crash_test_with_ts \
 	blackbox_crash_test_with_multiops_wc_txn \
-	blackbox_crash_test_with_multiops_wp_txn \
-	crash_test_with_tiered_storage blackbox_crash_test_with_tiered_storage \
-	whitebox_crash_test_with_tiered_storage \
+	blackbox_crash_test_with_multiops_wp_txn
 
 crash_test: $(DB_STRESS_CMD)
 # Do not parallelize
@@ -44,11 +42,6 @@ crash_test_with_ts: $(DB_STRESS_CMD)
 	$(CRASHTEST_MAKE) whitebox_crash_test_with_ts
 	$(CRASHTEST_MAKE) blackbox_crash_test_with_ts
 
-crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_tiered_storage
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_tiered_storage
-
 crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
 	$(CRASHTEST_MAKE) blackbox_crash_test_with_multiops_wc_txn
 
@@ -77,9 +70,6 @@ blackbox_crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
 blackbox_crash_test_with_multiops_wp_txn: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --test_multiops_txn --write_policy write_prepared blackbox $(CRASH_TEST_EXT_ARGS)
 
-blackbox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_tiered_storage blackbox $(CRASH_TEST_EXT_ARGS)
-
 ifeq ($(CRASH_TEST_KILL_ODD),)
   CRASH_TEST_KILL_ODD=888887
 endif
@@ -101,7 +91,3 @@ whitebox_crash_test_with_txn: $(DB_STRESS_CMD)
 whitebox_crash_test_with_ts: $(DB_STRESS_CMD)
 	$(CRASHTEST_PY) --enable_ts whitebox --random_kill_odd \
       $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_tiered_storage whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

db/arena_wrapped_db_iter.cc

@@ -45,7 +45,6 @@ void ArenaWrappedDBIter::Init(
   sv_number_ = version_number;
   read_options_ = read_options;
   allow_refresh_ = allow_refresh;
-  memtable_range_tombstone_iter_ = nullptr;
 }
 
 Status ArenaWrappedDBIter::Refresh() {
@@ -59,68 +58,41 @@ Status ArenaWrappedDBIter::Refresh() {
   uint64_t cur_sv_number = cfd_->GetSuperVersionNumber();
   TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:1");
   TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:2");
-  auto reinit_internal_iter = [&]() {
-    Env* env = db_iter_->env();
-    db_iter_->~DBIter();
-    arena_.~Arena();
-    new (&arena_) Arena();
-
-    SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_);
-    SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
-    if (read_callback_) {
-      read_callback_->Refresh(latest_seq);
-    }
-    Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
-         sv->current, latest_seq,
-         sv->mutable_cf_options.max_sequential_skip_in_iterations,
-         cur_sv_number, read_callback_, db_impl_, cfd_, expose_blob_index_,
-         allow_refresh_);
-
-    InternalIterator* internal_iter = db_impl_->NewInternalIterator(
-        read_options_, cfd_, sv, &arena_, latest_seq,
-        /* allow_unprepared_value */ true, /* db_iter */ this);
-    SetIterUnderDBIter(internal_iter);
-  };
   while (true) {
     if (sv_number_ != cur_sv_number) {
-      reinit_internal_iter();
+      Env* env = db_iter_->env();
+      db_iter_->~DBIter();
+      arena_.~Arena();
+      new (&arena_) Arena();
+
+      SuperVersion* sv = cfd_->GetReferencedSuperVersion(db_impl_);
+      SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
+      if (read_callback_) {
+        read_callback_->Refresh(latest_seq);
+      }
+      Init(env, read_options_, *(cfd_->ioptions()), sv->mutable_cf_options,
+           sv->current, latest_seq,
+           sv->mutable_cf_options.max_sequential_skip_in_iterations,
+           cur_sv_number, read_callback_, db_impl_, cfd_, expose_blob_index_,
+           allow_refresh_);
+
+      InternalIterator* internal_iter = db_impl_->NewInternalIterator(
+          read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator(),
+          latest_seq, /* allow_unprepared_value */ true);
+      SetIterUnderDBIter(internal_iter);
       break;
     } else {
       SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
       // Refresh range-tombstones in MemTable
       if (!read_options_.ignore_range_deletions) {
         SuperVersion* sv = cfd_->GetThreadLocalSuperVersion(db_impl_);
-        TEST_SYNC_POINT_CALLBACK("ArenaWrappedDBIter::Refresh:SV", nullptr);
-        auto t = sv->mem->NewRangeTombstoneIterator(
-            read_options_, latest_seq, false /* immutable_memtable */);
-        if (!t || t->empty()) {
-          // If memtable_range_tombstone_iter_ points to a non-empty tombstone
-          // iterator, then it means sv->mem is not the memtable that
-          // memtable_range_tombstone_iter_ points to, so SV must have changed
-          // after the sv_number_ != cur_sv_number check above. We will fall
-          // back to re-init the InternalIterator, and the tombstone iterator
-          // will be freed during db_iter destruction there.
-          if (memtable_range_tombstone_iter_) {
-            assert(!*memtable_range_tombstone_iter_ ||
-                   sv_number_ != cfd_->GetSuperVersionNumber());
-          }
-          delete t;
-        } else {  // current mutable memtable has range tombstones
-          if (!memtable_range_tombstone_iter_) {
-            delete t;
-            db_impl_->ReturnAndCleanupSuperVersion(cfd_, sv);
-            // The memtable under DBIter did not have range tombstone before
-            // refresh.
-            reinit_internal_iter();
-            break;
-          } else {
-            delete *memtable_range_tombstone_iter_;
-            *memtable_range_tombstone_iter_ = new TruncatedRangeDelIterator(
-                std::unique_ptr<FragmentedRangeTombstoneIterator>(t),
-                &cfd_->internal_comparator(), nullptr, nullptr);
-          }
-        }
-        db_impl_->ReturnAndCleanupSuperVersion(cfd_, sv);
+        ReadRangeDelAggregator* range_del_agg =
+            db_iter_->GetRangeDelAggregator();
+        std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter;
+        range_del_iter.reset(
+            sv->mem->NewRangeTombstoneIterator(read_options_, latest_seq));
+        range_del_agg->AddTombstones(std::move(range_del_iter));
+        cfd_->ReturnThreadLocalSuperVersion(sv);
       }
       // Refresh latest sequence number
       db_iter_->set_sequence(latest_seq);

db/arena_wrapped_db_iter.h

@@ -44,7 +44,9 @@ class ArenaWrappedDBIter : public Iterator {
   // Get the arena to be used to allocate memory for DBIter to be wrapped,
   // as well as child iterators in it.
   virtual Arena* GetArena() { return &arena_; }
-
+  virtual ReadRangeDelAggregator* GetRangeDelAggregator() {
+    return db_iter_->GetRangeDelAggregator();
+  }
   const ReadOptions& GetReadOptions() { return read_options_; }
 
   // Set the internal iterator wrapped inside the DB Iterator. Usually it is
@@ -53,10 +55,6 @@ class ArenaWrappedDBIter : public Iterator {
     db_iter_->SetIter(iter);
   }
 
-  void SetMemtableRangetombstoneIter(TruncatedRangeDelIterator** iter) {
-    memtable_range_tombstone_iter_ = iter;
-  }
-
   bool Valid() const override { return db_iter_->Valid(); }
   void SeekToFirst() override { db_iter_->SeekToFirst(); }
   void SeekToLast() override { db_iter_->SeekToLast(); }
@@ -70,7 +68,6 @@ class ArenaWrappedDBIter : public Iterator {
   void Prev() override { db_iter_->Prev(); }
   Slice key() const override { return db_iter_->key(); }
   Slice value() const override { return db_iter_->value(); }
-  const WideColumns& columns() const override { return db_iter_->columns(); }
   Status status() const override { return db_iter_->status(); }
   Slice timestamp() const override { return db_iter_->timestamp(); }
   bool IsBlob() const { return db_iter_->IsBlob(); }
@@ -107,9 +104,6 @@ class ArenaWrappedDBIter : public Iterator {
   ReadCallback* read_callback_;
   bool expose_blob_index_ = false;
   bool allow_refresh_ = true;
-  // If this is nullptr, it means the mutable memtable does not contain range
-  // tombstone when added under this DBIter.
-  TruncatedRangeDelIterator** memtable_range_tombstone_iter_ = nullptr;
 };
 
 // Generate the arena wrapped iterator class.

db/blob/blob_contents.cc

@@ -1,90 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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_contents.h"
-
-#include <cassert>
-
-#include "cache/cache_entry_roles.h"
-#include "cache/cache_helpers.h"
-#include "port/malloc.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-std::unique_ptr<BlobContents> BlobContents::Create(
-    CacheAllocationPtr&& allocation, size_t size) {
-  return std::unique_ptr<BlobContents>(
-      new BlobContents(std::move(allocation), size));
-}
-
-size_t BlobContents::ApproximateMemoryUsage() const {
-  size_t usage = 0;
-
-  if (allocation_) {
-    MemoryAllocator* const allocator = allocation_.get_deleter().allocator;
-
-    if (allocator) {
-      usage += allocator->UsableSize(allocation_.get(), data_.size());
-    } else {
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      usage += malloc_usable_size(allocation_.get());
-#else
-      usage += data_.size();
-#endif
-    }
-  }
-
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-  usage += malloc_usable_size(const_cast<BlobContents*>(this));
-#else
-  usage += sizeof(*this);
-#endif
-
-  return usage;
-}
-
-size_t BlobContents::SizeCallback(void* obj) {
-  assert(obj);
-
-  return static_cast<const BlobContents*>(obj)->size();
-}
-
-Status BlobContents::SaveToCallback(void* from_obj, size_t from_offset,
-                                    size_t length, void* out) {
-  assert(from_obj);
-
-  const BlobContents* buf = static_cast<const BlobContents*>(from_obj);
-  assert(buf->size() >= from_offset + length);
-
-  memcpy(out, buf->data().data() + from_offset, length);
-
-  return Status::OK();
-}
-
-Cache::CacheItemHelper* BlobContents::GetCacheItemHelper() {
-  static Cache::CacheItemHelper cache_helper(
-      &SizeCallback, &SaveToCallback,
-      GetCacheEntryDeleterForRole<BlobContents, CacheEntryRole::kBlobValue>());
-
-  return &cache_helper;
-}
-
-Status BlobContents::CreateCallback(CacheAllocationPtr&& allocation,
-                                    const void* buf, size_t size,
-                                    void** out_obj, size_t* charge) {
-  assert(allocation);
-
-  memcpy(allocation.get(), buf, size);
-
-  std::unique_ptr<BlobContents> obj = Create(std::move(allocation), size);
-  BlobContents* const contents = obj.release();
-
-  *out_obj = contents;
-  *charge = contents->ApproximateMemoryUsage();
-
-  return Status::OK();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_contents.h

@@ -1,56 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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 <memory>
-
-#include "memory/memory_allocator.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A class representing a single uncompressed value read from a blob file.
-class BlobContents {
- public:
-  static std::unique_ptr<BlobContents> Create(CacheAllocationPtr&& allocation,
-                                              size_t size);
-
-  BlobContents(const BlobContents&) = delete;
-  BlobContents& operator=(const BlobContents&) = delete;
-
-  BlobContents(BlobContents&&) = default;
-  BlobContents& operator=(BlobContents&&) = default;
-
-  ~BlobContents() = default;
-
-  const Slice& data() const { return data_; }
-  size_t size() const { return data_.size(); }
-
-  size_t ApproximateMemoryUsage() const;
-
-  // Callbacks for secondary cache
-  static size_t SizeCallback(void* obj);
-
-  static Status SaveToCallback(void* from_obj, size_t from_offset,
-                               size_t length, void* out);
-
-  static Cache::CacheItemHelper* GetCacheItemHelper();
-
-  static Status CreateCallback(CacheAllocationPtr&& allocation, const void* buf,
-                               size_t size, void** out_obj, size_t* charge);
-
- private:
-  BlobContents(CacheAllocationPtr&& allocation, size_t size)
-      : allocation_(std::move(allocation)), data_(allocation_.get(), size) {}
-
-  CacheAllocationPtr allocation_;
-  Slice data_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_builder.cc

@@ -7,7 +7,6 @@
 
 #include <cassert>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_addition.h"
 #include "db/blob/blob_file_completion_callback.h"
 #include "db/blob/blob_index.h"
@@ -33,9 +32,9 @@ BlobFileBuilder::BlobFileBuilder(
     VersionSet* versions, FileSystem* fs,
     const ImmutableOptions* immutable_options,
     const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
-    std::string db_id, std::string db_session_id, int job_id,
-    uint32_t column_family_id, const std::string& column_family_name,
-    Env::IOPriority io_priority, Env::WriteLifeTimeHint write_hint,
+    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,
@@ -43,18 +42,17 @@ BlobFileBuilder::BlobFileBuilder(
     std::vector<BlobFileAddition>* blob_file_additions)
     : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs,
                       immutable_options, mutable_cf_options, file_options,
-                      db_id, db_session_id, job_id, column_family_id,
-                      column_family_name, io_priority, write_hint, io_tracer,
-                      blob_callback, creation_reason, blob_file_paths,
-                      blob_file_additions) {}
+                      job_id, column_family_id, column_family_name, io_priority,
+                      write_hint, io_tracer, blob_callback, creation_reason,
+                      blob_file_paths, blob_file_additions) {}
 
 BlobFileBuilder::BlobFileBuilder(
     std::function<uint64_t()> file_number_generator, FileSystem* fs,
     const ImmutableOptions* immutable_options,
     const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
-    std::string db_id, std::string db_session_id, int job_id,
-    uint32_t column_family_id, const std::string& column_family_name,
-    Env::IOPriority io_priority, Env::WriteLifeTimeHint write_hint,
+    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,
@@ -66,10 +64,7 @@ BlobFileBuilder::BlobFileBuilder(
       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),
-      prepopulate_blob_cache_(mutable_cf_options->prepopulate_blob_cache),
       file_options_(file_options),
-      db_id_(std::move(db_id)),
-      db_session_id_(std::move(db_session_id)),
       job_id_(job_id),
       column_family_id_(column_family_id),
       column_family_name_(column_family_name),
@@ -138,16 +133,6 @@ Status BlobFileBuilder::Add(const Slice& key, const Slice& value,
     }
   }
 
-  {
-    const Status s =
-        PutBlobIntoCacheIfNeeded(value, blob_file_number, blob_offset);
-    if (!s.ok()) {
-      ROCKS_LOG_WARN(immutable_options_->info_log,
-                     "Failed to pre-populate the blob into blob cache: %s",
-                     s.ToString().c_str());
-    }
-  }
-
   BlobIndex::EncodeBlob(blob_index, blob_file_number, blob_offset, blob.size(),
                         blob_compression_type_);
 
@@ -387,60 +372,4 @@ void BlobFileBuilder::Abandon(const Status& s) {
   blob_count_ = 0;
   blob_bytes_ = 0;
 }
-
-Status BlobFileBuilder::PutBlobIntoCacheIfNeeded(const Slice& blob,
-                                                 uint64_t blob_file_number,
-                                                 uint64_t blob_offset) const {
-  Status s = Status::OK();
-
-  auto blob_cache = immutable_options_->blob_cache;
-  auto statistics = immutable_options_->statistics.get();
-  bool warm_cache =
-      prepopulate_blob_cache_ == PrepopulateBlobCache::kFlushOnly &&
-      creation_reason_ == BlobFileCreationReason::kFlush;
-
-  if (blob_cache && warm_cache) {
-    const OffsetableCacheKey base_cache_key(db_id_, db_session_id_,
-                                            blob_file_number);
-    const CacheKey cache_key = base_cache_key.WithOffset(blob_offset);
-    const Slice key = cache_key.AsSlice();
-
-    const Cache::Priority priority = Cache::Priority::BOTTOM;
-
-    // Objects to be put into the cache have to be heap-allocated and
-    // self-contained, i.e. own their contents. The Cache has to be able to
-    // take unique ownership of them.
-    CacheAllocationPtr allocation =
-        AllocateBlock(blob.size(), blob_cache->memory_allocator());
-    memcpy(allocation.get(), blob.data(), blob.size());
-    std::unique_ptr<BlobContents> buf =
-        BlobContents::Create(std::move(allocation), blob.size());
-
-    Cache::CacheItemHelper* const cache_item_helper =
-        BlobContents::GetCacheItemHelper();
-    assert(cache_item_helper);
-
-    if (immutable_options_->lowest_used_cache_tier ==
-        CacheTier::kNonVolatileBlockTier) {
-      s = blob_cache->Insert(key, buf.get(), cache_item_helper,
-                             buf->ApproximateMemoryUsage(),
-                             nullptr /* cache_handle */, priority);
-    } else {
-      s = blob_cache->Insert(key, buf.get(), buf->ApproximateMemoryUsage(),
-                             cache_item_helper->del_cb,
-                             nullptr /* cache_handle */, priority);
-    }
-
-    if (s.ok()) {
-      RecordTick(statistics, BLOB_DB_CACHE_ADD);
-      RecordTick(statistics, BLOB_DB_CACHE_BYTES_WRITE, buf->size());
-      buf.release();
-    } else {
-      RecordTick(statistics, BLOB_DB_CACHE_ADD_FAILURES);
-    }
-  }
-
-  return s;
-}
-
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_builder.h

@@ -10,7 +10,6 @@
 #include <string>
 #include <vector>
 
-#include "rocksdb/advanced_options.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/env.h"
 #include "rocksdb/rocksdb_namespace.h"
@@ -36,8 +35,7 @@ class BlobFileBuilder {
   BlobFileBuilder(VersionSet* versions, FileSystem* fs,
                   const ImmutableOptions* immutable_options,
                   const MutableCFOptions* mutable_cf_options,
-                  const FileOptions* file_options, std::string db_id,
-                  std::string db_session_id, int job_id,
+                  const FileOptions* file_options, int job_id,
                   uint32_t column_family_id,
                   const std::string& column_family_name,
                   Env::IOPriority io_priority,
@@ -51,8 +49,7 @@ class BlobFileBuilder {
   BlobFileBuilder(std::function<uint64_t()> file_number_generator,
                   FileSystem* fs, const ImmutableOptions* immutable_options,
                   const MutableCFOptions* mutable_cf_options,
-                  const FileOptions* file_options, std::string db_id,
-                  std::string db_session_id, int job_id,
+                  const FileOptions* file_options, int job_id,
                   uint32_t column_family_id,
                   const std::string& column_family_name,
                   Env::IOPriority io_priority,
@@ -81,19 +78,13 @@ class BlobFileBuilder {
   Status CloseBlobFile();
   Status CloseBlobFileIfNeeded();
 
-  Status PutBlobIntoCacheIfNeeded(const Slice& blob, uint64_t blob_file_number,
-                                  uint64_t blob_offset) const;
-
   std::function<uint64_t()> file_number_generator_;
   FileSystem* fs_;
   const ImmutableOptions* immutable_options_;
   uint64_t min_blob_size_;
   uint64_t blob_file_size_;
   CompressionType blob_compression_type_;
-  PrepopulateBlobCache prepopulate_blob_cache_;
   const FileOptions* file_options_;
-  const std::string db_id_;
-  const std::string db_session_id_;
   int job_id_;
   uint32_t column_family_id_;
   std::string column_family_name_;

db/blob/blob_file_builder_test.cc

@@ -144,9 +144,8 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
@@ -229,9 +228,8 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
@@ -317,9 +315,8 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   for (size_t i = 0; i < number_of_blobs; ++i) {
@@ -372,9 +369,8 @@ TEST_F(BlobFileBuilderTest, Compression) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   const std::string key("1");
@@ -456,9 +452,8 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue",
@@ -536,9 +531,8 @@ TEST_F(BlobFileBuilderTest, Checksum) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   const std::string key("1");
@@ -634,9 +628,8 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &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);
 
   SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) {

db/blob/blob_file_reader.cc

@@ -8,7 +8,6 @@
 #include <cassert>
 #include <string>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
 #include "file/file_prefetch_buffer.h"
 #include "file/filename.h"
@@ -284,12 +283,14 @@ BlobFileReader::BlobFileReader(
 
 BlobFileReader::~BlobFileReader() = default;
 
-Status BlobFileReader::GetBlob(
-    const ReadOptions& read_options, const Slice& user_key, uint64_t offset,
-    uint64_t value_size, CompressionType compression_type,
-    FilePrefetchBuffer* prefetch_buffer, MemoryAllocator* allocator,
-    std::unique_ptr<BlobContents>* result, uint64_t* bytes_read) const {
-  assert(result);
+Status BlobFileReader::GetBlob(const ReadOptions& read_options,
+                               const Slice& user_key, uint64_t offset,
+                               uint64_t value_size,
+                               CompressionType compression_type,
+                               FilePrefetchBuffer* prefetch_buffer,
+                               PinnableSlice* value,
+                               uint64_t* bytes_read) const {
+  assert(value);
 
   const uint64_t key_size = user_key.size();
 
@@ -360,8 +361,8 @@ Status BlobFileReader::GetBlob(
   const Slice value_slice(record_slice.data() + adjustment, value_size);
 
   {
-    const Status s = UncompressBlobIfNeeded(
-        value_slice, compression_type, allocator, clock_, statistics_, result);
+    const Status s = UncompressBlobIfNeeded(value_slice, compression_type,
+                                            clock_, statistics_, value);
     if (!s.ok()) {
       return s;
     }
@@ -374,18 +375,16 @@ Status BlobFileReader::GetBlob(
   return Status::OK();
 }
 
-void BlobFileReader::MultiGetBlob(
-    const ReadOptions& read_options, MemoryAllocator* allocator,
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>&
-        blob_reqs,
-    uint64_t* bytes_read) const {
+void BlobFileReader::MultiGetBlob(const ReadOptions& read_options,
+                                  autovector<BlobReadRequest*>& blob_reqs,
+                                  uint64_t* bytes_read) const {
   const size_t num_blobs = blob_reqs.size();
   assert(num_blobs > 0);
   assert(num_blobs <= MultiGetContext::MAX_BATCH_SIZE);
 
 #ifndef NDEBUG
   for (size_t i = 0; i < num_blobs - 1; ++i) {
-    assert(blob_reqs[i].first->offset <= blob_reqs[i + 1].first->offset);
+    assert(blob_reqs[i]->offset <= blob_reqs[i + 1]->offset);
   }
 #endif  // !NDEBUG
 
@@ -394,21 +393,16 @@ void BlobFileReader::MultiGetBlob(
   uint64_t total_len = 0;
   read_reqs.reserve(num_blobs);
   for (size_t i = 0; i < num_blobs; ++i) {
-    BlobReadRequest* const req = blob_reqs[i].first;
-    assert(req);
-    assert(req->user_key);
-    assert(req->status);
-
-    const size_t key_size = req->user_key->size();
-    const uint64_t offset = req->offset;
-    const uint64_t value_size = req->len;
+    const size_t key_size = blob_reqs[i]->user_key->size();
+    const uint64_t offset = blob_reqs[i]->offset;
+    const uint64_t value_size = blob_reqs[i]->len;
 
     if (!IsValidBlobOffset(offset, key_size, value_size, file_size_)) {
-      *req->status = Status::Corruption("Invalid blob offset");
+      *blob_reqs[i]->status = Status::Corruption("Invalid blob offset");
       continue;
     }
-    if (req->compression != compression_type_) {
-      *req->status =
+    if (blob_reqs[i]->compression != compression_type_) {
+      *blob_reqs[i]->status =
           Status::Corruption("Compression type mismatch when reading a blob");
       continue;
     }
@@ -417,12 +411,12 @@ void BlobFileReader::MultiGetBlob(
         read_options.verify_checksums
             ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
             : 0;
-    assert(req->offset >= adjustment);
+    assert(blob_reqs[i]->offset >= adjustment);
     adjustments.push_back(adjustment);
 
-    FSReadRequest read_req = {};
-    read_req.offset = req->offset - adjustment;
-    read_req.len = req->len + adjustment;
+    FSReadRequest read_req;
+    read_req.offset = blob_reqs[i]->offset - adjustment;
+    read_req.len = blob_reqs[i]->len + adjustment;
     read_reqs.emplace_back(read_req);
     total_len += read_req.len;
   }
@@ -456,11 +450,8 @@ void BlobFileReader::MultiGetBlob(
     for (auto& req : read_reqs) {
       req.status.PermitUncheckedError();
     }
-    for (auto& blob_req : blob_reqs) {
-      BlobReadRequest* const req = blob_req.first;
-      assert(req);
+    for (auto& req : blob_reqs) {
       assert(req->status);
-
       if (!req->status->IsCorruption()) {
         // Avoid overwriting corruption status.
         *req->status = s;
@@ -473,42 +464,38 @@ void BlobFileReader::MultiGetBlob(
 
   uint64_t total_bytes = 0;
   for (size_t i = 0, j = 0; i < num_blobs; ++i) {
-    BlobReadRequest* const req = blob_reqs[i].first;
-    assert(req);
-    assert(req->user_key);
-    assert(req->status);
-
-    if (!req->status->ok()) {
+    assert(blob_reqs[i]->status);
+    if (!blob_reqs[i]->status->ok()) {
       continue;
     }
 
     assert(j < read_reqs.size());
-    auto& read_req = read_reqs[j++];
-    const auto& record_slice = read_req.result;
-    if (read_req.status.ok() && record_slice.size() != read_req.len) {
-      read_req.status =
-          IOStatus::Corruption("Failed to read data from blob file");
+    auto& req = read_reqs[j++];
+    const auto& record_slice = req.result;
+    if (req.status.ok() && record_slice.size() != req.len) {
+      req.status = IOStatus::Corruption("Failed to read data from blob file");
     }
 
-    *req->status = read_req.status;
-    if (!req->status->ok()) {
+    *blob_reqs[i]->status = req.status;
+    if (!blob_reqs[i]->status->ok()) {
       continue;
     }
 
     // Verify checksums if enabled
     if (read_options.verify_checksums) {
-      *req->status = VerifyBlob(record_slice, *req->user_key, req->len);
-      if (!req->status->ok()) {
+      *blob_reqs[i]->status =
+          VerifyBlob(record_slice, *blob_reqs[i]->user_key, blob_reqs[i]->len);
+      if (!blob_reqs[i]->status->ok()) {
         continue;
       }
     }
 
     // Uncompress blob if needed
-    Slice value_slice(record_slice.data() + adjustments[i], req->len);
-    *req->status =
-        UncompressBlobIfNeeded(value_slice, compression_type_, allocator,
-                               clock_, statistics_, &blob_reqs[i].second);
-    if (req->status->ok()) {
+    Slice value_slice(record_slice.data() + adjustments[i], blob_reqs[i]->len);
+    *blob_reqs[i]->status =
+        UncompressBlobIfNeeded(value_slice, compression_type_, clock_,
+                               statistics_, blob_reqs[i]->result);
+    if (blob_reqs[i]->status->ok()) {
       total_bytes += record_slice.size();
     }
   }
@@ -562,18 +549,15 @@ Status BlobFileReader::VerifyBlob(const Slice& record_slice,
   return Status::OK();
 }
 
-Status BlobFileReader::UncompressBlobIfNeeded(
-    const Slice& value_slice, CompressionType compression_type,
-    MemoryAllocator* allocator, SystemClock* clock, Statistics* statistics,
-    std::unique_ptr<BlobContents>* result) {
-  assert(result);
+Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
+                                              CompressionType compression_type,
+                                              SystemClock* clock,
+                                              Statistics* statistics,
+                                              PinnableSlice* value) {
+  assert(value);
 
   if (compression_type == kNoCompression) {
-    CacheAllocationPtr allocation =
-        AllocateBlock(value_slice.size(), allocator);
-    memcpy(allocation.get(), value_slice.data(), value_slice.size());
-
-    *result = BlobContents::Create(std::move(allocation), value_slice.size());
+    SaveValue(value_slice, value);
 
     return Status::OK();
   }
@@ -584,6 +568,7 @@ Status BlobFileReader::UncompressBlobIfNeeded(
 
   size_t uncompressed_size = 0;
   constexpr uint32_t compression_format_version = 2;
+  constexpr MemoryAllocator* allocator = nullptr;
 
   CacheAllocationPtr output;
 
@@ -602,9 +587,19 @@ Status BlobFileReader::UncompressBlobIfNeeded(
     return Status::Corruption("Unable to uncompress blob");
   }
 
-  *result = BlobContents::Create(std::move(output), uncompressed_size);
+  SaveValue(Slice(output.get(), uncompressed_size), value);
 
   return Status::OK();
 }
 
+void BlobFileReader::SaveValue(const Slice& src, PinnableSlice* dst) {
+  assert(dst);
+
+  if (dst->IsPinned()) {
+    dst->Reset();
+  }
+
+  dst->PinSelf(src);
+}
+
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_reader.h

@@ -23,7 +23,7 @@ class HistogramImpl;
 struct ReadOptions;
 class Slice;
 class FilePrefetchBuffer;
-class BlobContents;
+class PinnableSlice;
 class Statistics;
 
 class BlobFileReader {
@@ -44,17 +44,13 @@ class BlobFileReader {
   Status GetBlob(const ReadOptions& read_options, const Slice& user_key,
                  uint64_t offset, uint64_t value_size,
                  CompressionType compression_type,
-                 FilePrefetchBuffer* prefetch_buffer,
-                 MemoryAllocator* allocator,
-                 std::unique_ptr<BlobContents>* result,
+                 FilePrefetchBuffer* prefetch_buffer, PinnableSlice* value,
                  uint64_t* bytes_read) const;
 
   // offsets must be sorted in ascending order by caller.
-  void MultiGetBlob(
-      const ReadOptions& read_options, MemoryAllocator* allocator,
-      autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>&
-          blob_reqs,
-      uint64_t* bytes_read) const;
+  void MultiGetBlob(const ReadOptions& read_options,
+                    autovector<BlobReadRequest*>& blob_reqs,
+                    uint64_t* bytes_read) const;
 
   CompressionType GetCompressionType() const { return compression_type_; }
 
@@ -93,10 +89,11 @@ class BlobFileReader {
 
   static Status UncompressBlobIfNeeded(const Slice& value_slice,
                                        CompressionType compression_type,
-                                       MemoryAllocator* allocator,
                                        SystemClock* clock,
                                        Statistics* statistics,
-                                       std::unique_ptr<BlobContents>* result);
+                                       PinnableSlice* value);
+
+  static void SaveValue(const Slice& src, PinnableSlice* dst);
 
   std::unique_ptr<RandomAccessFileReader> file_reader_;
   uint64_t file_size_;

db/blob/blob_file_reader_test.cc

@@ -8,7 +8,6 @@
 #include <cassert>
 #include <string>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
 #include "env/mock_env.h"
@@ -181,17 +180,15 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   read_options.verify_checksums = false;
 
   constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, keys[0], blob_offsets[0],
                               blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blobs[0]);
+                              &value, &bytes_read));
+    ASSERT_EQ(value, blobs[0]);
     ASSERT_EQ(bytes_read, blob_sizes[0]);
 
     // MultiGetBlob
@@ -199,25 +196,22 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
     size_t total_size = 0;
 
     std::array<Status, num_blobs> statuses_buf;
+    std::array<PinnableSlice, num_blobs> value_buf;
     std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
+    autovector<BlobReadRequest*> blob_reqs;
 
     for (size_t i = 0; i < num_blobs; ++i) {
       requests_buf[i] =
           BlobReadRequest(keys[i], blob_offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
+                          kNoCompression, &value_buf[i], &statuses_buf[i]);
+      blob_reqs.push_back(&requests_buf[i]);
     }
 
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
+    reader->MultiGetBlob(read_options, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
-      const auto& result = blob_reqs[i].second;
-
       ASSERT_OK(statuses_buf[i]);
-      ASSERT_NE(result, nullptr);
-      ASSERT_EQ(result->data(), blobs[i]);
+      ASSERT_EQ(value_buf[i], blobs[i]);
       total_size += blob_sizes[i];
     }
     ASSERT_EQ(bytes_read, total_size);
@@ -226,14 +220,13 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   read_options.verify_checksums = true;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, keys[1], blob_offsets[1],
                               blob_sizes[1], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blobs[1]);
+                              &value, &bytes_read));
+    ASSERT_EQ(value, blobs[1]);
 
     const uint64_t key_size = keys[1].size();
     ASSERT_EQ(bytes_read,
@@ -243,50 +236,47 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
 
   // Invalid offset (too close to start of file)
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[0], blob_offsets[0] - 1,
                               blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Invalid offset (too close to end of file)
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[2], blob_offsets[2] + 1,
                               blob_sizes[2], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Incorrect compression type
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[0], blob_offsets[0],
-                              blob_sizes[0], kZSTD, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              blob_sizes[0], kZSTD, prefetch_buffer, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Incorrect key size
   {
     constexpr char shorter_key[] = "k";
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
@@ -294,9 +284,8 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
                               blob_offsets[0] -
                                   (keys[0].size() - sizeof(shorter_key) + 1),
                               blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -313,18 +302,18 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
         blob_offsets[2]};
 
     std::array<Status, num_blobs> statuses_buf;
+    std::array<PinnableSlice, num_blobs> value_buf;
     std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
+    autovector<BlobReadRequest*> blob_reqs;
 
     for (size_t i = 0; i < num_blobs; ++i) {
       requests_buf[i] =
           BlobReadRequest(key_refs[i], offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
+                          kNoCompression, &value_buf[i], &statuses_buf[i]);
+      blob_reqs.push_back(&requests_buf[i]);
     }
 
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
+    reader->MultiGetBlob(read_options, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i == 1) {
@@ -338,15 +327,14 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   // Incorrect key
   {
     constexpr char incorrect_key[] = "foo1";
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, incorrect_key, blob_offsets[0],
                               blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -358,18 +346,19 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
     key_refs[2] = std::cref(wrong_key_slice);
 
     std::array<Status, num_blobs> statuses_buf;
+    std::array<PinnableSlice, num_blobs> value_buf;
     std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
 
     for (size_t i = 0; i < num_blobs; ++i) {
       requests_buf[i] =
           BlobReadRequest(key_refs[i], blob_offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
+                          kNoCompression, &value_buf[i], &statuses_buf[i]);
     }
 
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
+    autovector<BlobReadRequest*> blob_reqs = {
+        &requests_buf[0], &requests_buf[1], &requests_buf[2]};
+
+    reader->MultiGetBlob(read_options, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i == num_blobs - 1) {
@@ -382,15 +371,14 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
 
   // Incorrect value size
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[1], blob_offsets[1],
                               blob_sizes[1] + 1, kNoCompression,
-                              prefetch_buffer, allocator, &value, &bytes_read)
+                              prefetch_buffer, &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -400,26 +388,23 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
     }
 
     std::array<Status, num_blobs> statuses_buf;
+    std::array<PinnableSlice, num_blobs> value_buf;
     std::array<BlobReadRequest, num_blobs> requests_buf;
 
     requests_buf[0] =
         BlobReadRequest(key_refs[0], blob_offsets[0], blob_sizes[0],
-                        kNoCompression, nullptr, &statuses_buf[0]);
+                        kNoCompression, &value_buf[0], &statuses_buf[0]);
     requests_buf[1] =
         BlobReadRequest(key_refs[1], blob_offsets[1], blob_sizes[1] + 1,
-                        kNoCompression, nullptr, &statuses_buf[1]);
+                        kNoCompression, &value_buf[1], &statuses_buf[1]);
     requests_buf[2] =
         BlobReadRequest(key_refs[2], blob_offsets[2], blob_sizes[2],
-                        kNoCompression, nullptr, &statuses_buf[2]);
+                        kNoCompression, &value_buf[2], &statuses_buf[2]);
 
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
+    autovector<BlobReadRequest*> blob_reqs = {
+        &requests_buf[0], &requests_buf[1], &requests_buf[2]};
 
-    for (size_t i = 0; i < num_blobs; ++i) {
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
-    }
-
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
+    reader->MultiGetBlob(read_options, blob_reqs, &bytes_read);
 
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i != 1) {
@@ -680,17 +665,14 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
   SyncPoint::GetInstance()->EnableProcessing();
 
   constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
-  std::unique_ptr<BlobContents> value;
+  PinnableSlice value;
   uint64_t bytes_read = 0;
 
   ASSERT_TRUE(reader
                   ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kNoCompression, prefetch_buffer, allocator, &value,
+                            kNoCompression, prefetch_buffer, &value,
                             &bytes_read)
                   .IsCorruption());
-  ASSERT_EQ(value, nullptr);
   ASSERT_EQ(bytes_read, 0);
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -738,31 +720,28 @@ TEST_F(BlobFileReaderTest, Compression) {
   read_options.verify_checksums = false;
 
   constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blob);
+                              kSnappyCompression, prefetch_buffer, &value,
+                              &bytes_read));
+    ASSERT_EQ(value, blob);
     ASSERT_EQ(bytes_read, blob_size);
   }
 
   read_options.verify_checksums = true;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blob);
+                              kSnappyCompression, prefetch_buffer, &value,
+                              &bytes_read));
+    ASSERT_EQ(value, blob);
 
     constexpr uint64_t key_size = sizeof(key) - 1;
     ASSERT_EQ(bytes_read,
@@ -820,17 +799,14 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
   SyncPoint::GetInstance()->EnableProcessing();
 
   constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
-  std::unique_ptr<BlobContents> value;
+  PinnableSlice value;
   uint64_t bytes_read = 0;
 
   ASSERT_TRUE(reader
                   ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kSnappyCompression, prefetch_buffer, allocator,
-                            &value, &bytes_read)
+                            kSnappyCompression, prefetch_buffer, &value,
+                            &bytes_read)
                   .IsCorruption());
-  ASSERT_EQ(value, nullptr);
   ASSERT_EQ(bytes_read, 0);
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -909,17 +885,14 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
     ASSERT_OK(s);
 
     constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-    constexpr MemoryAllocator* allocator = nullptr;
-
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              kNoCompression, prefetch_buffer, &value,
+                              &bytes_read)
                     .IsIOError());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
@@ -997,17 +970,14 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
     ASSERT_OK(s);
 
     constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-    constexpr MemoryAllocator* allocator = nullptr;
-
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              kNoCompression, prefetch_buffer, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 

db/blob/blob_index.h

@@ -92,7 +92,7 @@ class BlobIndex {
   }
 
   Status DecodeFrom(Slice slice) {
-    const char* kErrorMessage = "Error while decoding blob index";
+    static const std::string kErrorMessage = "Error while decoding blob index";
     assert(slice.size() > 0);
     type_ = static_cast<Type>(*slice.data());
     if (type_ >= Type::kUnknown) {

db/blob/blob_log_format.cc

@@ -26,7 +26,8 @@ void BlobLogHeader::EncodeTo(std::string* dst) {
 }
 
 Status BlobLogHeader::DecodeFrom(Slice src) {
-  const char* kErrorMessage = "Error while decoding blob log header";
+  static const std::string kErrorMessage =
+      "Error while decoding blob log header";
   if (src.size() != BlobLogHeader::kSize) {
     return Status::Corruption(kErrorMessage,
                               "Unexpected blob file header size");
@@ -70,7 +71,8 @@ void BlobLogFooter::EncodeTo(std::string* dst) {
 }
 
 Status BlobLogFooter::DecodeFrom(Slice src) {
-  const char* kErrorMessage = "Error while decoding blob log footer";
+  static const std::string kErrorMessage =
+      "Error while decoding blob log footer";
   if (src.size() != BlobLogFooter::kSize) {
     return Status::Corruption(kErrorMessage,
                               "Unexpected blob file footer size");
@@ -110,7 +112,7 @@ void BlobLogRecord::EncodeHeaderTo(std::string* dst) {
 }
 
 Status BlobLogRecord::DecodeHeaderFrom(Slice src) {
-  const char* kErrorMessage = "Error while decoding blob record";
+  static const std::string kErrorMessage = "Error while decoding blob record";
   if (src.size() != BlobLogRecord::kHeaderSize) {
     return Status::Corruption(kErrorMessage,
                               "Unexpected blob record header size");

db/blob/blob_log_writer.cc

@@ -70,38 +70,32 @@ Status BlobLogWriter::AppendFooter(BlobLogFooter& footer,
   std::string str;
   footer.EncodeTo(&str);
 
-  Status s;
-  if (dest_->seen_error()) {
-    s.PermitUncheckedError();
-    return Status::IOError("Seen Error. Skip closing.");
-  } else {
-    s = dest_->Append(Slice(str));
-    if (s.ok()) {
-      block_offset_ += str.size();
+  Status s = dest_->Append(Slice(str));
+  if (s.ok()) {
+    block_offset_ += str.size();
 
-      s = Sync();
+    s = Sync();
+
+    if (s.ok()) {
+      s = dest_->Close();
 
       if (s.ok()) {
-        s = dest_->Close();
+        assert(!!checksum_method == !!checksum_value);
 
-        if (s.ok()) {
-          assert(!!checksum_method == !!checksum_value);
+        if (checksum_method) {
+          assert(checksum_method->empty());
 
-          if (checksum_method) {
-            assert(checksum_method->empty());
-
-            std::string method = dest_->GetFileChecksumFuncName();
-            if (method != kUnknownFileChecksumFuncName) {
-              *checksum_method = std::move(method);
-            }
+          std::string method = dest_->GetFileChecksumFuncName();
+          if (method != kUnknownFileChecksumFuncName) {
+            *checksum_method = std::move(method);
           }
-          if (checksum_value) {
-            assert(checksum_value->empty());
+        }
+        if (checksum_value) {
+          assert(checksum_value->empty());
 
-            std::string value = dest_->GetFileChecksum();
-            if (value != kUnknownFileChecksum) {
-              *checksum_value = std::move(value);
-            }
+          std::string value = dest_->GetFileChecksum();
+          if (value != kUnknownFileChecksum) {
+            *checksum_value = std::move(value);
           }
         }
       }

db/blob/blob_source.cc

@@ -8,9 +8,6 @@
 #include <cassert>
 #include <string>
 
-#include "cache/cache_reservation_manager.h"
-#include "cache/charged_cache.h"
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_reader.h"
 #include "db/blob/blob_log_format.h"
 #include "monitoring/statistics.h"
@@ -28,79 +25,55 @@ BlobSource::BlobSource(const ImmutableOptions* immutable_options,
       db_session_id_(db_session_id),
       statistics_(immutable_options->statistics.get()),
       blob_file_cache_(blob_file_cache),
-      blob_cache_(immutable_options->blob_cache),
-      lowest_used_cache_tier_(immutable_options->lowest_used_cache_tier) {
-#ifndef ROCKSDB_LITE
-  auto bbto =
-      immutable_options->table_factory->GetOptions<BlockBasedTableOptions>();
-  if (bbto &&
-      bbto->cache_usage_options.options_overrides.at(CacheEntryRole::kBlobCache)
-              .charged == CacheEntryRoleOptions::Decision::kEnabled) {
-    blob_cache_ = std::make_shared<ChargedCache>(immutable_options->blob_cache,
-                                                 bbto->block_cache);
-  }
-#endif  // ROCKSDB_LITE
-}
+      blob_cache_(immutable_options->blob_cache) {}
 
 BlobSource::~BlobSource() = default;
 
-Status BlobSource::GetBlobFromCache(
-    const Slice& cache_key, CacheHandleGuard<BlobContents>* cached_blob) const {
+Status BlobSource::GetBlobFromCache(const Slice& cache_key,
+                                    CacheHandleGuard<std::string>* blob) const {
+  assert(blob);
+  assert(blob->IsEmpty());
   assert(blob_cache_);
   assert(!cache_key.empty());
-  assert(cached_blob);
-  assert(cached_blob->IsEmpty());
 
   Cache::Handle* cache_handle = nullptr;
   cache_handle = GetEntryFromCache(cache_key);
   if (cache_handle != nullptr) {
-    *cached_blob =
-        CacheHandleGuard<BlobContents>(blob_cache_.get(), cache_handle);
-
-    assert(cached_blob->GetValue());
-
-    PERF_COUNTER_ADD(blob_cache_hit_count, 1);
-    RecordTick(statistics_, BLOB_DB_CACHE_HIT);
-    RecordTick(statistics_, BLOB_DB_CACHE_BYTES_READ,
-               cached_blob->GetValue()->size());
-
+    *blob = CacheHandleGuard<std::string>(blob_cache_.get(), cache_handle);
     return Status::OK();
   }
 
-  RecordTick(statistics_, BLOB_DB_CACHE_MISS);
+  assert(blob->IsEmpty());
 
   return Status::NotFound("Blob not found in cache");
 }
 
-Status BlobSource::PutBlobIntoCache(
-    const Slice& cache_key, std::unique_ptr<BlobContents>* blob,
-    CacheHandleGuard<BlobContents>* cached_blob) const {
-  assert(blob_cache_);
-  assert(!cache_key.empty());
+Status BlobSource::PutBlobIntoCache(const Slice& cache_key,
+                                    CacheHandleGuard<std::string>* cached_blob,
+                                    PinnableSlice* blob) const {
   assert(blob);
-  assert(*blob);
-  assert(cached_blob);
-  assert(cached_blob->IsEmpty());
+  assert(!cache_key.empty());
+  assert(blob_cache_);
 
+  Status s;
+  const Cache::Priority priority = Cache::Priority::LOW;
+
+  // Objects to be put into the cache have to be heap-allocated and
+  // self-contained, i.e. own their contents. The Cache has to be able to take
+  // unique ownership of them. Therefore, we copy the blob into a string
+  // directly, and insert that into the cache.
+  std::string* buf = new std::string();
+  buf->assign(blob->data(), blob->size());
+
+  // TODO: support custom allocators and provide a better estimated memory
+  // usage using malloc_usable_size.
   Cache::Handle* cache_handle = nullptr;
-  const Status s = InsertEntryIntoCache(cache_key, blob->get(),
-                                        (*blob)->ApproximateMemoryUsage(),
-                                        &cache_handle, Cache::Priority::BOTTOM);
+  s = InsertEntryIntoCache(cache_key, buf, buf->size(), &cache_handle,
+                           priority);
   if (s.ok()) {
-    blob->release();
-
     assert(cache_handle != nullptr);
     *cached_blob =
-        CacheHandleGuard<BlobContents>(blob_cache_.get(), cache_handle);
-
-    assert(cached_blob->GetValue());
-
-    RecordTick(statistics_, BLOB_DB_CACHE_ADD);
-    RecordTick(statistics_, BLOB_DB_CACHE_BYTES_WRITE,
-               cached_blob->GetValue()->size());
-
-  } else {
-    RecordTick(statistics_, BLOB_DB_CACHE_ADD_FAILURES);
+        CacheHandleGuard<std::string>(blob_cache_.get(), cache_handle);
   }
 
   return s;
@@ -108,81 +81,33 @@ Status BlobSource::PutBlobIntoCache(
 
 Cache::Handle* BlobSource::GetEntryFromCache(const Slice& key) const {
   Cache::Handle* cache_handle = nullptr;
-
-  if (lowest_used_cache_tier_ == CacheTier::kNonVolatileBlockTier) {
-    Cache::CreateCallback create_cb =
-        [allocator = blob_cache_->memory_allocator()](
-            const void* buf, size_t size, void** out_obj,
-            size_t* charge) -> Status {
-      return BlobContents::CreateCallback(AllocateBlock(size, allocator), buf,
-                                          size, out_obj, charge);
-    };
-
-    cache_handle = blob_cache_->Lookup(key, BlobContents::GetCacheItemHelper(),
-                                       create_cb, Cache::Priority::BOTTOM,
-                                       true /* wait_for_cache */, statistics_);
+  cache_handle = blob_cache_->Lookup(key, statistics_);
+  if (cache_handle != nullptr) {
+    PERF_COUNTER_ADD(blob_cache_hit_count, 1);
+    RecordTick(statistics_, BLOB_DB_CACHE_HIT);
+    RecordTick(statistics_, BLOB_DB_CACHE_BYTES_READ,
+               blob_cache_->GetUsage(cache_handle));
   } else {
-    cache_handle = blob_cache_->Lookup(key, statistics_);
+    RecordTick(statistics_, BLOB_DB_CACHE_MISS);
   }
-
   return cache_handle;
 }
 
-void BlobSource::PinCachedBlob(CacheHandleGuard<BlobContents>* cached_blob,
-                               PinnableSlice* value) {
-  assert(cached_blob);
-  assert(cached_blob->GetValue());
-  assert(value);
-
-  // To avoid copying the cached blob into the buffer provided by the
-  // application, we can simply transfer ownership of the cache handle to
-  // the target PinnableSlice. This has the potential to save a lot of
-  // CPU, especially with large blob values.
-
-  value->Reset();
-
-  constexpr Cleanable* cleanable = nullptr;
-  value->PinSlice(cached_blob->GetValue()->data(), cleanable);
-
-  cached_blob->TransferTo(value);
-}
-
-void BlobSource::PinOwnedBlob(std::unique_ptr<BlobContents>* owned_blob,
-                              PinnableSlice* value) {
-  assert(owned_blob);
-  assert(*owned_blob);
-  assert(value);
-
-  BlobContents* const blob = owned_blob->release();
-  assert(blob);
-
-  value->Reset();
-  value->PinSlice(
-      blob->data(),
-      [](void* arg1, void* /* arg2 */) {
-        delete static_cast<BlobContents*>(arg1);
-      },
-      blob, nullptr);
-}
-
-Status BlobSource::InsertEntryIntoCache(const Slice& key, BlobContents* value,
+Status BlobSource::InsertEntryIntoCache(const Slice& key, std::string* value,
                                         size_t charge,
                                         Cache::Handle** cache_handle,
                                         Cache::Priority priority) const {
-  Status s;
-
-  Cache::CacheItemHelper* const cache_item_helper =
-      BlobContents::GetCacheItemHelper();
-  assert(cache_item_helper);
-
-  if (lowest_used_cache_tier_ == CacheTier::kNonVolatileBlockTier) {
-    s = blob_cache_->Insert(key, value, cache_item_helper, charge, cache_handle,
-                            priority);
+  const Status s =
+      blob_cache_->Insert(key, value, charge, &DeleteCacheEntry<std::string>,
+                          cache_handle, priority);
+  if (s.ok()) {
+    assert(*cache_handle != nullptr);
+    RecordTick(statistics_, BLOB_DB_CACHE_ADD);
+    RecordTick(statistics_, BLOB_DB_CACHE_BYTES_WRITE,
+               blob_cache_->GetUsage(*cache_handle));
   } else {
-    s = blob_cache_->Insert(key, value, charge, cache_item_helper->del_cb,
-                            cache_handle, priority);
+    RecordTick(statistics_, BLOB_DB_CACHE_ADD_FAILURES);
   }
-
   return s;
 }
 
@@ -199,7 +124,7 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
 
   const CacheKey cache_key = GetCacheKey(file_number, file_size, offset);
 
-  CacheHandleGuard<BlobContents> blob_handle;
+  CacheHandleGuard<std::string> blob_handle;
 
   // First, try to get the blob from the cache
   //
@@ -207,8 +132,24 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
   if (blob_cache_) {
     Slice key = cache_key.AsSlice();
     s = GetBlobFromCache(key, &blob_handle);
-    if (s.ok()) {
-      PinCachedBlob(&blob_handle, value);
+    if (s.ok() && blob_handle.GetValue()) {
+      {
+        value->Reset();
+        // To avoid copying the cached blob into the buffer provided by the
+        // application, we can simply transfer ownership of the cache handle to
+        // the target PinnableSlice. This has the potential to save a lot of
+        // CPU, especially with large blob values.
+        value->PinSlice(
+            *blob_handle.GetValue(),
+            [](void* arg1, void* arg2) {
+              Cache* const cache = static_cast<Cache*>(arg1);
+              Cache::Handle* const handle = static_cast<Cache::Handle*>(arg2);
+              cache->Release(handle);
+            },
+            blob_handle.GetCache(), blob_handle.GetCacheHandle());
+        // Make the CacheHandleGuard relinquish ownership of the handle.
+        blob_handle.TransferTo(nullptr);
+      }
 
       // For consistency, the size of on-disk (possibly compressed) blob record
       // is assigned to bytes_read.
@@ -237,8 +178,6 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
 
   // Can't find the blob from the cache. Since I/O is allowed, read from the
   // file.
-  std::unique_ptr<BlobContents> blob_contents;
-
   {
     CacheHandleGuard<BlobFileReader> blob_file_reader;
     s = blob_file_cache_->GetBlobFileReader(file_number, &blob_file_reader);
@@ -252,14 +191,10 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
       return Status::Corruption("Compression type mismatch when reading blob");
     }
 
-    MemoryAllocator* const allocator = (blob_cache_ && read_options.fill_cache)
-                                           ? blob_cache_->memory_allocator()
-                                           : nullptr;
-
     uint64_t read_size = 0;
     s = blob_file_reader.GetValue()->GetBlob(
         read_options, user_key, offset, value_size, compression_type,
-        prefetch_buffer, allocator, &blob_contents, &read_size);
+        prefetch_buffer, value, &read_size);
     if (!s.ok()) {
       return s;
     }
@@ -272,14 +207,10 @@ Status BlobSource::GetBlob(const ReadOptions& read_options,
     // If filling cache is allowed and a cache is configured, try to put the
     // blob to the cache.
     Slice key = cache_key.AsSlice();
-    s = PutBlobIntoCache(key, &blob_contents, &blob_handle);
+    s = PutBlobIntoCache(key, &blob_handle, value);
     if (!s.ok()) {
       return s;
     }
-
-    PinCachedBlob(&blob_handle, value);
-  } else {
-    PinOwnedBlob(&blob_contents, value);
   }
 
   assert(s.ok());
@@ -315,7 +246,7 @@ void BlobSource::MultiGetBlob(const ReadOptions& read_options,
 
 void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
                                          uint64_t file_number,
-                                         uint64_t /*file_size*/,
+                                         uint64_t file_size,
                                          autovector<BlobReadRequest>& blob_reqs,
                                          uint64_t* bytes_read) {
   const size_t num_blobs = blob_reqs.size();
@@ -332,24 +263,41 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
   Mask cache_hit_mask = 0;
 
   uint64_t total_bytes = 0;
-  const OffsetableCacheKey base_cache_key(db_id_, db_session_id_, file_number);
+  const OffsetableCacheKey base_cache_key(db_id_, db_session_id_, file_number,
+                                          file_size);
 
   if (blob_cache_) {
     size_t cached_blob_count = 0;
     for (size_t i = 0; i < num_blobs; ++i) {
       auto& req = blob_reqs[i];
 
-      CacheHandleGuard<BlobContents> blob_handle;
+      CacheHandleGuard<std::string> blob_handle;
       const CacheKey cache_key = base_cache_key.WithOffset(req.offset);
       const Slice key = cache_key.AsSlice();
 
       const Status s = GetBlobFromCache(key, &blob_handle);
 
-      if (s.ok()) {
+      if (s.ok() && blob_handle.GetValue()) {
         assert(req.status);
         *req.status = s;
 
-        PinCachedBlob(&blob_handle, req.result);
+        {
+          req.result->Reset();
+          // To avoid copying the cached blob into the buffer provided by the
+          // application, we can simply transfer ownership of the cache handle
+          // to the target PinnableSlice. This has the potential to save a lot
+          // of CPU, especially with large blob values.
+          req.result->PinSlice(
+              *blob_handle.GetValue(),
+              [](void* arg1, void* arg2) {
+                Cache* const cache = static_cast<Cache*>(arg1);
+                Cache::Handle* const handle = static_cast<Cache::Handle*>(arg2);
+                cache->Release(handle);
+              },
+              blob_handle.GetCache(), blob_handle.GetCacheHandle());
+          // Make the CacheHandleGuard relinquish ownership of the handle.
+          blob_handle.TransferTo(nullptr);
+        }
 
         // Update the counter for the number of valid blobs read from the cache.
         ++cached_blob_count;
@@ -380,10 +328,8 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
   if (no_io) {
     for (size_t i = 0; i < num_blobs; ++i) {
       if (!(cache_hit_mask & (Mask{1} << i))) {
-        BlobReadRequest& req = blob_reqs[i];
-        assert(req.status);
-
-        *req.status =
+        assert(blob_reqs[i].status);
+        *blob_reqs[i].status =
             Status::Incomplete("Cannot read blob(s): no disk I/O allowed");
       }
     }
@@ -392,13 +338,12 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
 
   {
     // Find the rest of blobs from the file since I/O is allowed.
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        _blob_reqs;
+    autovector<BlobReadRequest*> _blob_reqs;
     uint64_t _bytes_read = 0;
 
     for (size_t i = 0; i < num_blobs; ++i) {
       if (!(cache_hit_mask & (Mask{1} << i))) {
-        _blob_reqs.emplace_back(&blob_reqs[i], std::unique_ptr<BlobContents>());
+        _blob_reqs.push_back(&blob_reqs[i]);
       }
     }
 
@@ -407,50 +352,32 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
         blob_file_cache_->GetBlobFileReader(file_number, &blob_file_reader);
     if (!s.ok()) {
       for (size_t i = 0; i < _blob_reqs.size(); ++i) {
-        BlobReadRequest* const req = _blob_reqs[i].first;
-        assert(req);
-        assert(req->status);
-
-        *req->status = s;
+        assert(_blob_reqs[i]->status);
+        *_blob_reqs[i]->status = s;
       }
       return;
     }
 
     assert(blob_file_reader.GetValue());
 
-    MemoryAllocator* const allocator = (blob_cache_ && read_options.fill_cache)
-                                           ? blob_cache_->memory_allocator()
-                                           : nullptr;
-
-    blob_file_reader.GetValue()->MultiGetBlob(read_options, allocator,
-                                              _blob_reqs, &_bytes_read);
+    blob_file_reader.GetValue()->MultiGetBlob(read_options, _blob_reqs,
+                                              &_bytes_read);
 
     if (blob_cache_ && read_options.fill_cache) {
       // If filling cache is allowed and a cache is configured, try to put
       // the blob(s) to the cache.
-      for (auto& [req, blob_contents] : _blob_reqs) {
-        assert(req);
-
-        if (req->status->ok()) {
-          CacheHandleGuard<BlobContents> blob_handle;
-          const CacheKey cache_key = base_cache_key.WithOffset(req->offset);
+      for (size_t i = 0; i < _blob_reqs.size(); ++i) {
+        if (_blob_reqs[i]->status->ok()) {
+          CacheHandleGuard<std::string> blob_handle;
+          const CacheKey cache_key =
+              base_cache_key.WithOffset(_blob_reqs[i]->offset);
           const Slice key = cache_key.AsSlice();
-          s = PutBlobIntoCache(key, &blob_contents, &blob_handle);
+          s = PutBlobIntoCache(key, &blob_handle, _blob_reqs[i]->result);
           if (!s.ok()) {
-            *req->status = s;
-          } else {
-            PinCachedBlob(&blob_handle, req->result);
+            *_blob_reqs[i]->status = s;
           }
         }
       }
-    } else {
-      for (auto& [req, blob_contents] : _blob_reqs) {
-        assert(req);
-
-        if (req->status->ok()) {
-          PinOwnedBlob(&blob_contents, req->result);
-        }
-      }
     }
 
     total_bytes += _bytes_read;
@@ -461,24 +388,14 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,
 }
 
 bool BlobSource::TEST_BlobInCache(uint64_t file_number, uint64_t file_size,
-                                  uint64_t offset, size_t* charge) const {
+                                  uint64_t offset) const {
   const CacheKey cache_key = GetCacheKey(file_number, file_size, offset);
   const Slice key = cache_key.AsSlice();
 
-  CacheHandleGuard<BlobContents> blob_handle;
+  CacheHandleGuard<std::string> blob_handle;
   const Status s = GetBlobFromCache(key, &blob_handle);
 
   if (s.ok() && blob_handle.GetValue() != nullptr) {
-    if (charge) {
-      const Cache* const cache = blob_handle.GetCache();
-      assert(cache);
-
-      Cache::Handle* const handle = blob_handle.GetCacheHandle();
-      assert(handle);
-
-      *charge = cache->GetUsage(handle);
-    }
-
     return true;
   }
 

db/blob/blob_source.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include <cinttypes>
-#include <memory>
 
 #include "cache/cache_helpers.h"
 #include "cache/cache_key.h"
@@ -23,7 +22,6 @@ struct ImmutableOptions;
 class Status;
 class FilePrefetchBuffer;
 class Slice;
-class BlobContents;
 
 // BlobSource is a class that provides universal access to blobs, regardless of
 // whether they are in the blob cache, secondary cache, or (remote) storage.
@@ -101,34 +99,27 @@ class BlobSource {
                                                blob_file_reader);
   }
 
-  inline Cache* GetBlobCache() const { return blob_cache_.get(); }
-
   bool TEST_BlobInCache(uint64_t file_number, uint64_t file_size,
-                        uint64_t offset, size_t* charge = nullptr) const;
+                        uint64_t offset) const;
 
  private:
   Status GetBlobFromCache(const Slice& cache_key,
-                          CacheHandleGuard<BlobContents>* cached_blob) const;
+                          CacheHandleGuard<std::string>* blob) const;
 
   Status PutBlobIntoCache(const Slice& cache_key,
-                          std::unique_ptr<BlobContents>* blob,
-                          CacheHandleGuard<BlobContents>* cached_blob) const;
-
-  static void PinCachedBlob(CacheHandleGuard<BlobContents>* cached_blob,
-                            PinnableSlice* value);
-
-  static void PinOwnedBlob(std::unique_ptr<BlobContents>* owned_blob,
-                           PinnableSlice* value);
+                          CacheHandleGuard<std::string>* cached_blob,
+                          PinnableSlice* blob) const;
 
   Cache::Handle* GetEntryFromCache(const Slice& key) const;
 
-  Status InsertEntryIntoCache(const Slice& key, BlobContents* value,
+  Status InsertEntryIntoCache(const Slice& key, std::string* value,
                               size_t charge, Cache::Handle** cache_handle,
                               Cache::Priority priority) const;
 
-  inline CacheKey GetCacheKey(uint64_t file_number, uint64_t /*file_size*/,
+  inline CacheKey GetCacheKey(uint64_t file_number, uint64_t file_size,
                               uint64_t offset) const {
-    OffsetableCacheKey base_cache_key(db_id_, db_session_id_, file_number);
+    OffsetableCacheKey base_cache_key(db_id_, db_session_id_, file_number,
+                                      file_size);
     return base_cache_key.WithOffset(offset);
   }
 
@@ -142,12 +133,6 @@ class BlobSource {
 
   // A cache to store uncompressed blobs.
   std::shared_ptr<Cache> blob_cache_;
-
-  // The control option of how the cache tiers will be used. Currently rocksdb
-  // support block/blob cache (volatile tier) and secondary cache (this tier
-  // isn't strictly speaking a non-volatile tier since the compressed cache in
-  // this tier is in volatile memory).
-  const CacheTier lowest_used_cache_tier_;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_source_test.cc

@@ -11,9 +11,6 @@
 #include <memory>
 #include <string>
 
-#include "cache/charged_cache.h"
-#include "cache/compressed_secondary_cache.h"
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_cache.h"
 #include "db/blob/blob_file_reader.h"
 #include "db/blob/blob_log_format.h"
@@ -24,7 +21,6 @@
 #include "options/cf_options.h"
 #include "rocksdb/options.h"
 #include "util/compression.h"
-#include "util/random.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -122,8 +118,6 @@ class BlobSourceTest : public DBTestBase {
     co.capacity = 8 << 20;
     co.num_shard_bits = 2;
     co.metadata_charge_policy = kDontChargeCacheMetadata;
-    co.high_pri_pool_ratio = 0.2;
-    co.low_pri_pool_ratio = 0.2;
     options_.blob_cache = NewLRUCache(co);
     options_.lowest_used_cache_tier = CacheTier::kVolatileTier;
 
@@ -187,10 +181,9 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
   FileOptions file_options;
   constexpr HistogramImpl* blob_file_read_hist = nullptr;
 
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);
+  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
+      backing_cache.get(), &immutable_options, &file_options, column_family_id,
+      blob_file_read_hist, nullptr /*IOTracer*/));
 
   BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
                          blob_file_cache.get());
@@ -219,7 +212,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                     kNoCompression, prefetch_buffer, &values[i],
                                     &bytes_read));
       ASSERT_EQ(values[i], blobs[i]);
-      ASSERT_TRUE(values[i].IsPinned());
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
@@ -257,7 +249,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                     kNoCompression, prefetch_buffer, &values[i],
                                     &bytes_read));
       ASSERT_EQ(values[i], blobs[i]);
-      ASSERT_TRUE(values[i].IsPinned());
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
@@ -301,7 +292,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                     kNoCompression, prefetch_buffer, &values[i],
                                     &bytes_read));
       ASSERT_EQ(values[i], blobs[i]);
-      ASSERT_TRUE(values[i].IsPinned());
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
@@ -340,7 +330,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                     kNoCompression, prefetch_buffer, &values[i],
                                     &bytes_read));
       ASSERT_EQ(values[i], blobs[i]);
-      ASSERT_TRUE(values[i].IsPinned());
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
@@ -387,7 +376,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                &bytes_read)
                       .IsIncomplete());
       ASSERT_TRUE(values[i].empty());
-      ASSERT_FALSE(values[i].IsPinned());
       ASSERT_EQ(bytes_read, 0);
 
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -429,7 +417,6 @@ TEST_F(BlobSourceTest, GetBlobsFromCache) {
                                &bytes_read)
                       .IsIOError());
       ASSERT_TRUE(values[i].empty());
-      ASSERT_FALSE(values[i].IsPinned());
       ASSERT_EQ(bytes_read, 0);
 
       ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
@@ -492,10 +479,9 @@ TEST_F(BlobSourceTest, GetCompressedBlobs) {
   auto backing_cache = NewLRUCache(capacity);  // Blob file cache
 
   FileOptions file_options;
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          column_family_id, nullptr /*HistogramImpl*/, nullptr /*IOTracer*/);
+  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
+      backing_cache.get(), &immutable_options, &file_options, column_family_id,
+      nullptr /*HistogramImpl*/, nullptr /*IOTracer*/));
 
   BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
                          blob_file_cache.get());
@@ -637,10 +623,9 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromMultiFiles) {
   FileOptions file_options;
   constexpr HistogramImpl* blob_file_read_hist = nullptr;
 
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);
+  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
+      backing_cache.get(), &immutable_options, &file_options, column_family_id,
+      blob_file_read_hist, nullptr /*IOTracer*/));
 
   BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
                          blob_file_cache.get());
@@ -820,10 +805,9 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
   FileOptions file_options;
   constexpr HistogramImpl* blob_file_read_hist = nullptr;
 
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          column_family_id, blob_file_read_hist, nullptr /*IOTracer*/);
+  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
+      backing_cache.get(), &immutable_options, &file_options, column_family_id,
+      blob_file_read_hist, nullptr /*IOTracer*/));
 
   BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
                          blob_file_cache.get());
@@ -862,7 +846,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
       if (i % 2 == 0) {
         ASSERT_OK(statuses_buf[i]);
         ASSERT_EQ(value_buf[i], blobs[i]);
-        ASSERT_TRUE(value_buf[i].IsPinned());
         fs_read_bytes +=
             blob_sizes[i] + keys[i].size() + BlobLogRecord::kHeaderSize;
         ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
@@ -871,7 +854,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
       } else {
         statuses_buf[i].PermitUncheckedError();
         ASSERT_TRUE(value_buf[i].empty());
-        ASSERT_FALSE(value_buf[i].IsPinned());
         ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                   blob_offsets[i]));
       }
@@ -904,7 +886,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
                                     kNoCompression, prefetch_buffer,
                                     &value_buf[i], &bytes_read));
       ASSERT_EQ(value_buf[i], blobs[i]);
-      ASSERT_TRUE(value_buf[i].IsPinned());
       ASSERT_EQ(bytes_read,
                 BlobLogRecord::kHeaderSize + keys[i].size() + blob_sizes[i]);
 
@@ -930,7 +911,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_OK(statuses_buf[i]);
       ASSERT_EQ(value_buf[i], blobs[i]);
-      ASSERT_TRUE(value_buf[i].IsPinned());
       ASSERT_TRUE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                blob_offsets[i]));
       blob_bytes += blob_sizes[i];
@@ -979,7 +959,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(statuses_buf[i].IsIncomplete());
       ASSERT_TRUE(value_buf[i].empty());
-      ASSERT_FALSE(value_buf[i].IsPinned());
       ASSERT_FALSE(blob_source.TEST_BlobInCache(blob_file_number, file_size,
                                                 blob_offsets[i]));
     }
@@ -1023,7 +1002,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
     for (size_t i = 0; i < num_blobs; ++i) {
       ASSERT_TRUE(statuses_buf[i].IsIOError());
       ASSERT_TRUE(value_buf[i].empty());
-      ASSERT_FALSE(value_buf[i].IsPinned());
       ASSERT_FALSE(blob_source.TEST_BlobInCache(non_existing_file_number,
                                                 file_size, blob_offsets[i]));
     }
@@ -1042,571 +1020,6 @@ TEST_F(BlobSourceTest, MultiGetBlobsFromCache) {
   }
 }
 
-class BlobSecondaryCacheTest : public DBTestBase {
- protected:
- public:
-  explicit BlobSecondaryCacheTest()
-      : DBTestBase("blob_secondary_cache_test", /*env_do_fsync=*/true) {
-    options_.env = env_;
-    options_.enable_blob_files = true;
-    options_.create_if_missing = true;
-
-    // Set a small cache capacity to evict entries from the cache, and to test
-    // that secondary cache is used properly.
-    lru_cache_opts_.capacity = 1024;
-    lru_cache_opts_.num_shard_bits = 0;
-    lru_cache_opts_.strict_capacity_limit = true;
-    lru_cache_opts_.metadata_charge_policy = kDontChargeCacheMetadata;
-    lru_cache_opts_.high_pri_pool_ratio = 0.2;
-    lru_cache_opts_.low_pri_pool_ratio = 0.2;
-
-    secondary_cache_opts_.capacity = 8 << 20;  // 8 MB
-    secondary_cache_opts_.num_shard_bits = 0;
-    secondary_cache_opts_.metadata_charge_policy =
-        kDefaultCacheMetadataChargePolicy;
-
-    // Read blobs from the secondary cache if they are not in the primary cache
-    options_.lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier;
-
-    assert(db_->GetDbIdentity(db_id_).ok());
-    assert(db_->GetDbSessionId(db_session_id_).ok());
-  }
-
-  Options options_;
-
-  LRUCacheOptions lru_cache_opts_;
-  CompressedSecondaryCacheOptions secondary_cache_opts_;
-
-  std::string db_id_;
-  std::string db_session_id_;
-};
-
-TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-
-  secondary_cache_opts_.compression_type = kSnappyCompression;
-  lru_cache_opts_.secondary_cache =
-      NewCompressedSecondaryCache(secondary_cache_opts_);
-  options_.blob_cache = NewLRUCache(lru_cache_opts_);
-
-  options_.cf_paths.emplace_back(
-      test::PerThreadDBPath(
-          env_, "BlobSecondaryCacheTest_GetBlobsFromSecondaryCache"),
-      0);
-
-  options_.statistics = CreateDBStatistics();
-  Statistics* statistics = options_.statistics.get();
-  assert(statistics);
-
-  DestroyAndReopen(options_);
-
-  ImmutableOptions immutable_options(options_);
-
-  constexpr uint32_t column_family_id = 1;
-  constexpr bool has_ttl = false;
-  constexpr ExpirationRange expiration_range;
-  constexpr uint64_t file_number = 1;
-
-  Random rnd(301);
-
-  std::vector<std::string> key_strs{"key0", "key1"};
-  std::vector<std::string> blob_strs{rnd.RandomString(512),
-                                     rnd.RandomString(768)};
-
-  std::vector<Slice> keys{key_strs[0], key_strs[1]};
-  std::vector<Slice> blobs{blob_strs[0], blob_strs[1]};
-
-  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, file_number, keys, blobs, kNoCompression,
-                blob_offsets, blob_sizes);
-
-  constexpr size_t capacity = 1024;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileCache> blob_file_cache(new BlobFileCache(
-      backing_cache.get(), &immutable_options, &file_options, column_family_id,
-      blob_file_read_hist, nullptr /*IOTracer*/));
-
-  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
-                         blob_file_cache.get());
-
-  CacheHandleGuard<BlobFileReader> file_reader;
-  ASSERT_OK(blob_source.GetBlobFileReader(file_number, &file_reader));
-  ASSERT_NE(file_reader.GetValue(), nullptr);
-  const uint64_t file_size = file_reader.GetValue()->GetFileSize();
-  ASSERT_EQ(file_reader.GetValue()->GetCompressionType(), kNoCompression);
-
-  ReadOptions read_options;
-  read_options.verify_checksums = true;
-
-  auto blob_cache = options_.blob_cache;
-  auto secondary_cache = lru_cache_opts_.secondary_cache;
-
-  Cache::CreateCallback create_cb = [](const void* buf, size_t size,
-                                       void** out_obj,
-                                       size_t* charge) -> Status {
-    CacheAllocationPtr allocation(new char[size]);
-
-    return BlobContents::CreateCallback(std::move(allocation), buf, size,
-                                        out_obj, charge);
-  };
-
-  {
-    // GetBlob
-    std::vector<PinnableSlice> values(keys.size());
-
-    read_options.fill_cache = true;
-    get_perf_context()->Reset();
-
-    // key0 should be filled to the primary cache from the blob file.
-    ASSERT_OK(blob_source.GetBlob(read_options, keys[0], file_number,
-                                  blob_offsets[0], file_size, blob_sizes[0],
-                                  kNoCompression, nullptr /* prefetch_buffer */,
-                                  &values[0], nullptr /* bytes_read */));
-    // Release cache handle
-    values[0].Reset();
-
-    // key0 should be evicted and key0's dummy item is inserted into secondary
-    // cache. key1 should be filled to the primary cache from the blob file.
-    ASSERT_OK(blob_source.GetBlob(read_options, keys[1], file_number,
-                                  blob_offsets[1], file_size, blob_sizes[1],
-                                  kNoCompression, nullptr /* prefetch_buffer */,
-                                  &values[1], nullptr /* bytes_read */));
-
-    // Release cache handle
-    values[1].Reset();
-
-    // key0 should be filled to the primary cache from the blob file. key1
-    // should be evicted and key1's dummy item is inserted into secondary cache.
-    ASSERT_OK(blob_source.GetBlob(read_options, keys[0], file_number,
-                                  blob_offsets[0], file_size, blob_sizes[0],
-                                  kNoCompression, nullptr /* prefetch_buffer */,
-                                  &values[0], nullptr /* bytes_read */));
-    ASSERT_EQ(values[0], blobs[0]);
-    ASSERT_TRUE(
-        blob_source.TEST_BlobInCache(file_number, file_size, blob_offsets[0]));
-
-    // Release cache handle
-    values[0].Reset();
-
-    // key0 should be evicted and is inserted into secondary cache.
-    // key1 should be filled to the primary cache from the blob file.
-    ASSERT_OK(blob_source.GetBlob(read_options, keys[1], file_number,
-                                  blob_offsets[1], file_size, blob_sizes[1],
-                                  kNoCompression, nullptr /* prefetch_buffer */,
-                                  &values[1], nullptr /* bytes_read */));
-    ASSERT_EQ(values[1], blobs[1]);
-    ASSERT_TRUE(
-        blob_source.TEST_BlobInCache(file_number, file_size, blob_offsets[1]));
-
-    // Release cache handle
-    values[1].Reset();
-
-    OffsetableCacheKey base_cache_key(db_id_, db_session_id_, file_number);
-
-    // blob_cache here only looks at the primary cache since we didn't provide
-    // the cache item helper for the secondary cache. However, since key0 is
-    // demoted to the secondary cache, we shouldn't be able to find it in the
-    // primary cache.
-    {
-      CacheKey cache_key = base_cache_key.WithOffset(blob_offsets[0]);
-      const Slice key0 = cache_key.AsSlice();
-      auto handle0 = blob_cache->Lookup(key0, statistics);
-      ASSERT_EQ(handle0, nullptr);
-
-      // key0's item should be in the secondary cache.
-      bool is_in_sec_cache = false;
-      auto sec_handle0 =
-          secondary_cache->Lookup(key0, create_cb, true,
-                                  /*advise_erase=*/true, is_in_sec_cache);
-      ASSERT_FALSE(is_in_sec_cache);
-      ASSERT_NE(sec_handle0, nullptr);
-      ASSERT_TRUE(sec_handle0->IsReady());
-      auto value = static_cast<BlobContents*>(sec_handle0->Value());
-      ASSERT_NE(value, nullptr);
-      ASSERT_EQ(value->data(), blobs[0]);
-      delete value;
-
-      // key0 doesn't exist in the blob cache although key0's dummy
-      // item exist in the secondary cache.
-      ASSERT_FALSE(blob_source.TEST_BlobInCache(file_number, file_size,
-                                                blob_offsets[0]));
-    }
-
-    // key1 should exists in the primary cache. key1's dummy item exists
-    // in the secondary cache.
-    {
-      CacheKey cache_key = base_cache_key.WithOffset(blob_offsets[1]);
-      const Slice key1 = cache_key.AsSlice();
-      auto handle1 = blob_cache->Lookup(key1, statistics);
-      ASSERT_NE(handle1, nullptr);
-      blob_cache->Release(handle1);
-
-      bool is_in_sec_cache = false;
-      auto sec_handle1 =
-          secondary_cache->Lookup(key1, create_cb, true,
-                                  /*advise_erase=*/true, is_in_sec_cache);
-      ASSERT_FALSE(is_in_sec_cache);
-      ASSERT_EQ(sec_handle1, nullptr);
-
-      ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
-                                               blob_offsets[1]));
-    }
-
-    {
-      // fetch key0 from the blob file to the primary cache.
-      // key1 is evicted and inserted into the secondary cache.
-      ASSERT_OK(blob_source.GetBlob(
-          read_options, keys[0], file_number, blob_offsets[0], file_size,
-          blob_sizes[0], kNoCompression, nullptr /* prefetch_buffer */,
-          &values[0], nullptr /* bytes_read */));
-      ASSERT_EQ(values[0], blobs[0]);
-
-      // Release cache handle
-      values[0].Reset();
-
-      // key0 should be in the primary cache.
-      CacheKey cache_key0 = base_cache_key.WithOffset(blob_offsets[0]);
-      const Slice key0 = cache_key0.AsSlice();
-      auto handle0 = blob_cache->Lookup(key0, statistics);
-      ASSERT_NE(handle0, nullptr);
-      auto value = static_cast<BlobContents*>(blob_cache->Value(handle0));
-      ASSERT_NE(value, nullptr);
-      ASSERT_EQ(value->data(), blobs[0]);
-      blob_cache->Release(handle0);
-
-      // key1 is not in the primary cache and is in the secondary cache.
-      CacheKey cache_key1 = base_cache_key.WithOffset(blob_offsets[1]);
-      const Slice key1 = cache_key1.AsSlice();
-      auto handle1 = blob_cache->Lookup(key1, statistics);
-      ASSERT_EQ(handle1, nullptr);
-
-      // erase key0 from the primary cache.
-      blob_cache->Erase(key0);
-      handle0 = blob_cache->Lookup(key0, statistics);
-      ASSERT_EQ(handle0, nullptr);
-
-      // key1 promotion should succeed due to the primary cache being empty. we
-      // did't call secondary cache's Lookup() here, because it will remove the
-      // key but it won't be able to promote the key to the primary cache.
-      // Instead we use the end-to-end blob source API to read key1.
-      // In function TEST_BlobInCache, key1's dummy item is inserted into the
-      // primary cache and a standalone handle is checked by GetValue().
-      ASSERT_TRUE(blob_source.TEST_BlobInCache(file_number, file_size,
-                                               blob_offsets[1]));
-
-      // key1's dummy handle is in the primary cache and key1's item is still
-      // in the secondary cache. So, the primary cache's Lookup() can only
-      // get a dummy handle.
-      handle1 = blob_cache->Lookup(key1, statistics);
-      ASSERT_NE(handle1, nullptr);
-      // handl1 is a dummy handle.
-      ASSERT_EQ(blob_cache->Value(handle1), nullptr);
-      blob_cache->Release(handle1);
-    }
-  }
-}
-
-class BlobSourceCacheReservationTest : public DBTestBase {
- public:
-  explicit BlobSourceCacheReservationTest()
-      : DBTestBase("blob_source_cache_reservation_test",
-                   /*env_do_fsync=*/true) {
-    options_.env = env_;
-    options_.enable_blob_files = true;
-    options_.create_if_missing = true;
-
-    LRUCacheOptions co;
-    co.capacity = kCacheCapacity;
-    co.num_shard_bits = kNumShardBits;
-    co.metadata_charge_policy = kDontChargeCacheMetadata;
-
-    co.high_pri_pool_ratio = 0.0;
-    co.low_pri_pool_ratio = 0.0;
-    std::shared_ptr<Cache> blob_cache = NewLRUCache(co);
-
-    co.high_pri_pool_ratio = 0.5;
-    co.low_pri_pool_ratio = 0.5;
-    std::shared_ptr<Cache> block_cache = NewLRUCache(co);
-
-    options_.blob_cache = blob_cache;
-    options_.lowest_used_cache_tier = CacheTier::kVolatileTier;
-
-    BlockBasedTableOptions block_based_options;
-    block_based_options.no_block_cache = false;
-    block_based_options.block_cache = block_cache;
-    block_based_options.cache_usage_options.options_overrides.insert(
-        {CacheEntryRole::kBlobCache,
-         {/* charged = */ CacheEntryRoleOptions::Decision::kEnabled}});
-    options_.table_factory.reset(
-        NewBlockBasedTableFactory(block_based_options));
-
-    assert(db_->GetDbIdentity(db_id_).ok());
-    assert(db_->GetDbSessionId(db_session_id_).ok());
-  }
-
-  void GenerateKeysAndBlobs() {
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      key_strs_.push_back("key" + std::to_string(i));
-      blob_strs_.push_back("blob" + std::to_string(i));
-    }
-
-    blob_file_size_ = BlobLogHeader::kSize;
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      keys_.push_back({key_strs_[i]});
-      blobs_.push_back({blob_strs_[i]});
-      blob_file_size_ +=
-          BlobLogRecord::kHeaderSize + keys_[i].size() + blobs_[i].size();
-    }
-    blob_file_size_ += BlobLogFooter::kSize;
-  }
-
-  static constexpr std::size_t kSizeDummyEntry = CacheReservationManagerImpl<
-      CacheEntryRole::kBlobCache>::GetDummyEntrySize();
-  static constexpr std::size_t kCacheCapacity = 1 * kSizeDummyEntry;
-  static constexpr int kNumShardBits = 0;  // 2^0 shard
-
-  static constexpr uint32_t kColumnFamilyId = 1;
-  static constexpr bool kHasTTL = false;
-  static constexpr uint64_t kBlobFileNumber = 1;
-  static constexpr size_t kNumBlobs = 16;
-
-  std::vector<Slice> keys_;
-  std::vector<Slice> blobs_;
-  std::vector<std::string> key_strs_;
-  std::vector<std::string> blob_strs_;
-  uint64_t blob_file_size_;
-
-  Options options_;
-  std::string db_id_;
-  std::string db_session_id_;
-};
-
-#ifndef ROCKSDB_LITE
-TEST_F(BlobSourceCacheReservationTest, SimpleCacheReservation) {
-  options_.cf_paths.emplace_back(
-      test::PerThreadDBPath(
-          env_, "BlobSourceCacheReservationTest_SimpleCacheReservation"),
-      0);
-
-  GenerateKeysAndBlobs();
-
-  DestroyAndReopen(options_);
-
-  ImmutableOptions immutable_options(options_);
-
-  constexpr ExpirationRange expiration_range;
-
-  std::vector<uint64_t> blob_offsets(keys_.size());
-  std::vector<uint64_t> blob_sizes(keys_.size());
-
-  WriteBlobFile(immutable_options, kColumnFamilyId, kHasTTL, expiration_range,
-                expiration_range, kBlobFileNumber, keys_, blobs_,
-                kNoCompression, blob_offsets, blob_sizes);
-
-  constexpr size_t capacity = 10;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          kColumnFamilyId, blob_file_read_hist, nullptr /*IOTracer*/);
-
-  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
-                         blob_file_cache.get());
-
-  ConcurrentCacheReservationManager* cache_res_mgr =
-      static_cast<ChargedCache*>(blob_source.GetBlobCache())
-          ->TEST_GetCacheReservationManager();
-  ASSERT_NE(cache_res_mgr, nullptr);
-
-  ReadOptions read_options;
-  read_options.verify_checksums = true;
-
-  {
-    read_options.fill_cache = false;
-
-    std::vector<PinnableSlice> values(keys_.size());
-
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      ASSERT_OK(blob_source.GetBlob(
-          read_options, keys_[i], kBlobFileNumber, blob_offsets[i],
-          blob_file_size_, blob_sizes[i], kNoCompression,
-          nullptr /* prefetch_buffer */, &values[i], nullptr /* bytes_read */));
-      ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), 0);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(), 0);
-    }
-  }
-
-  {
-    read_options.fill_cache = true;
-
-    std::vector<PinnableSlice> values(keys_.size());
-
-    // num_blobs is 16, so the total blob cache usage is less than a single
-    // dummy entry. Therefore, cache reservation manager only reserves one dummy
-    // entry here.
-    uint64_t blob_bytes = 0;
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      ASSERT_OK(blob_source.GetBlob(
-          read_options, keys_[i], kBlobFileNumber, blob_offsets[i],
-          blob_file_size_, blob_sizes[i], kNoCompression,
-          nullptr /* prefetch_buffer */, &values[i], nullptr /* bytes_read */));
-
-      size_t charge = 0;
-      ASSERT_TRUE(blob_source.TEST_BlobInCache(kBlobFileNumber, blob_file_size_,
-                                               blob_offsets[i], &charge));
-
-      blob_bytes += charge;
-      ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), kSizeDummyEntry);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(), blob_bytes);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(),
-                options_.blob_cache->GetUsage());
-    }
-  }
-
-  {
-    OffsetableCacheKey base_cache_key(db_id_, db_session_id_, kBlobFileNumber);
-    size_t blob_bytes = options_.blob_cache->GetUsage();
-
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      size_t charge = 0;
-      ASSERT_TRUE(blob_source.TEST_BlobInCache(kBlobFileNumber, blob_file_size_,
-                                               blob_offsets[i], &charge));
-
-      CacheKey cache_key = base_cache_key.WithOffset(blob_offsets[i]);
-      // We didn't call options_.blob_cache->Erase() here, this is because
-      // the cache wrapper's Erase() method must be called to update the
-      // cache usage after erasing the cache entry.
-      blob_source.GetBlobCache()->Erase(cache_key.AsSlice());
-      if (i == kNumBlobs - 1) {
-        // All the blobs got removed from the cache. cache_res_mgr should not
-        // reserve any space for them.
-        ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), 0);
-      } else {
-        ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), kSizeDummyEntry);
-      }
-      blob_bytes -= charge;
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(), blob_bytes);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(),
-                options_.blob_cache->GetUsage());
-    }
-  }
-}
-
-TEST_F(BlobSourceCacheReservationTest, IncreaseCacheReservationOnFullCache) {
-  options_.cf_paths.emplace_back(
-      test::PerThreadDBPath(
-          env_,
-          "BlobSourceCacheReservationTest_IncreaseCacheReservationOnFullCache"),
-      0);
-
-  GenerateKeysAndBlobs();
-
-  DestroyAndReopen(options_);
-
-  ImmutableOptions immutable_options(options_);
-  constexpr size_t blob_size = kSizeDummyEntry / (kNumBlobs / 2);
-  for (size_t i = 0; i < kNumBlobs; ++i) {
-    blob_file_size_ -= blobs_[i].size();  // old blob size
-    blob_strs_[i].resize(blob_size, '@');
-    blobs_[i] = Slice(blob_strs_[i]);
-    blob_file_size_ += blobs_[i].size();  // new blob size
-  }
-
-  std::vector<uint64_t> blob_offsets(keys_.size());
-  std::vector<uint64_t> blob_sizes(keys_.size());
-
-  constexpr ExpirationRange expiration_range;
-  WriteBlobFile(immutable_options, kColumnFamilyId, kHasTTL, expiration_range,
-                expiration_range, kBlobFileNumber, keys_, blobs_,
-                kNoCompression, blob_offsets, blob_sizes);
-
-  constexpr size_t capacity = 10;
-  std::shared_ptr<Cache> backing_cache = NewLRUCache(capacity);
-
-  FileOptions file_options;
-  constexpr HistogramImpl* blob_file_read_hist = nullptr;
-
-  std::unique_ptr<BlobFileCache> blob_file_cache =
-      std::make_unique<BlobFileCache>(
-          backing_cache.get(), &immutable_options, &file_options,
-          kColumnFamilyId, blob_file_read_hist, nullptr /*IOTracer*/);
-
-  BlobSource blob_source(&immutable_options, db_id_, db_session_id_,
-                         blob_file_cache.get());
-
-  ConcurrentCacheReservationManager* cache_res_mgr =
-      static_cast<ChargedCache*>(blob_source.GetBlobCache())
-          ->TEST_GetCacheReservationManager();
-  ASSERT_NE(cache_res_mgr, nullptr);
-
-  ReadOptions read_options;
-  read_options.verify_checksums = true;
-
-  {
-    read_options.fill_cache = false;
-
-    std::vector<PinnableSlice> values(keys_.size());
-
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      ASSERT_OK(blob_source.GetBlob(
-          read_options, keys_[i], kBlobFileNumber, blob_offsets[i],
-          blob_file_size_, blob_sizes[i], kNoCompression,
-          nullptr /* prefetch_buffer */, &values[i], nullptr /* bytes_read */));
-      ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), 0);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(), 0);
-    }
-  }
-
-  {
-    read_options.fill_cache = true;
-
-    std::vector<PinnableSlice> values(keys_.size());
-
-    // Since we resized each blob to be kSizeDummyEntry / (num_blobs / 2), we
-    // can't fit all the blobs in the cache at the same time, which means we
-    // should observe cache evictions once we reach the cache's capacity.
-    // Due to the overhead of the cache and the BlobContents objects, as well as
-    // jemalloc bin sizes, this happens after inserting seven blobs.
-    uint64_t blob_bytes = 0;
-    for (size_t i = 0; i < kNumBlobs; ++i) {
-      ASSERT_OK(blob_source.GetBlob(
-          read_options, keys_[i], kBlobFileNumber, blob_offsets[i],
-          blob_file_size_, blob_sizes[i], kNoCompression,
-          nullptr /* prefetch_buffer */, &values[i], nullptr /* bytes_read */));
-
-      // Release cache handle
-      values[i].Reset();
-
-      if (i < kNumBlobs / 2 - 1) {
-        size_t charge = 0;
-        ASSERT_TRUE(blob_source.TEST_BlobInCache(
-            kBlobFileNumber, blob_file_size_, blob_offsets[i], &charge));
-
-        blob_bytes += charge;
-      }
-
-      ASSERT_EQ(cache_res_mgr->GetTotalReservedCacheSize(), kSizeDummyEntry);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(), blob_bytes);
-      ASSERT_EQ(cache_res_mgr->GetTotalMemoryUsed(),
-                options_.blob_cache->GetUsage());
-    }
-  }
-}
-#endif  // ROCKSDB_LITE
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/blob/db_blob_basic_test.cc

@@ -7,7 +7,6 @@
 #include <sstream>
 #include <string>
 
-#include "cache/compressed_secondary_cache.h"
 #include "db/blob/blob_index.h"
 #include "db/blob/blob_log_format.h"
 #include "db/db_test_util.h"
@@ -54,7 +53,7 @@ TEST_F(DBBlobBasicTest, GetBlobFromCache) {
   Options options = GetDefaultOptions();
 
   LRUCacheOptions co;
-  co.capacity = 2 << 20;  // 2MB
+  co.capacity = 2048;
   co.num_shard_bits = 2;
   co.metadata_charge_policy = kDontChargeCacheMetadata;
   auto backing_cache = NewLRUCache(co);
@@ -122,7 +121,7 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
   Options options = GetDefaultOptions();
 
   LRUCacheOptions co;
-  co.capacity = 2 << 20;  // 2MB
+  co.capacity = 2048;
   co.num_shard_bits = 2;
   co.metadata_charge_policy = kDontChargeCacheMetadata;
   auto backing_cache = NewLRUCache(co);
@@ -136,8 +135,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
   block_based_options.cache_index_and_filter_blocks = true;
   options.table_factory.reset(NewBlockBasedTableFactory(block_based_options));
 
-  options.statistics = CreateDBStatistics();
-
   Reopen(options);
 
   int num_blobs = 5;
@@ -168,7 +165,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
       ++i;
     }
     ASSERT_EQ(i, num_blobs);
-    ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD), 0);
   }
 
   {
@@ -184,7 +180,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
     iter->SeekToFirst();
     ASSERT_NOK(iter->status());
     ASSERT_FALSE(iter->Valid());
-    ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD), 0);
   }
 
   {
@@ -203,8 +198,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
       ++i;
     }
     ASSERT_EQ(i, num_blobs);
-    ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD),
-              num_blobs);
   }
 
   {
@@ -224,149 +217,6 @@ TEST_F(DBBlobBasicTest, IterateBlobsFromCache) {
       ++i;
     }
     ASSERT_EQ(i, num_blobs);
-    ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD), 0);
-  }
-}
-
-TEST_F(DBBlobBasicTest, IterateBlobsFromCachePinning) {
-  constexpr size_t min_blob_size = 6;
-
-  Options options = GetDefaultOptions();
-
-  LRUCacheOptions cache_options;
-  cache_options.capacity = 2048;
-  cache_options.num_shard_bits = 0;
-  cache_options.metadata_charge_policy = kDontChargeCacheMetadata;
-
-  options.blob_cache = NewLRUCache(cache_options);
-  options.enable_blob_files = true;
-  options.min_blob_size = min_blob_size;
-
-  Reopen(options);
-
-  // Put then iterate over three key-values. The second value is below the size
-  // limit and is thus stored inline; the other two are stored separately as
-  // blobs. We expect to have something pinned in the cache iff we are
-  // positioned on a blob.
-
-  constexpr char first_key[] = "first_key";
-  constexpr char first_value[] = "long_value";
-  static_assert(sizeof(first_value) - 1 >= min_blob_size,
-                "first_value too short to be stored as blob");
-
-  ASSERT_OK(Put(first_key, first_value));
-
-  constexpr char second_key[] = "second_key";
-  constexpr char second_value[] = "short";
-  static_assert(sizeof(second_value) - 1 < min_blob_size,
-                "second_value too long to be inlined");
-
-  ASSERT_OK(Put(second_key, second_value));
-
-  constexpr char third_key[] = "third_key";
-  constexpr char third_value[] = "other_long_value";
-  static_assert(sizeof(third_value) - 1 >= min_blob_size,
-                "third_value too short to be stored as blob");
-
-  ASSERT_OK(Put(third_key, third_value));
-
-  ASSERT_OK(Flush());
-
-  {
-    ReadOptions read_options;
-    read_options.fill_cache = true;
-
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
-
-    iter->SeekToFirst();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), first_key);
-    ASSERT_EQ(iter->value(), first_value);
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), second_key);
-    ASSERT_EQ(iter->value(), second_value);
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), third_key);
-    ASSERT_EQ(iter->value(), third_value);
-
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-  }
-
-  {
-    ReadOptions read_options;
-    read_options.fill_cache = false;
-    read_options.read_tier = kBlockCacheTier;
-
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
-
-    iter->SeekToFirst();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), first_key);
-    ASSERT_EQ(iter->value(), first_value);
-    ASSERT_GT(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), second_key);
-    ASSERT_EQ(iter->value(), second_value);
-    ASSERT_EQ(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), third_key);
-    ASSERT_EQ(iter->value(), third_value);
-    ASSERT_GT(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(options.blob_cache->GetPinnedUsage(), 0);
-  }
-
-  {
-    ReadOptions read_options;
-    read_options.fill_cache = false;
-    read_options.read_tier = kBlockCacheTier;
-
-    std::unique_ptr<Iterator> iter(db_->NewIterator(read_options));
-
-    iter->SeekToLast();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), third_key);
-    ASSERT_EQ(iter->value(), third_value);
-    ASSERT_GT(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Prev();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), second_key);
-    ASSERT_EQ(iter->value(), second_value);
-    ASSERT_EQ(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Prev();
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(iter->key(), first_key);
-    ASSERT_EQ(iter->value(), first_value);
-    ASSERT_GT(options.blob_cache->GetPinnedUsage(), 0);
-
-    iter->Prev();
-    ASSERT_FALSE(iter->Valid());
-    ASSERT_OK(iter->status());
-    ASSERT_EQ(options.blob_cache->GetPinnedUsage(), 0);
   }
 }
 
@@ -453,7 +303,7 @@ TEST_F(DBBlobBasicTest, MultiGetBlobsFromCache) {
   Options options = GetDefaultOptions();
 
   LRUCacheOptions co;
-  co.capacity = 2 << 20;  // 2MB
+  co.capacity = 2048;
   co.num_shard_bits = 2;
   co.metadata_charge_policy = kDontChargeCacheMetadata;
   auto backing_cache = NewLRUCache(co);
@@ -1582,203 +1432,6 @@ TEST_P(DBBlobBasicIOErrorTest, CompactionFilterReadBlob_IOError) {
   SyncPoint::GetInstance()->ClearAllCallBacks();
 }
 
-TEST_F(DBBlobBasicTest, WarmCacheWithBlobsDuringFlush) {
-  Options options = GetDefaultOptions();
-
-  LRUCacheOptions co;
-  co.capacity = 1 << 25;
-  co.num_shard_bits = 2;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  auto backing_cache = NewLRUCache(co);
-
-  options.blob_cache = backing_cache;
-
-  BlockBasedTableOptions block_based_options;
-  block_based_options.no_block_cache = false;
-  block_based_options.block_cache = backing_cache;
-  block_based_options.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(block_based_options));
-
-  options.enable_blob_files = true;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  options.enable_blob_garbage_collection = true;
-  options.blob_garbage_collection_age_cutoff = 1.0;
-  options.prepopulate_blob_cache = PrepopulateBlobCache::kFlushOnly;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  DestroyAndReopen(options);
-
-  constexpr size_t kNumBlobs = 10;
-  constexpr size_t kValueSize = 100;
-
-  std::string value(kValueSize, 'a');
-
-  for (size_t i = 1; i <= kNumBlobs; i++) {
-    ASSERT_OK(Put(std::to_string(i), value));
-    ASSERT_OK(Put(std::to_string(i + kNumBlobs), value));  // Add some overlap
-    ASSERT_OK(Flush());
-    ASSERT_EQ(i * 2, options.statistics->getTickerCount(BLOB_DB_CACHE_ADD));
-    ASSERT_EQ(value, Get(std::to_string(i)));
-    ASSERT_EQ(value, Get(std::to_string(i + kNumBlobs)));
-    ASSERT_EQ(0, options.statistics->getTickerCount(BLOB_DB_CACHE_MISS));
-    ASSERT_EQ(i * 2, options.statistics->getTickerCount(BLOB_DB_CACHE_HIT));
-  }
-
-  // Verify compaction not counted
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-  EXPECT_EQ(kNumBlobs * 2,
-            options.statistics->getTickerCount(BLOB_DB_CACHE_ADD));
-}
-
-#ifndef ROCKSDB_LITE
-TEST_F(DBBlobBasicTest, DynamicallyWarmCacheDuringFlush) {
-  Options options = GetDefaultOptions();
-
-  LRUCacheOptions co;
-  co.capacity = 1 << 25;
-  co.num_shard_bits = 2;
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  auto backing_cache = NewLRUCache(co);
-
-  options.blob_cache = backing_cache;
-
-  BlockBasedTableOptions block_based_options;
-  block_based_options.no_block_cache = false;
-  block_based_options.block_cache = backing_cache;
-  block_based_options.cache_index_and_filter_blocks = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(block_based_options));
-
-  options.enable_blob_files = true;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  options.enable_blob_garbage_collection = true;
-  options.blob_garbage_collection_age_cutoff = 1.0;
-  options.prepopulate_blob_cache = PrepopulateBlobCache::kFlushOnly;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  DestroyAndReopen(options);
-
-  constexpr size_t kNumBlobs = 10;
-  constexpr size_t kValueSize = 100;
-
-  std::string value(kValueSize, 'a');
-
-  for (size_t i = 1; i <= 5; i++) {
-    ASSERT_OK(Put(std::to_string(i), value));
-    ASSERT_OK(Put(std::to_string(i + kNumBlobs), value));  // Add some overlap
-    ASSERT_OK(Flush());
-    ASSERT_EQ(2, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD));
-
-    ASSERT_EQ(value, Get(std::to_string(i)));
-    ASSERT_EQ(value, Get(std::to_string(i + kNumBlobs)));
-    ASSERT_EQ(0, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD));
-    ASSERT_EQ(0,
-              options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS));
-    ASSERT_EQ(2, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT));
-  }
-
-  ASSERT_OK(dbfull()->SetOptions({{"prepopulate_blob_cache", "kDisable"}}));
-
-  for (size_t i = 6; i <= kNumBlobs; i++) {
-    ASSERT_OK(Put(std::to_string(i), value));
-    ASSERT_OK(Put(std::to_string(i + kNumBlobs), value));  // Add some overlap
-    ASSERT_OK(Flush());
-    ASSERT_EQ(0, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD));
-
-    ASSERT_EQ(value, Get(std::to_string(i)));
-    ASSERT_EQ(value, Get(std::to_string(i + kNumBlobs)));
-    ASSERT_EQ(2, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD));
-    ASSERT_EQ(2,
-              options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS));
-    ASSERT_EQ(0, options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT));
-  }
-
-  // Verify compaction not counted
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), /*begin=*/nullptr,
-                              /*end=*/nullptr));
-  EXPECT_EQ(0, options.statistics->getTickerCount(BLOB_DB_CACHE_ADD));
-}
-#endif  // !ROCKSDB_LITE
-
-TEST_F(DBBlobBasicTest, WarmCacheWithBlobsSecondary) {
-  CompressedSecondaryCacheOptions secondary_cache_opts;
-  secondary_cache_opts.capacity = 1 << 20;
-  secondary_cache_opts.num_shard_bits = 0;
-  secondary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
-  secondary_cache_opts.compression_type = kNoCompression;
-
-  LRUCacheOptions primary_cache_opts;
-  primary_cache_opts.capacity = 1024;
-  primary_cache_opts.num_shard_bits = 0;
-  primary_cache_opts.metadata_charge_policy = kDontChargeCacheMetadata;
-  primary_cache_opts.secondary_cache =
-      NewCompressedSecondaryCache(secondary_cache_opts);
-
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.statistics = CreateDBStatistics();
-  options.enable_blob_files = true;
-  options.blob_cache = NewLRUCache(primary_cache_opts);
-  options.prepopulate_blob_cache = PrepopulateBlobCache::kFlushOnly;
-
-  DestroyAndReopen(options);
-
-  // Note: only one of the two blobs fit in the primary cache at any given time.
-  constexpr char first_key[] = "foo";
-  constexpr size_t first_blob_size = 512;
-  const std::string first_blob(first_blob_size, 'a');
-
-  constexpr char second_key[] = "bar";
-  constexpr size_t second_blob_size = 768;
-  const std::string second_blob(second_blob_size, 'b');
-
-  // First blob is inserted into primary cache during flush.
-  ASSERT_OK(Put(first_key, first_blob));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD), 1);
-
-  // Second blob is inserted into primary cache during flush,
-  // First blob is evicted but only a dummy handle is inserted into secondary
-  // cache.
-  ASSERT_OK(Put(second_key, second_blob));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_ADD), 1);
-
-  // First blob is inserted into primary cache.
-  // Second blob is evicted but only a dummy handle is inserted into secondary
-  // cache.
-  ASSERT_EQ(Get(first_key), first_blob);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS), 1);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT), 0);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(SECONDARY_CACHE_HITS),
-            0);
-  // Second blob is inserted into primary cache,
-  // First blob is evicted and is inserted into secondary cache.
-  ASSERT_EQ(Get(second_key), second_blob);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS), 1);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT), 0);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(SECONDARY_CACHE_HITS),
-            0);
-
-  // First blob's dummy item is inserted into primary cache b/c of lookup.
-  // Second blob is still in primary cache.
-  ASSERT_EQ(Get(first_key), first_blob);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS), 0);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT), 1);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(SECONDARY_CACHE_HITS),
-            1);
-
-  // First blob's item is inserted into primary cache b/c of lookup.
-  // Second blob is evicted and inserted into secondary cache.
-  ASSERT_EQ(Get(first_key), first_blob);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_MISS), 0);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(BLOB_DB_CACHE_HIT), 1);
-  ASSERT_EQ(options.statistics->getAndResetTickerCount(SECONDARY_CACHE_HITS),
-            1);
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/blob/db_blob_compaction_test.cc

@@ -54,26 +54,6 @@ class FilterByKeyLength : public CompactionFilter {
   size_t length_threshold_;
 };
 
-class FilterByValueLength : public CompactionFilter {
- public:
-  explicit FilterByValueLength(size_t len) : length_threshold_(len) {}
-  const char* Name() const override {
-    return "rocksdb.compaction.filter.by.value.length";
-  }
-  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 {
-    if (existing_value.size() < length_threshold_) {
-      return CompactionFilter::Decision::kRemove;
-    }
-    return CompactionFilter::Decision::kKeep;
-  }
-
- private:
-  size_t length_threshold_;
-};
-
 class BadBlobCompactionFilter : public CompactionFilter {
  public:
   explicit BadBlobCompactionFilter(std::string prefix,
@@ -263,55 +243,6 @@ TEST_F(DBBlobCompactionTest, FilterByKeyLength) {
   Close();
 }
 
-TEST_F(DBBlobCompactionTest, FilterByValueLength) {
-  Options options = GetDefaultOptions();
-  options.enable_blob_files = true;
-  options.min_blob_size = 5;
-  options.create_if_missing = true;
-  constexpr size_t kValueLength = 5;
-  std::unique_ptr<CompactionFilter> compaction_filter_guard(
-      new FilterByValueLength(kValueLength));
-  options.compaction_filter = compaction_filter_guard.get();
-
-  const std::vector<std::string> short_value_keys = {"a", "e", "j"};
-  constexpr char short_value[] = "val";
-  const std::vector<std::string> long_value_keys = {"b", "f", "k"};
-  constexpr char long_value[] = "valuevalue";
-
-  DestroyAndReopen(options);
-  for (size_t i = 0; i < short_value_keys.size(); ++i) {
-    ASSERT_OK(Put(short_value_keys[i], short_value));
-  }
-  for (size_t i = 0; i < short_value_keys.size(); ++i) {
-    ASSERT_OK(Put(long_value_keys[i], long_value));
-  }
-  ASSERT_OK(Flush());
-  CompactRangeOptions cro;
-  ASSERT_OK(db_->CompactRange(cro, /*begin=*/nullptr, /*end=*/nullptr));
-  std::string value;
-  for (size_t i = 0; i < short_value_keys.size(); ++i) {
-    ASSERT_TRUE(
-        db_->Get(ReadOptions(), short_value_keys[i], &value).IsNotFound());
-    value.clear();
-  }
-  for (size_t i = 0; i < long_value_keys.size(); ++i) {
-    ASSERT_OK(db_->Get(ReadOptions(), long_value_keys[i], &value));
-    ASSERT_EQ(long_value, value);
-  }
-
-#ifndef ROCKSDB_LITE
-  const auto& compaction_stats = GetCompactionStats();
-  ASSERT_GE(compaction_stats.size(), 2);
-
-  // Filter decides between kKeep and kRemove based on value;
-  // this involves reading but not writing blobs
-  ASSERT_GT(compaction_stats[1].bytes_read_blob, 0);
-  ASSERT_EQ(compaction_stats[1].bytes_written_blob, 0);
-#endif  // ROCKSDB_LITE
-
-  Close();
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(DBBlobCompactionTest, BlobCompactWithStartingLevel) {
   Options options = GetDefaultOptions();

db/builder.cc

@@ -188,10 +188,10 @@ Status BuildTable(
          blob_file_additions)
             ? new BlobFileBuilder(
                   versions, fs, &ioptions, &mutable_cf_options, &file_options,
-                  tboptions.db_id, tboptions.db_session_id, 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)
+                  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)
             : nullptr);
 
     const std::atomic<bool> kManualCompactionCanceledFalse{false};

db/c.cc

@@ -99,7 +99,6 @@ using ROCKSDB_NAMESPACE::Options;
 using ROCKSDB_NAMESPACE::PerfContext;
 using ROCKSDB_NAMESPACE::PerfLevel;
 using ROCKSDB_NAMESPACE::PinnableSlice;
-using ROCKSDB_NAMESPACE::PrepopulateBlobCache;
 using ROCKSDB_NAMESPACE::RandomAccessFile;
 using ROCKSDB_NAMESPACE::Range;
 using ROCKSDB_NAMESPACE::RateLimiter;
@@ -1054,18 +1053,6 @@ void rocksdb_drop_column_family(
   SaveError(errptr, db->rep->DropColumnFamily(handle->rep));
 }
 
-uint32_t rocksdb_column_family_handle_get_id(
-    rocksdb_column_family_handle_t* handle) {
-  return handle->rep->GetID();
-}
-
-char* rocksdb_column_family_handle_get_name(
-    rocksdb_column_family_handle_t* handle, size_t* name_len) {
-  auto name = handle->rep->GetName();
-  *name_len = name.size();
-  return CopyString(name);
-}
-
 void rocksdb_column_family_handle_destroy(rocksdb_column_family_handle_t* handle) {
   delete handle->rep;
   delete handle;
@@ -2618,11 +2605,6 @@ void rocksdb_block_based_options_destroy(
   delete options;
 }
 
-void rocksdb_block_based_options_set_checksum(
-    rocksdb_block_based_table_options_t* opt, char v) {
-  opt->rep.checksum = static_cast<ROCKSDB_NAMESPACE::ChecksumType>(v);
-}
-
 void rocksdb_block_based_options_set_block_size(
     rocksdb_block_based_table_options_t* options, size_t block_size) {
   options->rep.block_size = block_size;
@@ -3158,14 +3140,6 @@ void rocksdb_options_set_blob_cache(rocksdb_options_t* opt,
   opt->rep.blob_cache = blob_cache->rep;
 }
 
-void rocksdb_options_set_prepopulate_blob_cache(rocksdb_options_t* opt, int t) {
-  opt->rep.prepopulate_blob_cache = static_cast<PrepopulateBlobCache>(t);
-}
-
-int rocksdb_options_get_prepopulate_blob_cache(rocksdb_options_t* opt) {
-  return static_cast<int>(opt->rep.prepopulate_blob_cache);
-}
-
 void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
   opt->rep.num_levels = n;
 }
@@ -4116,8 +4090,6 @@ uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
       return rep->blob_checksum_time;
     case rocksdb_blob_decompress_time:
       return rep->blob_decompress_time;
-    case rocksdb_internal_range_del_reseek_count:
-      return rep->internal_range_del_reseek_count;
     default:
       break;
   }
@@ -4927,15 +4899,6 @@ void rocksdb_sstfilewriter_delete_with_ts(rocksdb_sstfilewriter_t* writer,
   SaveError(errptr, writer->rep->Delete(Slice(key, keylen), Slice(ts, tslen)));
 }
 
-void rocksdb_sstfilewriter_delete_range(rocksdb_sstfilewriter_t* writer,
-                                        const char* begin_key,
-                                        size_t begin_keylen,
-                                        const char* end_key, size_t end_keylen,
-                                        char** errptr) {
-  SaveError(errptr, writer->rep->DeleteRange(Slice(begin_key, begin_keylen),
-                                             Slice(end_key, end_keylen)));
-}
-
 void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
                                   char** errptr) {
   SaveError(errptr, writer->rep->Finish(nullptr));

db/c_test.c

@@ -905,21 +905,6 @@ int main(int argc, char** argv) {
     CheckGet(db, roptions, "sstk22", "v5");
     CheckGet(db, roptions, "sstk3", "v6");
 
-    rocksdb_sstfilewriter_open(writer, sstfilename, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_put(writer, "abc1", 4, "v7", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_put(writer, "abc2", 4, "v8", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_put(writer, "abc3", 4, "v9", 2, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_put(writer, "abc4", 4, "v10", 3, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_delete_range(writer, "abc1", 4, "abc4", 4, &err);
-    CheckNoError(err);
-    rocksdb_sstfilewriter_finish(writer, &err);
-    CheckNoError(err);
-
     rocksdb_ingestexternalfileoptions_destroy(ing_opt);
     rocksdb_sstfilewriter_destroy(writer);
     rocksdb_options_destroy(io_options);
@@ -2068,9 +2053,6 @@ int main(int argc, char** argv) {
     rocksdb_options_set_blob_file_starting_level(o, 5);
     CheckCondition(5 == rocksdb_options_get_blob_file_starting_level(o));
 
-    rocksdb_options_set_prepopulate_blob_cache(o, 1 /* flush only */);
-    CheckCondition(1 == rocksdb_options_get_prepopulate_blob_cache(o));
-
     // Create a copy that should be equal to the original.
     rocksdb_options_t* copy;
     copy = rocksdb_options_create_copy(o);

db/column_family.cc

@@ -233,21 +233,6 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
     result.min_write_buffer_number_to_merge = 1;
   }
 
-  if (db_options.atomic_flush && result.min_write_buffer_number_to_merge > 1) {
-    ROCKS_LOG_WARN(
-        db_options.logger,
-        "Currently, if atomic_flush is true, then triggering flush for any "
-        "column family internally (non-manual flush) will trigger flushing "
-        "all column families even if the number of memtables is smaller "
-        "min_write_buffer_number_to_merge. Therefore, configuring "
-        "min_write_buffer_number_to_merge > 1 is not compatible and should "
-        "be satinized to 1. Not doing so will lead to data loss and "
-        "inconsistent state across multiple column families when WAL is "
-        "disabled, which is a common setting for atomic flush");
-
-    result.min_write_buffer_number_to_merge = 1;
-  }
-
   if (result.num_levels < 1) {
     result.num_levels = 1;
   }
@@ -788,13 +773,13 @@ namespace {
 std::unique_ptr<WriteControllerToken> SetupDelay(
     WriteController* write_controller, uint64_t compaction_needed_bytes,
     uint64_t prev_compaction_need_bytes, bool penalize_stop,
-    bool auto_compactions_disabled) {
+    bool auto_comapctions_disabled) {
   const uint64_t kMinWriteRate = 16 * 1024u;  // Minimum write rate 16KB/s.
 
   uint64_t max_write_rate = write_controller->max_delayed_write_rate();
   uint64_t write_rate = write_controller->delayed_write_rate();
 
-  if (auto_compactions_disabled) {
+  if (auto_comapctions_disabled) {
     // When auto compaction is disabled, always use the value user gave.
     write_rate = max_write_rate;
   } else if (write_controller->NeedsDelay() && max_write_rate > kMinWriteRate) {
@@ -1159,14 +1144,13 @@ Status ColumnFamilyData::RangesOverlapWithMemtables(
   MergeIteratorBuilder merge_iter_builder(&internal_comparator_, &arena);
   merge_iter_builder.AddIterator(
       super_version->mem->NewIterator(read_opts, &arena));
-  super_version->imm->AddIterators(read_opts, &merge_iter_builder,
-                                   false /* add_range_tombstone_iter */);
+  super_version->imm->AddIterators(read_opts, &merge_iter_builder);
   ScopedArenaIterator memtable_iter(merge_iter_builder.Finish());
 
   auto read_seq = super_version->current->version_set()->LastSequence();
   ReadRangeDelAggregator range_del_agg(&internal_comparator_, read_seq);
-  auto* active_range_del_iter = super_version->mem->NewRangeTombstoneIterator(
-      read_opts, read_seq, false /* immutable_memtable */);
+  auto* active_range_del_iter =
+      super_version->mem->NewRangeTombstoneIterator(read_opts, read_seq);
   range_del_agg.AddTombstones(
       std::unique_ptr<FragmentedRangeTombstoneIterator>(active_range_del_iter));
   Status status;
@@ -1431,14 +1415,6 @@ Status ColumnFamilyData::ValidateOptions(
         "FIFO compaction only supported with max_open_files = -1.");
   }
 
-  std::vector<uint32_t> supported{0, 1, 2, 4, 8};
-  if (std::find(supported.begin(), supported.end(),
-                cf_options.memtable_protection_bytes_per_key) ==
-      supported.end()) {
-    return Status::NotSupported(
-        "Memtable per key-value checksum protection only supports 0, 1, 2, 4 "
-        "or 8 bytes per key.");
-  }
   return s;
 }
 

db/column_family_test.cc

@@ -1116,7 +1116,7 @@ TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
   CreateColumnFamilies({"one", "two", "three"});
   ColumnFamilyOptions default_cf, one, two, three;
   // setup options. all column families have max_write_buffer_number setup to 10
-  // "default" -> 100KB memtable, start flushing immediately
+  // "default" -> 100KB memtable, start flushing immediatelly
   // "one" -> 200KB memtable, start flushing with two immutable memtables
   // "two" -> 1MB memtable, start flushing with three immutable memtables
   // "three" -> 90KB memtable, start flushing with four immutable memtables
@@ -2207,22 +2207,9 @@ TEST_P(ColumnFamilyTest, FlushStaleColumnFamilies) {
   PutRandomData(0, 100, 1000);  // flush
   WaitForFlush(0);
   WaitForFlush(2);
-  // at least 3 files for default column families, 1 file for column family
-  // [two], zero files for column family [one], because it's empty
-  std::vector<LiveFileMetaData> metadata;
-  db_->GetLiveFilesMetaData(&metadata);
-  ASSERT_GE(metadata.size(), 4);
-  bool has_cf1_sst = false;
-  bool has_cf2_sst = false;
-  for (const auto& file : metadata) {
-    if (file.column_family_name == "one") {
-      has_cf1_sst = true;
-    } else if (file.column_family_name == "two") {
-      has_cf2_sst = true;
-    }
-  }
-  ASSERT_FALSE(has_cf1_sst);
-  ASSERT_TRUE(has_cf2_sst);
+  // 3 files for default column families, 1 file for column family [two], zero
+  // files for column family [one], because it's empty
+  AssertCountLiveFiles(4);
 
   ASSERT_OK(Flush(0));
   ASSERT_EQ(0, dbfull()->TEST_total_log_size());
@@ -2939,7 +2926,7 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupTwoColumnFamilies) {
   ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());
 }
 
-TEST_P(ColumnFamilyTest, CreateAndDestroyOptions) {
+TEST_P(ColumnFamilyTest, CreateAndDestoryOptions) {
   std::unique_ptr<ColumnFamilyOptions> cfo(new ColumnFamilyOptions());
   ColumnFamilyHandle* cfh;
   Open();
@@ -3433,27 +3420,6 @@ TEST(ColumnFamilyTest, ValidateBlobGCForceThreshold) {
                   .IsInvalidArgument());
 }
 
-TEST(ColumnFamilyTest, ValidateMemtableKVChecksumOption) {
-  DBOptions db_options;
-
-  ColumnFamilyOptions cf_options;
-  ASSERT_OK(ColumnFamilyData::ValidateOptions(db_options, cf_options));
-
-  cf_options.memtable_protection_bytes_per_key = 5;
-  ASSERT_TRUE(ColumnFamilyData::ValidateOptions(db_options, cf_options)
-                  .IsNotSupported());
-
-  cf_options.memtable_protection_bytes_per_key = 1;
-  ASSERT_OK(ColumnFamilyData::ValidateOptions(db_options, cf_options));
-
-  cf_options.memtable_protection_bytes_per_key = 16;
-  ASSERT_TRUE(ColumnFamilyData::ValidateOptions(db_options, cf_options)
-                  .IsNotSupported());
-
-  cf_options.memtable_protection_bytes_per_key = 0;
-  ASSERT_OK(ColumnFamilyData::ValidateOptions(db_options, cf_options));
-}
-
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

db/compact_files_test.cc

@@ -77,7 +77,7 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) {
   options.compression = kNoCompression;
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   assert(s.ok());
   assert(db);
@@ -128,7 +128,7 @@ TEST_F(CompactFilesTest, MultipleLevel) {
   options.listeners.emplace_back(collector);
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
   ASSERT_NE(db, nullptr);
@@ -211,7 +211,7 @@ TEST_F(CompactFilesTest, ObsoleteFiles) {
   options.listeners.emplace_back(collector);
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
   ASSERT_NE(db, nullptr);
@@ -250,7 +250,7 @@ TEST_F(CompactFilesTest, NotCutOutputOnLevel0) {
   options.listeners.emplace_back(collector);
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   assert(s.ok());
   assert(db);
@@ -288,7 +288,7 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
   options.listeners.emplace_back(collector);
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
   assert(db);
@@ -366,7 +366,7 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
   options.compaction_filter = cf.get();
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
 
@@ -404,7 +404,7 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
        {CompactionStyle::kCompactionStyleLevel,
         CompactionStyle::kCompactionStyleUniversal,
         CompactionStyle::kCompactionStyleNone}) {
-    ASSERT_OK(DestroyDB(db_name_, Options()));
+    DestroyDB(db_name_, Options());
     Options options;
     options.compaction_style = compaction_style;
     // L0: Snappy, L1: ZSTD, L2: Snappy
@@ -458,7 +458,7 @@ TEST_F(CompactFilesTest, GetCompactionJobInfo) {
   options.listeners.emplace_back(collector);
 
   DB* db = nullptr;
-  ASSERT_OK(DestroyDB(db_name_, options));
+  DestroyDB(db_name_, options);
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
   assert(db);

db/compaction/compaction.cc

@@ -660,23 +660,20 @@ bool Compaction::IsOutputLevelEmpty() const {
 }
 
 bool Compaction::ShouldFormSubcompactions() const {
-  if (cfd_ == nullptr) {
+  if (max_subcompactions_ <= 1 || cfd_ == nullptr) {
     return false;
   }
 
-  // Round-Robin pri under leveled compaction allows subcompactions by default
-  // and the number of subcompactions can be larger than max_subcompactions_
-  if (cfd_->ioptions()->compaction_pri == kRoundRobin &&
-      cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
-    return output_level_ > 0;
-  }
-
-  if (max_subcompactions_ <= 1) {
+  // 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;
+    return (start_level_ == 0 || is_manual_compaction_) && output_level_ > 0 &&
+           !IsOutputLevelEmpty();
   } else if (cfd_->ioptions()->compaction_style == kCompactionStyleUniversal) {
     return number_levels_ > 1 && output_level_ > 0;
   } else {

db/compaction/compaction.h

@@ -212,11 +212,6 @@ class Compaction {
   // Is this compaction creating a file in the bottom most level?
   bool bottommost_level() const { return bottommost_level_; }
 
-  // Is the compaction compact to the last level
-  bool is_last_level() const {
-    return output_level_ == immutable_options_.num_levels - 1;
-  }
-
   // Does this compaction include all sst files?
   bool is_full_compaction() const { return is_full_compaction_; }
 

db/compaction/compaction_iterator.cc

@@ -80,15 +80,6 @@ CompactionIterator::CompactionIterator(
       compaction_filter_(compaction_filter),
       shutting_down_(shutting_down),
       manual_compaction_canceled_(manual_compaction_canceled),
-      bottommost_level_(!compaction_ ? false
-                                     : compaction_->bottommost_level() &&
-                                           !compaction_->allow_ingest_behind()),
-      // snapshots_ cannot be nullptr, but we will assert later in the body of
-      // the constructor.
-      visible_at_tip_(snapshots_ ? snapshots_->empty() : false),
-      earliest_snapshot_(!snapshots_ || snapshots_->empty()
-                             ? kMaxSequenceNumber
-                             : snapshots_->at(0)),
       info_log_(info_log),
       allow_data_in_errors_(allow_data_in_errors),
       enforce_single_del_contracts_(enforce_single_del_contracts),
@@ -107,10 +98,25 @@ CompactionIterator::CompactionIterator(
       level_(compaction_ == nullptr ? 0 : compaction_->level()),
       penultimate_level_cutoff_seqno_(penultimate_level_cutoff_seqno) {
   assert(snapshots_ != nullptr);
-
+  bottommost_level_ = compaction_ == nullptr
+                          ? false
+                          : compaction_->bottommost_level() &&
+                                !compaction_->allow_ingest_behind();
   if (compaction_ != nullptr) {
     level_ptrs_ = std::vector<size_t>(compaction_->number_levels(), 0);
   }
+  if (snapshots_->size() == 0) {
+    // optimize for fast path if there are no snapshots
+    visible_at_tip_ = true;
+    earliest_snapshot_iter_ = snapshots_->end();
+    earliest_snapshot_ = kMaxSequenceNumber;
+    latest_snapshot_ = 0;
+  } else {
+    visible_at_tip_ = false;
+    earliest_snapshot_iter_ = snapshots_->begin();
+    earliest_snapshot_ = snapshots_->at(0);
+    latest_snapshot_ = snapshots_->back();
+  }
 #ifndef NDEBUG
   // findEarliestVisibleSnapshot assumes this ordering.
   for (size_t i = 1; i < snapshots_->size(); ++i) {
@@ -167,7 +173,7 @@ void CompactionIterator::Next() {
       current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
       key_ = current_key_.GetInternalKey();
       ikey_.user_key = current_key_.GetUserKey();
-      validity_info_.SetValid(ValidContext::kMerge1);
+      valid_ = true;
     } else {
       // We consumed all pinned merge operands, release pinned iterators
       pinned_iters_mgr_.ReleasePinnedData();
@@ -185,7 +191,7 @@ void CompactionIterator::Next() {
     NextFromInput();
   }
 
-  if (Valid()) {
+  if (valid_) {
     // Record that we've outputted a record for the current key.
     has_outputted_key_ = true;
   }
@@ -222,6 +228,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
   {
     StopWatchNano timer(clock_, report_detailed_time_);
     if (kTypeBlobIndex == ikey_.type) {
+      blob_value_.Reset();
       filter = compaction_filter_->FilterBlobByKey(
           level_, filter_key, &compaction_filter_value_,
           compaction_filter_skip_until_.rep());
@@ -230,7 +237,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
         if (compaction_ == nullptr) {
           status_ =
               Status::Corruption("Unexpected blob index outside of compaction");
-          validity_info_.Invalidate();
+          valid_ = false;
           return false;
         }
 
@@ -245,7 +252,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
         Status s = blob_index.DecodeFrom(value_);
         if (!s.ok()) {
           status_ = s;
-          validity_info_.Invalidate();
+          valid_ = false;
           return false;
         }
 
@@ -263,7 +270,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
                                      &bytes_read);
         if (!s.ok()) {
           status_ = s;
-          validity_info_.Invalidate();
+          valid_ = false;
           return false;
         }
 
@@ -287,7 +294,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
     // Should not reach here, since FilterV2 should never return kUndetermined.
     status_ =
         Status::NotSupported("FilterV2() should never return kUndetermined");
-    validity_info_.Invalidate();
+    valid_ = false;
     return false;
   }
 
@@ -336,7 +343,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
       status_ = Status::NotSupported(
           "Only stacked BlobDB's internal compaction filter can return "
           "kChangeBlobIndex.");
-      validity_info_.Invalidate();
+      valid_ = false;
       return false;
     }
     if (ikey_.type == kTypeValue) {
@@ -349,7 +356,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
     if (!compaction_filter_->IsStackedBlobDbInternalCompactionFilter()) {
       status_ = Status::NotSupported(
           "CompactionFilter for integrated BlobDB should not return kIOError");
-      validity_info_.Invalidate();
+      valid_ = false;
       return false;
     }
     status_ = Status::IOError("Failed to access blob during compaction filter");
@@ -360,13 +367,12 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
 
 void CompactionIterator::NextFromInput() {
   at_next_ = false;
-  validity_info_.Invalidate();
+  valid_ = false;
 
-  while (!Valid() && input_.Valid() && !IsPausingManualCompaction() &&
+  while (!valid_ && input_.Valid() && !IsPausingManualCompaction() &&
          !IsShuttingDown()) {
     key_ = input_.key();
     value_ = input_.value();
-    blob_value_.Reset();
     iter_stats_.num_input_records++;
 
     Status pik_status = ParseInternalKey(key_, &ikey_, allow_data_in_errors_);
@@ -383,7 +389,7 @@ void CompactionIterator::NextFromInput() {
       has_current_user_key_ = false;
       current_user_key_sequence_ = kMaxSequenceNumber;
       current_user_key_snapshot_ = 0;
-      validity_info_.SetValid(ValidContext::kParseKeyError);
+      valid_ = true;
       break;
     }
     TEST_SYNC_POINT_CALLBACK("CompactionIterator:ProcessKV", &ikey_);
@@ -496,7 +502,7 @@ void CompactionIterator::NextFromInput() {
 
     if (UNLIKELY(!current_key_committed_)) {
       assert(snapshot_checker_ != nullptr);
-      validity_info_.SetValid(ValidContext::kCurrentKeyUncommitted);
+      valid_ = true;
       break;
     }
 
@@ -539,7 +545,7 @@ void CompactionIterator::NextFromInput() {
       }
 
       value_.clear();
-      validity_info_.SetValid(ValidContext::kKeepSDAndClearPut);
+      valid_ = true;
       clear_and_output_next_key_ = false;
     } else if (ikey_.type == kTypeSingleDeletion) {
       // We can compact out a SingleDelete if:
@@ -663,7 +669,7 @@ void CompactionIterator::NextFromInput() {
             ++iter_stats_.num_single_del_mismatch;
             if (enforce_single_del_contracts_) {
               ROCKS_LOG_ERROR(info_log_, "%s", oss.str().c_str());
-              validity_info_.Invalidate();
+              valid_ = false;
               status_ = Status::Corruption(oss.str());
               return;
             }
@@ -672,7 +678,7 @@ void CompactionIterator::NextFromInput() {
             // We cannot drop the SingleDelete as timestamp is enabled, and
             // timestamp of this key is greater than or equal to
             // *full_history_ts_low_. We will output the SingleDelete.
-            validity_info_.SetValid(ValidContext::kKeepTsHistory);
+            valid_ = true;
           } else if (has_outputted_key_ ||
                      DefinitelyInSnapshot(ikey_.sequence,
                                           earliest_write_conflict_snapshot_) ||
@@ -707,7 +713,7 @@ void CompactionIterator::NextFromInput() {
             // outputted on the next iteration.)
 
             // Setting valid_ to true will output the current SingleDelete
-            validity_info_.SetValid(ValidContext::kKeepSDForConflictCheck);
+            valid_ = true;
 
             // Set up the Put to be outputted in the next iteration.
             // (Optimization 3).
@@ -719,7 +725,7 @@ void CompactionIterator::NextFromInput() {
         } else {
           // We hit the next snapshot without hitting a put, so the iterator
           // returns the single delete.
-          validity_info_.SetValid(ValidContext::kKeepSDForSnapshot);
+          valid_ = true;
           TEST_SYNC_POINT_CALLBACK(
               "CompactionIterator::NextFromInput:SingleDelete:3",
               const_cast<Compaction*>(c));
@@ -752,11 +758,11 @@ void CompactionIterator::NextFromInput() {
           assert(bottommost_level_);
         } else {
           // Output SingleDelete
-          validity_info_.SetValid(ValidContext::kKeepSD);
+          valid_ = true;
         }
       }
 
-      if (Valid()) {
+      if (valid_) {
         at_next_ = true;
       }
     } else if (last_snapshot == current_user_key_snapshot_ ||
@@ -855,7 +861,7 @@ void CompactionIterator::NextFromInput() {
           (ParseInternalKey(input_.key(), &next_ikey, allow_data_in_errors_)
                .ok()) &&
           cmp_->EqualWithoutTimestamp(ikey_.user_key, next_ikey.user_key)) {
-        validity_info_.SetValid(ValidContext::kKeepDel);
+        valid_ = true;
         at_next_ = true;
       }
     } else if (ikey_.type == kTypeMerge) {
@@ -899,7 +905,7 @@ void CompactionIterator::NextFromInput() {
         current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
         key_ = current_key_.GetInternalKey();
         ikey_.user_key = current_key_.GetUserKey();
-        validity_info_.SetValid(ValidContext::kMerge2);
+        valid_ = true;
       } else {
         // all merge operands were filtered out. reset the user key, since the
         // batch consumed by the merge operator should not shadow any keys
@@ -921,7 +927,7 @@ void CompactionIterator::NextFromInput() {
         ++iter_stats_.num_record_drop_range_del;
         AdvanceInputIter();
       } else {
-        validity_info_.SetValid(ValidContext::kNewUserKey);
+        valid_ = true;
       }
     }
 
@@ -930,18 +936,13 @@ void CompactionIterator::NextFromInput() {
     }
   }
 
-  if (!Valid() && IsShuttingDown()) {
+  if (!valid_ && IsShuttingDown()) {
     status_ = Status::ShutdownInProgress();
   }
 
   if (IsPausingManualCompaction()) {
     status_ = Status::Incomplete(Status::SubCode::kManualCompactionPaused);
   }
-
-  // Propagate corruption status from memtable itereator
-  if (!input_.Valid() && input_.status().IsCorruption()) {
-    status_ = input_.status();
-  }
 }
 
 bool CompactionIterator::ExtractLargeValueIfNeededImpl() {
@@ -954,7 +955,7 @@ bool CompactionIterator::ExtractLargeValueIfNeededImpl() {
 
   if (!s.ok()) {
     status_ = s;
-    validity_info_.Invalidate();
+    valid_ = false;
 
     return false;
   }
@@ -999,7 +1000,7 @@ void CompactionIterator::GarbageCollectBlobIfNeeded() {
 
       if (!s.ok()) {
         status_ = s;
-        validity_info_.Invalidate();
+        valid_ = false;
 
         return;
       }
@@ -1025,7 +1026,7 @@ void CompactionIterator::GarbageCollectBlobIfNeeded() {
 
       if (!s.ok()) {
         status_ = s;
-        validity_info_.Invalidate();
+        valid_ = false;
 
         return;
       }
@@ -1058,14 +1059,14 @@ void CompactionIterator::GarbageCollectBlobIfNeeded() {
     if (blob_decision == CompactionFilter::BlobDecision::kCorruption) {
       status_ =
           Status::Corruption("Corrupted blob reference encountered during GC");
-      validity_info_.Invalidate();
+      valid_ = false;
 
       return;
     }
 
     if (blob_decision == CompactionFilter::BlobDecision::kIOError) {
       status_ = Status::IOError("Could not relocate blob during GC");
-      validity_info_.Invalidate();
+      valid_ = false;
 
       return;
     }
@@ -1086,9 +1087,7 @@ void CompactionIterator::DecideOutputLevel() {
   TEST_SYNC_POINT_CALLBACK("CompactionIterator::PrepareOutput.context",
                            &context);
   output_to_penultimate_level_ = context.output_to_penultimate_level;
-#else
-  output_to_penultimate_level_ = false;
-#endif  // NDEBUG
+#endif /* !NDEBUG */
 
   // if the key is newer than the cutoff sequence or within the earliest
   // snapshot, it should output to the penultimate level.
@@ -1108,13 +1107,13 @@ void CompactionIterator::DecideOutputLevel() {
         compaction_->WithinPenultimateLevelOutputRange(ikey_.user_key);
     if (!safe_to_penultimate_level) {
       output_to_penultimate_level_ = false;
-      // It could happen when disable/enable `last_level_temperature` while
-      // holding a snapshot. When `last_level_temperature` is not set
+      // It could happen when disable/enable `bottommost_temperature` while
+      // holding a snapshot. When `bottommost_temperature` is not set
       // (==kUnknown), the data newer than any snapshot is pushed to the last
       // level, but when the per_key_placement feature is enabled on the fly,
       // the data later than the snapshot has to be moved to the penultimate
       // level, which may or may not be safe. So the user needs to make sure all
-      // snapshot is released before enabling `last_level_temperature` feature
+      // snapshot is released before enabling `bottommost_temperature` feature
       // We will migrate the feature to `last_level_temperature` and maybe make
       // it not dynamically changeable.
       if (ikey_.sequence > earliest_snapshot_) {
@@ -1127,7 +1126,7 @@ void CompactionIterator::DecideOutputLevel() {
 }
 
 void CompactionIterator::PrepareOutput() {
-  if (Valid()) {
+  if (valid_) {
     if (ikey_.type == kTypeValue) {
       ExtractLargeValueIfNeeded();
     } else if (ikey_.type == kTypeBlobIndex) {
@@ -1149,7 +1148,7 @@ void CompactionIterator::PrepareOutput() {
     //
     // Can we do the same for levels above bottom level as long as
     // KeyNotExistsBeyondOutputLevel() return true?
-    if (Valid() && compaction_ != nullptr &&
+    if (valid_ && compaction_ != nullptr &&
         !compaction_->allow_ingest_behind() && bottommost_level_ &&
         DefinitelyInSnapshot(ikey_.sequence, earliest_snapshot_) &&
         ikey_.type != kTypeMerge && current_key_committed_ &&
@@ -1163,14 +1162,13 @@ void CompactionIterator::PrepareOutput() {
             "earliest_snapshot %" PRIu64
             ", earliest_write_conflict_snapshot %" PRIu64
             " job_snapshot %" PRIu64
-            ". timestamp_size: %d full_history_ts_low_ %s. validity %x",
+            ". timestamp_size: %d full_history_ts_low_ %s",
             ikey_.DebugString(allow_data_in_errors_, true).c_str(),
             earliest_snapshot_, earliest_write_conflict_snapshot_,
             job_snapshot_, static_cast<int>(timestamp_size_),
             full_history_ts_low_ != nullptr
                 ? Slice(*full_history_ts_low_).ToString(true).c_str()
-                : "null",
-            validity_info_.rep);
+                : "null");
         assert(false);
       }
       ikey_.sequence = 0;

db/compaction/compaction_iterator.h

@@ -235,7 +235,7 @@ class CompactionIterator {
   const Slice& value() const { return value_; }
   const Status& status() const { return status_; }
   const ParsedInternalKey& ikey() const { return ikey_; }
-  inline bool Valid() const { return validity_info_.IsValid(); }
+  bool Valid() const { return valid_; }
   const Slice& user_key() const { return current_user_key_; }
   const CompactionIterationStats& iter_stats() const { return iter_stats_; }
   uint64_t num_input_entry_scanned() const { return input_.num_itered(); }
@@ -332,26 +332,29 @@ class CompactionIterator {
   // earliest visible snapshot of an older value.
   // See WritePreparedTransactionTest::ReleaseSnapshotDuringCompaction3.
   std::unordered_set<SequenceNumber> released_snapshots_;
+  std::vector<SequenceNumber>::const_iterator earliest_snapshot_iter_;
   const SequenceNumber earliest_write_conflict_snapshot_;
   const SequenceNumber job_snapshot_;
   const SnapshotChecker* const snapshot_checker_;
   Env* env_;
   SystemClock* clock_;
-  const bool report_detailed_time_;
-  const bool expect_valid_internal_key_;
+  bool report_detailed_time_;
+  bool expect_valid_internal_key_;
   CompactionRangeDelAggregator* range_del_agg_;
   BlobFileBuilder* blob_file_builder_;
   std::unique_ptr<CompactionProxy> compaction_;
   const CompactionFilter* compaction_filter_;
   const std::atomic<bool>* shutting_down_;
   const std::atomic<bool>& manual_compaction_canceled_;
-  const bool bottommost_level_;
-  const bool visible_at_tip_;
-  const SequenceNumber earliest_snapshot_;
+  bool bottommost_level_;
+  bool valid_ = false;
+  bool visible_at_tip_;
+  SequenceNumber earliest_snapshot_;
+  SequenceNumber latest_snapshot_;
 
   std::shared_ptr<Logger> info_log_;
 
-  const bool allow_data_in_errors_;
+  bool allow_data_in_errors_;
 
   const bool enforce_single_del_contracts_;
 
@@ -367,33 +370,8 @@ class CompactionIterator {
 
   // State
   //
-  enum ValidContext : uint8_t {
-    kMerge1 = 0,
-    kMerge2 = 1,
-    kParseKeyError = 2,
-    kCurrentKeyUncommitted = 3,
-    kKeepSDAndClearPut = 4,
-    kKeepTsHistory = 5,
-    kKeepSDForConflictCheck = 6,
-    kKeepSDForSnapshot = 7,
-    kKeepSD = 8,
-    kKeepDel = 9,
-    kNewUserKey = 10,
-  };
-
-  struct ValidityInfo {
-    inline bool IsValid() const { return rep & 1; }
-    ValidContext GetContext() const {
-      return static_cast<ValidContext>(rep >> 1);
-    }
-    inline void SetValid(uint8_t ctx) { rep = (ctx << 1) | 1; }
-    inline void Invalidate() { rep = 0; }
-
-    uint8_t rep{0};
-  } validity_info_;
-
   // Points to a copy of the current compaction iterator output (current_key_)
-  // if valid.
+  // if valid_.
   Slice key_;
   // Points to the value in the underlying iterator that corresponds to the
   // current output.

db/compaction/compaction_job.cc

@@ -12,7 +12,6 @@
 #include <algorithm>
 #include <cinttypes>
 #include <memory>
-#include <optional>
 #include <set>
 #include <utility>
 #include <vector>
@@ -31,7 +30,6 @@
 #include "db/log_writer.h"
 #include "db/merge_helper.h"
 #include "db/range_del_aggregator.h"
-#include "db/version_edit.h"
 #include "db/version_set.h"
 #include "file/filename.h"
 #include "file/read_write_util.h"
@@ -46,7 +44,6 @@
 #include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
-#include "rocksdb/options.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/status.h"
 #include "rocksdb/table.h"
@@ -123,8 +120,7 @@ CompactionJob::CompactionJob(
     const std::atomic<bool>& manual_compaction_canceled,
     const std::string& db_id, const std::string& db_session_id,
     std::string full_history_ts_low, std::string trim_ts,
-    BlobFileCompletionCallback* blob_callback, int* bg_compaction_scheduled,
-    int* bg_bottom_compaction_scheduled)
+    BlobFileCompletionCallback* blob_callback)
     : compact_(new CompactionState(compaction)),
       compaction_stats_(compaction->compaction_reason(), 1),
       db_options_(db_options),
@@ -163,13 +159,9 @@ CompactionJob::CompactionJob(
       thread_pri_(thread_pri),
       full_history_ts_low_(std::move(full_history_ts_low)),
       trim_ts_(std::move(trim_ts)),
-      blob_callback_(blob_callback),
-      extra_num_subcompaction_threads_reserved_(0),
-      bg_compaction_scheduled_(bg_compaction_scheduled),
-      bg_bottom_compaction_scheduled_(bg_bottom_compaction_scheduled) {
+      blob_callback_(blob_callback) {
   assert(compaction_job_stats_ != nullptr);
   assert(log_buffer_ != nullptr);
-
   const auto* cfd = compact_->compaction->column_family_data();
   ThreadStatusUtil::SetColumnFamily(cfd, cfd->ioptions()->env,
                                     db_options_.enable_thread_tracking);
@@ -240,27 +232,24 @@ void CompactionJob::Prepare() {
   bottommost_level_ = c->bottommost_level();
 
   if (c->ShouldFormSubcompactions()) {
-    StopWatch sw(db_options_.clock, stats_, SUBCOMPACTION_SETUP_TIME);
-    GenSubcompactionBoundaries();
-  }
-  if (boundaries_.size() > 1) {
+    {
+      StopWatch sw(db_options_.clock, stats_, SUBCOMPACTION_SETUP_TIME);
+      GenSubcompactionBoundaries();
+    }
+
     for (size_t i = 0; i <= boundaries_.size(); i++) {
-      compact_->sub_compact_states.emplace_back(
-          c, (i != 0) ? std::optional<Slice>(boundaries_[i - 1]) : std::nullopt,
-          (i != boundaries_.size()) ? std::optional<Slice>(boundaries_[i])
-                                    : std::nullopt,
-          static_cast<uint32_t>(i));
-      // assert to validate that boundaries don't have same user keys (without
-      // timestamp part).
-      assert(i == 0 || i == boundaries_.size() ||
-             cfd->user_comparator()->CompareWithoutTimestamp(
-                 boundaries_[i - 1], boundaries_[i]) < 0);
+      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,
+                                                static_cast<uint32_t>(i));
     }
     RecordInHistogram(stats_, NUM_SUBCOMPACTIONS_SCHEDULED,
                       compact_->sub_compact_states.size());
   } else {
-    compact_->sub_compact_states.emplace_back(c, std::nullopt, std::nullopt,
-                                              /*sub_job_id*/ 0);
+    constexpr Slice* start = nullptr;
+    constexpr Slice* end = nullptr;
+
+    compact_->sub_compact_states.emplace_back(c, start, end, /*sub_job_id*/ 0);
   }
 
   if (c->immutable_options()->preclude_last_level_data_seconds > 0) {
@@ -301,101 +290,6 @@ void CompactionJob::Prepare() {
   }
 }
 
-uint64_t CompactionJob::GetSubcompactionsLimit() {
-  return extra_num_subcompaction_threads_reserved_ +
-         std::max(
-             std::uint64_t(1),
-             static_cast<uint64_t>(compact_->compaction->max_subcompactions()));
-}
-
-void CompactionJob::AcquireSubcompactionResources(
-    int num_extra_required_subcompactions) {
-  TEST_SYNC_POINT("CompactionJob::AcquireSubcompactionResources:0");
-  TEST_SYNC_POINT("CompactionJob::AcquireSubcompactionResources:1");
-  int max_db_compactions =
-      DBImpl::GetBGJobLimits(
-          mutable_db_options_copy_.max_background_flushes,
-          mutable_db_options_copy_.max_background_compactions,
-          mutable_db_options_copy_.max_background_jobs,
-          versions_->GetColumnFamilySet()
-              ->write_controller()
-              ->NeedSpeedupCompaction())
-          .max_compactions;
-  InstrumentedMutexLock l(db_mutex_);
-  // Apply min function first since We need to compute the extra subcompaction
-  // against compaction limits. And then try to reserve threads for extra
-  // subcompactions. The actual number of reserved threads could be less than
-  // the desired number.
-  int available_bg_compactions_against_db_limit =
-      std::max(max_db_compactions - *bg_compaction_scheduled_ -
-                   *bg_bottom_compaction_scheduled_,
-               0);
-  // Reservation only supports backgrdoun threads of which the priority is
-  // between BOTTOM and HIGH. Need to degrade the priority to HIGH if the
-  // origin thread_pri_ is higher than that. Similar to ReleaseThreads().
-  extra_num_subcompaction_threads_reserved_ =
-      env_->ReserveThreads(std::min(num_extra_required_subcompactions,
-                                    available_bg_compactions_against_db_limit),
-                           std::min(thread_pri_, Env::Priority::HIGH));
-
-  // Update bg_compaction_scheduled_ or bg_bottom_compaction_scheduled_
-  // depending on if this compaction has the bottommost priority
-  if (thread_pri_ == Env::Priority::BOTTOM) {
-    *bg_bottom_compaction_scheduled_ +=
-        extra_num_subcompaction_threads_reserved_;
-  } else {
-    *bg_compaction_scheduled_ += extra_num_subcompaction_threads_reserved_;
-  }
-}
-
-void CompactionJob::ShrinkSubcompactionResources(uint64_t num_extra_resources) {
-  // Do nothing when we have zero resources to shrink
-  if (num_extra_resources == 0) return;
-  db_mutex_->Lock();
-  // We cannot release threads more than what we reserved before
-  int extra_num_subcompaction_threads_released = env_->ReleaseThreads(
-      (int)num_extra_resources, std::min(thread_pri_, Env::Priority::HIGH));
-  // Update the number of reserved threads and the number of background
-  // scheduled compactions for this compaction job
-  extra_num_subcompaction_threads_reserved_ -=
-      extra_num_subcompaction_threads_released;
-  // TODO (zichen): design a test case with new subcompaction partitioning
-  // when the number of actual partitions is less than the number of planned
-  // partitions
-  assert(extra_num_subcompaction_threads_released == (int)num_extra_resources);
-  // Update bg_compaction_scheduled_ or bg_bottom_compaction_scheduled_
-  // depending on if this compaction has the bottommost priority
-  if (thread_pri_ == Env::Priority::BOTTOM) {
-    *bg_bottom_compaction_scheduled_ -=
-        extra_num_subcompaction_threads_released;
-  } else {
-    *bg_compaction_scheduled_ -= extra_num_subcompaction_threads_released;
-  }
-  db_mutex_->Unlock();
-  TEST_SYNC_POINT("CompactionJob::ShrinkSubcompactionResources:0");
-}
-
-void CompactionJob::ReleaseSubcompactionResources() {
-  if (extra_num_subcompaction_threads_reserved_ == 0) {
-    return;
-  }
-  {
-    InstrumentedMutexLock l(db_mutex_);
-    // The number of reserved threads becomes larger than 0 only if the
-    // compaction prioity is round robin and there is no sufficient
-    // sub-compactions available
-
-    // The scheduled compaction must be no less than 1 + extra number
-    // subcompactions using acquired resources since this compaction job has not
-    // finished yet
-    assert(*bg_bottom_compaction_scheduled_ >=
-               1 + extra_num_subcompaction_threads_reserved_ ||
-           *bg_compaction_scheduled_ >=
-               1 + extra_num_subcompaction_threads_reserved_);
-  }
-  ShrinkSubcompactionResources(extra_num_subcompaction_threads_reserved_);
-}
-
 struct RangeWithSize {
   Range range;
   uint64_t size;
@@ -405,51 +299,15 @@ struct RangeWithSize {
 };
 
 void CompactionJob::GenSubcompactionBoundaries() {
-  // The goal is to find some boundary keys so that we can evenly partition
-  // the compaction input data into max_subcompactions ranges.
-  // For every input file, we ask TableReader to estimate 128 anchor points
-  // that evenly partition the input file into 128 ranges and the range
-  // sizes. This can be calculated by scanning index blocks of the file.
-  // Once we have the anchor points for all the input files, we merge them
-  // together and try to find keys dividing ranges evenly.
-  // For example, if we have two input files, and each returns following
-  // ranges:
-  //   File1: (a1, 1000), (b1, 1200), (c1, 1100)
-  //   File2: (a2, 1100), (b2, 1000), (c2, 1000)
-  // We total sort the keys to following:
-  //  (a1, 1000), (a2, 1100), (b1, 1200), (b2, 1000), (c1, 1100), (c2, 1000)
-  // We calculate the total size by adding up all ranges' size, which is 6400.
-  // If we would like to partition into 2 subcompactions, the target of the
-  // range size is 3200. Based on the size, we take "b1" as the partition key
-  // since the first three ranges would hit 3200.
-  //
-  // Note that the ranges are actually overlapping. For example, in the example
-  // above, the range ending with "b1" is overlapping with the range ending with
-  // "b2". So the size 1000+1100+1200 is an underestimation of data size up to
-  // "b1". In extreme cases where we only compact N L0 files, a range can
-  // overlap with N-1 other ranges. Since we requested a relatively large number
-  // (128) of ranges from each input files, even N range overlapping would
-  // cause relatively small inaccuracy.
-
   auto* c = compact_->compaction;
-  if (c->max_subcompactions() <= 1 &&
-      !(c->immutable_options()->compaction_pri == kRoundRobin &&
-        c->immutable_options()->compaction_style == kCompactionStyleLevel)) {
-    return;
-  }
   auto* cfd = c->column_family_data();
   const Comparator* cfd_comparator = cfd->user_comparator();
-  const InternalKeyComparator& icomp = cfd->internal_comparator();
-
-  auto* v = compact_->compaction->input_version();
-  int base_level = v->storage_info()->base_level();
-  InstrumentedMutexUnlock unlock_guard(db_mutex_);
-
-  uint64_t total_size = 0;
-  std::vector<TableReader::Anchor> all_anchors;
+  std::vector<Slice> bounds;
   int start_lvl = c->start_level();
   int out_lvl = c->output_level();
 
+  // Add the starting and/or ending key of certain input files as a potential
+  // boundary
   for (size_t lvl_idx = 0; lvl_idx < c->num_input_levels(); lvl_idx++) {
     int lvl = c->level(lvl_idx);
     if (lvl >= start_lvl && lvl <= out_lvl) {
@@ -460,115 +318,108 @@ void CompactionJob::GenSubcompactionBoundaries() {
         continue;
       }
 
-      for (size_t i = 0; i < num_files; i++) {
-        FileMetaData* f = flevel->files[i].file_metadata;
-        std::vector<TableReader::Anchor> my_anchors;
-        Status s = cfd->table_cache()->ApproximateKeyAnchors(
-            ReadOptions(), icomp, *f, my_anchors);
-        if (!s.ok() || my_anchors.empty()) {
-          my_anchors.emplace_back(f->largest.user_key(), f->fd.GetFileSize());
+      if (lvl == 0) {
+        // For level 0 add the starting and ending key of each file since the
+        // files may have greatly differing key ranges (not range-partitioned)
+        for (size_t i = 0; i < num_files; i++) {
+          bounds.emplace_back(flevel->files[i].smallest_key);
+          bounds.emplace_back(flevel->files[i].largest_key);
         }
-        for (auto& ac : my_anchors) {
-          // Can be optimize to avoid this loop.
-          total_size += ac.range_size;
+      } else {
+        // For all other levels add the smallest/largest key in the level to
+        // encompass the range covered by that level
+        bounds.emplace_back(flevel->files[0].smallest_key);
+        bounds.emplace_back(flevel->files[num_files - 1].largest_key);
+        if (lvl == out_lvl) {
+          // For the last level include the starting keys of all files since
+          // the last level is the largest and probably has the widest key
+          // range. Since it's range partitioned, the ending key of one file
+          // and the starting key of the next are very close (or identical).
+          for (size_t i = 1; i < num_files; i++) {
+            bounds.emplace_back(flevel->files[i].smallest_key);
+          }
         }
-
-        all_anchors.insert(all_anchors.end(), my_anchors.begin(),
-                           my_anchors.end());
       }
     }
   }
-  // Here we total sort all the anchor points across all files and go through
-  // them in the sorted order to find partitioning boundaries.
-  // Not the most efficient implementation. A much more efficient algorithm
-  // probably exists. But they are more complex. If performance turns out to
-  // be a problem, we can optimize.
-  std::sort(
-      all_anchors.begin(), all_anchors.end(),
-      [cfd_comparator](TableReader::Anchor& a, TableReader::Anchor& b) -> bool {
-        return cfd_comparator->CompareWithoutTimestamp(a.user_key, b.user_key) <
-               0;
-      });
 
-  // Remove duplicated entries from boundaries.
-  all_anchors.erase(
-      std::unique(all_anchors.begin(), all_anchors.end(),
-                  [cfd_comparator](TableReader::Anchor& a,
-                                   TableReader::Anchor& b) -> bool {
-                    return cfd_comparator->CompareWithoutTimestamp(
-                               a.user_key, b.user_key) == 0;
+  std::sort(bounds.begin(), bounds.end(),
+            [cfd_comparator](const Slice& a, const Slice& b) -> bool {
+              return cfd_comparator->Compare(ExtractUserKey(a),
+                                             ExtractUserKey(b)) < 0;
+            });
+  // Remove duplicated entries from bounds
+  bounds.erase(
+      std::unique(bounds.begin(), bounds.end(),
+                  [cfd_comparator](const Slice& a, const Slice& b) -> bool {
+                    return cfd_comparator->Compare(ExtractUserKey(a),
+                                                   ExtractUserKey(b)) == 0;
                   }),
-      all_anchors.end());
+      bounds.end());
 
-  // Get the number of planned subcompactions, may update reserve threads
-  // and update extra_num_subcompaction_threads_reserved_ for round-robin
-  uint64_t num_planned_subcompactions;
-  if (c->immutable_options()->compaction_pri == kRoundRobin &&
-      c->immutable_options()->compaction_style == kCompactionStyleLevel) {
-    // For round-robin compaction prioity, we need to employ more
-    // subcompactions (may exceed the max_subcompaction limit). The extra
-    // subcompactions will be executed using reserved threads and taken into
-    // account bg_compaction_scheduled or bg_bottom_compaction_scheduled.
+  // Combine consecutive pairs of boundaries into ranges with an approximate
+  // size of data covered by keys in that range
+  uint64_t sum = 0;
+  std::vector<RangeWithSize> ranges;
+  // Get input version from CompactionState since it's already referenced
+  // earlier in SetInputVersioCompaction::SetInputVersion and will not change
+  // when db_mutex_ is released below
+  auto* v = compact_->compaction->input_version();
+  for (auto it = bounds.begin();;) {
+    const Slice a = *it;
+    ++it;
 
-    // Initialized by the number of input files
-    num_planned_subcompactions = static_cast<uint64_t>(c->num_input_files(0));
-    uint64_t max_subcompactions_limit = GetSubcompactionsLimit();
-    if (max_subcompactions_limit < num_planned_subcompactions) {
-      // Assert two pointers are not empty so that we can use extra
-      // subcompactions against db compaction limits
-      assert(bg_bottom_compaction_scheduled_ != nullptr);
-      assert(bg_compaction_scheduled_ != nullptr);
-      // Reserve resources when max_subcompaction is not sufficient
-      AcquireSubcompactionResources(
-          (int)(num_planned_subcompactions - max_subcompactions_limit));
-      // Subcompactions limit changes after acquiring additional resources.
-      // Need to call GetSubcompactionsLimit() again to update the number
-      // of planned subcompactions
-      num_planned_subcompactions =
-          std::min(num_planned_subcompactions, GetSubcompactionsLimit());
-    } else {
-      num_planned_subcompactions = max_subcompactions_limit;
+    if (it == bounds.end()) {
+      break;
     }
-  } else {
-    num_planned_subcompactions = GetSubcompactionsLimit();
+
+    const Slice b = *it;
+
+    // ApproximateSize could potentially create table reader iterator to seek
+    // to the index block and may incur I/O cost in the process. Unlock db
+    // mutex to reduce contention
+    db_mutex_->Unlock();
+    uint64_t size = versions_->ApproximateSize(SizeApproximationOptions(), v, a,
+                                               b, start_lvl, out_lvl + 1,
+                                               TableReaderCaller::kCompaction);
+    db_mutex_->Lock();
+    ranges.emplace_back(a, b, size);
+    sum += size;
   }
 
-  TEST_SYNC_POINT_CALLBACK("CompactionJob::GenSubcompactionBoundaries:0",
-                           &num_planned_subcompactions);
-  if (num_planned_subcompactions == 1) return;
-
   // Group the ranges into subcompactions
-  uint64_t target_range_size = std::max(
-      total_size / num_planned_subcompactions,
+  const double min_file_fill_percent = 4.0 / 5;
+  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));
+          c->immutable_options()->level_compaction_dynamic_level_bytes)));
+  uint64_t subcompactions =
+      std::min({static_cast<uint64_t>(ranges.size()),
+                static_cast<uint64_t>(c->max_subcompactions()),
+                max_output_files});
 
-  if (target_range_size >= total_size) {
-    return;
-  }
-
-  uint64_t next_threshold = target_range_size;
-  uint64_t cumulative_size = 0;
-  uint64_t num_actual_subcompactions = 1U;
-  for (TableReader::Anchor& anchor : all_anchors) {
-    cumulative_size += anchor.range_size;
-    if (cumulative_size > next_threshold) {
-      next_threshold += target_range_size;
-      num_actual_subcompactions++;
-      boundaries_.push_back(anchor.user_key);
-    }
-    if (num_actual_subcompactions == num_planned_subcompactions) {
-      break;
+  if (subcompactions > 1) {
+    double mean = sum * 1.0 / subcompactions;
+    // Greedily add ranges to the subcompaction until the sum of the ranges'
+    // sizes becomes >= the expected mean size of a subcompaction
+    sum = 0;
+    for (size_t i = 0; i + 1 < ranges.size(); i++) {
+      sum += ranges[i].size;
+      if (subcompactions == 1) {
+        // If there's only one left to schedule then it goes to the end so no
+        // need to put an end boundary
+        continue;
+      }
+      if (sum >= mean) {
+        boundaries_.emplace_back(ExtractUserKey(ranges[i].range.limit));
+        subcompactions--;
+        sum = 0;
+      }
     }
   }
-  TEST_SYNC_POINT_CALLBACK("CompactionJob::GenSubcompactionBoundaries:1",
-                           &num_actual_subcompactions);
-  // Shrink extra subcompactions resources when extra resrouces are acquired
-  ShrinkSubcompactionResources(
-      std::min((int)(num_planned_subcompactions - num_actual_subcompactions),
-               extra_num_subcompaction_threads_reserved_));
 }
 
 Status CompactionJob::Run() {
@@ -731,7 +582,6 @@ Status CompactionJob::Run() {
     for (auto& thread : thread_pool) {
       thread.join();
     }
-
     for (const auto& state : compact_->sub_compact_states) {
       if (!state.status.ok()) {
         status = state.status;
@@ -740,10 +590,6 @@ Status CompactionJob::Run() {
     }
   }
 
-  ReleaseSubcompactionResources();
-  TEST_SYNC_POINT("CompactionJob::ReleaseSubcompactionResources:0");
-  TEST_SYNC_POINT("CompactionJob::ReleaseSubcompactionResources:1");
-
   TablePropertiesCollection tp;
   for (const auto& state : compact_->sub_compact_states) {
     for (const auto& output : state.GetOutputs()) {
@@ -1039,11 +885,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
 
   // TODO: since we already use C++17, should use
   // std::optional<const Slice> instead.
-  const std::optional<Slice> start = sub_compact->start;
-  const std::optional<Slice> end = sub_compact->end;
-
-  std::optional<Slice> start_without_ts;
-  std::optional<Slice> end_without_ts;
+  const Slice* const start = sub_compact->start;
+  const Slice* const end = sub_compact->end;
 
   ReadOptions read_options;
   read_options.verify_checksums = true;
@@ -1055,29 +898,21 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   // (b) CompactionFilter::Decision::kRemoveAndSkipUntil.
   read_options.total_order_seek = true;
 
-  // Remove the timestamps from boundaries because boundaries created in
-  // GenSubcompactionBoundaries doesn't strip away the timestamp.
-  size_t ts_sz = cfd->user_comparator()->timestamp_size();
-  if (start.has_value()) {
-    read_options.iterate_lower_bound = &start.value();
-    if (ts_sz > 0) {
-      start_without_ts = StripTimestampFromUserKey(start.value(), ts_sz);
-      read_options.iterate_lower_bound = &start_without_ts.value();
-    }
-  }
-  if (end.has_value()) {
-    read_options.iterate_upper_bound = &end.value();
-    if (ts_sz > 0) {
-      end_without_ts = StripTimestampFromUserKey(end.value(), ts_sz);
-      read_options.iterate_upper_bound = &end_without_ts.value();
-    }
-  }
+  // 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(versions_->MakeInputIterator(
       read_options, sub_compact->compaction, range_del_agg.get(),
-      file_options_for_read_, start, end));
+      file_options_for_read_,
+      (start == nullptr) ? std::optional<const Slice>{}
+                         : std::optional<const Slice>{*start},
+      (end == nullptr) ? std::optional<const Slice>{}
+                       : std::optional<const Slice>{*end}));
   InternalIterator* input = raw_input.get();
 
   IterKey start_ikey;
@@ -1085,42 +920,20 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   Slice start_slice;
   Slice end_slice;
 
-  static constexpr char kMaxTs[] =
-      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
-  Slice ts_slice;
-  std::string max_ts;
-  if (ts_sz > 0) {
-    if (ts_sz <= strlen(kMaxTs)) {
-      ts_slice = Slice(kMaxTs, ts_sz);
-    } else {
-      max_ts = std::string(ts_sz, '\xff');
-      ts_slice = Slice(max_ts);
-    }
-  }
-
-  if (start.has_value()) {
-    start_ikey.SetInternalKey(start.value(), kMaxSequenceNumber,
-                              kValueTypeForSeek);
-    if (ts_sz > 0) {
-      start_ikey.UpdateInternalKey(kMaxSequenceNumber, kValueTypeForSeek,
-                                   &ts_slice);
-    }
+  if (start) {
+    start_ikey.SetInternalKey(*start, kMaxSequenceNumber, kValueTypeForSeek);
     start_slice = start_ikey.GetInternalKey();
   }
-  if (end.has_value()) {
-    end_ikey.SetInternalKey(end.value(), kMaxSequenceNumber, kValueTypeForSeek);
-    if (ts_sz > 0) {
-      end_ikey.UpdateInternalKey(kMaxSequenceNumber, kValueTypeForSeek,
-                                 &ts_slice);
-    }
+  if (end) {
+    end_ikey.SetInternalKey(*end, kMaxSequenceNumber, kValueTypeForSeek);
     end_slice = end_ikey.GetInternalKey();
   }
 
   std::unique_ptr<InternalIterator> clip;
-  if (start.has_value() || end.has_value()) {
+  if (start || end) {
     clip = std::make_unique<ClippingIterator>(
-        raw_input.get(), start.has_value() ? &start_slice : nullptr,
-        end.has_value() ? &end_slice : nullptr, &cfd->internal_comparator());
+        raw_input.get(), start ? &start_slice : nullptr,
+        end ? &end_slice : nullptr, &cfd->internal_comparator());
     input = clip.get();
   }
 
@@ -1133,7 +946,7 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   }
 
   std::unique_ptr<InternalIterator> trim_history_iter;
-  if (ts_sz > 0 && !trim_ts_.empty()) {
+  if (cfd->user_comparator()->timestamp_size() > 0 && !trim_ts_.empty()) {
     trim_history_iter = std::make_unique<HistoryTrimmingIterator>(
         input, cfd->user_comparator(), trim_ts_);
     input = trim_history_iter.get();
@@ -1186,10 +999,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
           ? new BlobFileBuilder(
                 versions_, fs_.get(),
                 sub_compact->compaction->immutable_options(),
-                mutable_cf_options, &file_options_, db_id_, db_session_id_,
-                job_id_, cfd->GetID(), cfd->GetName(), Env::IOPriority::IO_LOW,
-                write_hint_, io_tracer_, blob_callback_,
-                BlobFileCreationReason::kCompaction, &blob_file_paths,
+                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->Current().GetBlobFileAdditionsPtr())
           : nullptr);
 
@@ -1221,6 +1034,13 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   // it only output to single level
   sub_compact->AssignRangeDelAggregator(std::move(range_del_agg));
 
+  if (c_iter->Valid() && sub_compact->compaction->output_level() != 0) {
+    sub_compact->FillFilesToCutForTtl();
+    // ShouldStopBefore() maintains state based on keys processed so far. The
+    // compaction loop always calls it on the "next" key, thus won't tell it the
+    // first key. So we do that here.
+    sub_compact->ShouldStopBefore(c_iter->key());
+  }
   const auto& c_iter_stats = c_iter->iter_stats();
 
   // define the open and close functions for the compaction files, which will be
@@ -1241,8 +1061,8 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     // Invariant: c_iter.status() is guaranteed to be OK if c_iter->Valid()
     // returns true.
 
-    assert(!end.has_value() || cfd->user_comparator()->Compare(
-                                   c_iter->user_key(), end.value()) < 0);
+    assert(!end ||
+           cfd->user_comparator()->Compare(c_iter->user_key(), *end) < 0);
 
     if (c_iter_stats.num_input_records % kRecordStatsEvery ==
         kRecordStatsEvery - 1) {
@@ -1269,6 +1089,16 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
     if (c_iter->status().IsManualCompactionPaused()) {
       break;
     }
+
+    // TODO: Support earlier file cut for the penultimate level files. Maybe by
+    //  moving `ShouldStopBefore()` to `CompactionOutputs` class. Currently
+    //  the penultimate level output is only cut when it reaches the size limit.
+    if (!sub_compact->Current().IsPendingClose() &&
+        sub_compact->compaction->output_level() != 0 &&
+        !sub_compact->compaction->SupportsPerKeyPlacement() &&
+        sub_compact->ShouldStopBefore(c_iter->key())) {
+      sub_compact->Current().SetPendingClose();
+    }
   }
 
   sub_compact->compaction_job_stats.num_blobs_read =
@@ -1450,12 +1280,10 @@ Status CompactionJob::FinishCompactionOutputFile(
     // output_to_penultimate_level compaction here, as it's only used to decide
     // if range dels could be dropped.
     if (outputs.HasRangeDel()) {
-      s = outputs.AddRangeDels(
-          sub_compact->start.has_value() ? &(sub_compact->start.value())
-                                         : nullptr,
-          sub_compact->end.has_value() ? &(sub_compact->end.value()) : nullptr,
-          range_del_out_stats, bottommost_level_, cfd->internal_comparator(),
-          earliest_snapshot, next_table_min_key);
+      s = outputs.AddRangeDels(sub_compact->start, sub_compact->end,
+                               range_del_out_stats, bottommost_level_,
+                               cfd->internal_comparator(), earliest_snapshot,
+                               next_table_min_key);
     }
     RecordDroppedKeys(range_del_out_stats, &sub_compact->compaction_job_stats);
     TEST_SYNC_POINT("CompactionJob::FinishCompactionOutputFile1");
@@ -1667,8 +1495,7 @@ Status CompactionJob::InstallCompactionResults(
     if (start_level > 0) {
       auto vstorage = compaction->input_version()->storage_info();
       edit->AddCompactCursor(start_level,
-                             vstorage->GetNextCompactCursor(
-                                 start_level, compaction->num_input_files(0)));
+                             vstorage->GetNextCompactCursor(start_level));
     }
   }
 
@@ -1722,16 +1549,13 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
                            &syncpoint_arg);
 #endif
 
-  // Pass temperature of the last level files to FileSystem.
+  // Pass temperature of botommost files to FileSystem.
   FileOptions fo_copy = file_options_;
   Temperature temperature = sub_compact->compaction->output_temperature();
-  // only set for the last level compaction and also it's not output to
-  // penultimate level (when preclude_last_level feature is enabled)
-  if (temperature == Temperature::kUnknown &&
-      sub_compact->compaction->is_last_level() &&
+  if (temperature == Temperature::kUnknown && bottommost_level_ &&
       !sub_compact->IsCurrentPenultimateLevel()) {
     temperature =
-        sub_compact->compaction->mutable_cf_options()->last_level_temperature;
+        sub_compact->compaction->mutable_cf_options()->bottommost_temperature;
   }
   fo_copy.temperature = temperature;
 
@@ -1771,16 +1595,16 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
   }
   uint64_t current_time = static_cast<uint64_t>(temp_current_time);
   InternalKey tmp_start, tmp_end;
-  if (sub_compact->start.has_value()) {
-    tmp_start.SetMinPossibleForUserKey(sub_compact->start.value());
+  if (sub_compact->start != nullptr) {
+    tmp_start.SetMinPossibleForUserKey(*(sub_compact->start));
   }
-  if (sub_compact->end.has_value()) {
-    tmp_end.SetMinPossibleForUserKey(sub_compact->end.value());
+  if (sub_compact->end != nullptr) {
+    tmp_end.SetMinPossibleForUserKey(*(sub_compact->end));
   }
   uint64_t oldest_ancester_time =
       sub_compact->compaction->MinInputFileOldestAncesterTime(
-          sub_compact->start.has_value() ? &tmp_start : nullptr,
-          sub_compact->end.has_value() ? &tmp_end : nullptr);
+          (sub_compact->start != nullptr) ? &tmp_start : nullptr,
+          (sub_compact->end != nullptr) ? &tmp_end : nullptr);
   if (oldest_ancester_time == std::numeric_limits<uint64_t>::max()) {
     oldest_ancester_time = current_time;
   }
@@ -1967,10 +1791,7 @@ void CompactionJob::LogCompaction() {
       stream.EndArray();
     }
     stream << "score" << compaction->score() << "input_data_size"
-           << compaction->CalculateTotalInputSize() << "oldest_snapshot_seqno"
-           << (existing_snapshots_.empty()
-                   ? int64_t{-1}  // Use -1 for "none"
-                   : static_cast<int64_t>(existing_snapshots_[0]));
+           << compaction->CalculateTotalInputSize();
   }
 }
 

db/compaction/compaction_job.h

@@ -164,9 +164,7 @@ class CompactionJob {
       const std::atomic<bool>& manual_compaction_canceled,
       const std::string& db_id = "", const std::string& db_session_id = "",
       std::string full_history_ts_low = "", std::string trim_ts = "",
-      BlobFileCompletionCallback* blob_callback = nullptr,
-      int* bg_compaction_scheduled = nullptr,
-      int* bg_bottom_compaction_scheduled = nullptr);
+      BlobFileCompletionCallback* blob_callback = nullptr);
 
   virtual ~CompactionJob();
 
@@ -227,26 +225,6 @@ class CompactionJob {
   // consecutive groups such that each group has a similar size.
   void GenSubcompactionBoundaries();
 
-  // Get the number of planned subcompactions based on max_subcompactions and
-  // extra reserved resources
-  uint64_t GetSubcompactionsLimit();
-
-  // Additional reserved threads are reserved and the number is stored in
-  // extra_num_subcompaction_threads_reserved__. For now, this happens only if
-  // the compaction priority is round-robin and max_subcompactions is not
-  // sufficient (extra resources may be needed)
-  void AcquireSubcompactionResources(int num_extra_required_subcompactions);
-
-  // Additional threads may be reserved during IncreaseSubcompactionResources()
-  // if num_actual_subcompactions is less than num_planned_subcompactions.
-  // Additional threads will be released and the bg_compaction_scheduled_ or
-  // bg_bottom_compaction_scheduled_ will be updated if they are used.
-  // DB Mutex lock is required.
-  void ShrinkSubcompactionResources(uint64_t num_extra_resources);
-
-  // Release all reserved threads and update the compaction limits.
-  void ReleaseSubcompactionResources();
-
   CompactionServiceJobStatus ProcessKeyValueCompactionWithCompactionService(
       SubcompactionState* sub_compact);
 
@@ -314,22 +292,13 @@ class CompactionJob {
   bool paranoid_file_checks_;
   bool measure_io_stats_;
   // Stores the Slices that designate the boundaries for each subcompaction
-  std::vector<std::string> boundaries_;
+  std::vector<Slice> boundaries_;
   Env::Priority thread_pri_;
   std::string full_history_ts_low_;
   std::string trim_ts_;
   BlobFileCompletionCallback* blob_callback_;
 
   uint64_t GetCompactionId(SubcompactionState* sub_compact) const;
-  // Stores the number of reserved threads in shared env_ for the number of
-  // extra subcompaction in kRoundRobin compaction priority
-  int extra_num_subcompaction_threads_reserved_;
-
-  // Stores the pointer to bg_compaction_scheduled_,
-  // bg_bottom_compaction_scheduled_ in DBImpl. Mutex is required when accessing
-  // or updating it.
-  int* bg_compaction_scheduled_;
-  int* bg_bottom_compaction_scheduled_;
 
   // Stores the sequence number to time mapping gathered from all input files
   // it also collects the smallest_seqno -> oldest_ancester_time from the SST.

db/compaction/compaction_job_test.cc

@@ -19,9 +19,7 @@
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/version_set.h"
-#include "file/random_access_file_reader.h"
 #include "file/writable_file_writer.h"
-#include "options/options_helper.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/convenience.h"
 #include "rocksdb/db.h"
@@ -196,15 +194,13 @@ class MockTestFileSystem : public FileSystemWrapper {
   Env::IOPriority write_io_priority_;
 };
 
-enum TableTypeForTest : uint8_t { kMockTable = 0, kBlockBasedTable = 1 };
-
 }  // namespace
 
 class CompactionJobTestBase : public testing::Test {
  protected:
   CompactionJobTestBase(std::string dbname, const Comparator* ucmp,
                         std::function<std::string(uint64_t)> encode_u64_ts,
-                        bool test_io_priority, TableTypeForTest table_type)
+                        bool test_io_priority)
       : dbname_(std::move(dbname)),
         ucmp_(ucmp),
         db_options_(),
@@ -221,8 +217,7 @@ class CompactionJobTestBase : public testing::Test {
         mock_table_factory_(new mock::MockTableFactory()),
         error_handler_(nullptr, db_options_, &mutex_),
         encode_u64_ts_(std::move(encode_u64_ts)),
-        test_io_priority_(test_io_priority),
-        table_type_(table_type) {
+        test_io_priority_(test_io_priority) {
     Env* base_env = Env::Default();
     EXPECT_OK(
         test::CreateEnvFromSystem(ConfigOptions(), &base_env, &env_guard_));
@@ -237,13 +232,11 @@ class CompactionJobTestBase : public testing::Test {
     db_options_.db_paths.emplace_back(dbname_,
                                       std::numeric_limits<uint64_t>::max());
     cf_options_.comparator = ucmp_;
-    if (table_type_ == TableTypeForTest::kBlockBasedTable) {
+    if (test_io_priority_) {
       BlockBasedTableOptions table_options;
       cf_options_.table_factory.reset(NewBlockBasedTableFactory(table_options));
-    } else if (table_type_ == TableTypeForTest::kMockTable) {
-      cf_options_.table_factory = mock_table_factory_;
     } else {
-      assert(false);
+      cf_options_.table_factory = mock_table_factory_;
     }
   }
 
@@ -365,15 +358,13 @@ class CompactionJobTestBase : public testing::Test {
 
     uint64_t file_number = versions_->NewFileNumber();
 
-    uint64_t file_size = 0;
-    if (table_type_ == TableTypeForTest::kBlockBasedTable) {
+    uint64_t file_size;
+    if (test_io_priority_) {
       CreateTable(GenerateFileName(file_number), contents, file_size);
-    } else if (table_type_ == TableTypeForTest::kMockTable) {
+    } else {
       file_size = 10;
       EXPECT_OK(mock_table_factory_->CreateMockTable(
           env_, GenerateFileName(file_number), std::move(contents)));
-    } else {
-      assert(false);
     }
 
     VersionEdit edit;
@@ -381,92 +372,16 @@ class CompactionJobTestBase : public testing::Test {
                  smallest_seqno, largest_seqno, false, Temperature::kUnknown,
                  oldest_blob_file_number, kUnknownOldestAncesterTime,
                  kUnknownFileCreationTime, kUnknownFileChecksum,
-                 kUnknownFileChecksumFuncName, kNullUniqueId64x2);
+                 kUnknownFileChecksumFuncName, kDisableUserTimestamp,
+                 kDisableUserTimestamp, kNullUniqueId64x2);
 
     mutex_.Lock();
     EXPECT_OK(
         versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
-                               mutable_cf_options_, &edit, &mutex_, nullptr));
+                               mutable_cf_options_, &edit, &mutex_));
     mutex_.Unlock();
   }
 
-  void VerifyTables(int output_level,
-                    const std::vector<mock::KVVector>& expected_results,
-                    std::vector<uint64_t> expected_oldest_blob_file_numbers) {
-    if (expected_results.empty()) {
-      ASSERT_EQ(compaction_job_stats_.num_output_files, 0U);
-      return;
-    }
-    int expected_output_file_num = 0;
-    for (const auto& e : expected_results) {
-      if (!e.empty()) {
-        ++expected_output_file_num;
-      }
-    }
-    ASSERT_EQ(expected_output_file_num, compaction_job_stats_.num_output_files);
-    if (expected_output_file_num == 0) {
-      return;
-    }
-
-    if (expected_oldest_blob_file_numbers.empty()) {
-      expected_oldest_blob_file_numbers.resize(expected_output_file_num,
-                                               kInvalidBlobFileNumber);
-    }
-
-    auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-    if (table_type_ == TableTypeForTest::kMockTable) {
-      assert(expected_results.size() == 1);
-      mock_table_factory_->AssertLatestFile(expected_results[0]);
-    } else {
-      assert(table_type_ == TableTypeForTest::kBlockBasedTable);
-    }
-
-    auto output_files =
-        cfd->current()->storage_info()->LevelFiles(output_level);
-    ASSERT_EQ(expected_output_file_num, output_files.size());
-
-    if (table_type_ == TableTypeForTest::kMockTable) {
-      assert(output_files.size() == 1);
-      const FileMetaData* const output_file = output_files[0];
-      ASSERT_EQ(output_file->oldest_blob_file_number,
-                expected_oldest_blob_file_numbers[0]);
-      return;
-    }
-
-    for (size_t i = 0; i < expected_results.size(); ++i) {
-      const FileMetaData* const output_file = output_files[i];
-      std::string file_name = GenerateFileName(output_file->fd.GetNumber());
-      const auto& fs = env_->GetFileSystem();
-      std::unique_ptr<RandomAccessFileReader> freader;
-      IOStatus ios = RandomAccessFileReader::Create(
-          fs, file_name, FileOptions(), &freader, nullptr);
-      ASSERT_OK(ios);
-      std::unique_ptr<TableReader> table_reader;
-      uint64_t file_size = output_file->fd.GetFileSize();
-      ReadOptions read_opts;
-      Status s = cf_options_.table_factory->NewTableReader(
-          read_opts,
-          TableReaderOptions(*cfd->ioptions(), nullptr, FileOptions(),
-                             cfd_->internal_comparator()),
-          std::move(freader), file_size, &table_reader, false);
-      ASSERT_OK(s);
-      assert(table_reader);
-      std::unique_ptr<InternalIterator> iiter(
-          table_reader->NewIterator(read_opts, nullptr, nullptr, true,
-                                    TableReaderCaller::kUncategorized));
-      assert(iiter);
-
-      mock::KVVector from_db;
-      for (iiter->SeekToFirst(); iiter->Valid(); iiter->Next()) {
-        const Slice key = iiter->key();
-        const Slice value = iiter->value();
-        from_db.emplace_back(
-            make_pair(key.ToString(false), value.ToString(false)));
-      }
-      ASSERT_EQ(expected_results[i], from_db);
-    }
-  }
-
   void SetLastSequence(const SequenceNumber sequence_number) {
     versions_->SetLastAllocatedSequence(sequence_number + 1);
     versions_->SetLastPublishedSequence(sequence_number + 1);
@@ -525,13 +440,6 @@ class CompactionJobTestBase : public testing::Test {
   void NewDB() {
     EXPECT_OK(DestroyDB(dbname_, Options()));
     EXPECT_OK(env_->CreateDirIfMissing(dbname_));
-
-    std::shared_ptr<Logger> info_log;
-    DBOptions db_opts = BuildDBOptions(db_options_, mutable_db_options_);
-    Status s = CreateLoggerFromOptions(dbname_, db_opts, &info_log);
-    ASSERT_OK(s);
-    db_options_.info_log = info_log;
-
     versions_.reset(
         new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
                        &write_buffer_manager_, &write_controller_,
@@ -548,9 +456,9 @@ class CompactionJobTestBase : public testing::Test {
     const std::string manifest = DescriptorFileName(dbname_, 1);
     std::unique_ptr<WritableFileWriter> file_writer;
     const auto& fs = env_->GetFileSystem();
-    s = WritableFileWriter::Create(fs, manifest,
-                                   fs->OptimizeForManifestWrite(env_options_),
-                                   &file_writer, nullptr);
+    Status s = WritableFileWriter::Create(
+        fs, manifest, fs->OptimizeForManifestWrite(env_options_), &file_writer,
+        nullptr);
 
     ASSERT_OK(s);
     {
@@ -574,32 +482,27 @@ class CompactionJobTestBase : public testing::Test {
     cfd_ = versions_->GetColumnFamilySet()->GetDefault();
   }
 
-  // input_files[i] on input_levels[i]
   void RunLastLevelCompaction(
       const std::vector<std::vector<FileMetaData*>>& input_files,
-      const std::vector<int> input_levels,
       std::function<void(Compaction& comp)>&& verify_func,
       const std::vector<SequenceNumber>& snapshots = {}) {
     const int kLastLevel = cf_options_.num_levels - 1;
     verify_per_key_placement_ = std::move(verify_func);
     mock::KVVector empty_map;
-    RunCompaction(input_files, input_levels, {empty_map}, snapshots,
-                  kMaxSequenceNumber, kLastLevel, false);
+    RunCompaction(input_files, empty_map, snapshots, kMaxSequenceNumber,
+                  kLastLevel, false);
   }
 
-  // input_files[i] on input_levels[i]
   void RunCompaction(
       const std::vector<std::vector<FileMetaData*>>& input_files,
-      const std::vector<int>& input_levels,
-      const std::vector<mock::KVVector>& expected_results,
+      const mock::KVVector& expected_results,
       const std::vector<SequenceNumber>& snapshots = {},
       SequenceNumber earliest_write_conflict_snapshot = kMaxSequenceNumber,
       int output_level = 1, bool verify = true,
-      std::vector<uint64_t> expected_oldest_blob_file_numbers = {},
+      uint64_t expected_oldest_blob_file_number = kInvalidBlobFileNumber,
       bool check_get_priority = false,
       Env::IOPriority read_io_priority = Env::IO_TOTAL,
-      Env::IOPriority write_io_priority = Env::IO_TOTAL,
-      int max_subcompactions = 0) {
+      Env::IOPriority write_io_priority = Env::IO_TOTAL) {
     // For compaction, set fs as MockTestFileSystem to check the io_priority.
     if (test_io_priority_) {
       db_options_.fs.reset(
@@ -610,10 +513,10 @@ class CompactionJobTestBase : public testing::Test {
 
     size_t num_input_files = 0;
     std::vector<CompactionInputFiles> compaction_input_files;
-    for (size_t i = 0; i < input_files.size(); ++i) {
-      auto level_files = input_files[i];
+    for (size_t level = 0; level < input_files.size(); level++) {
+      auto level_files = input_files[level];
       CompactionInputFiles compaction_level;
-      compaction_level.level = input_levels[i];
+      compaction_level.level = static_cast<int>(level);
       compaction_level.files.insert(compaction_level.files.end(),
           level_files.begin(), level_files.end());
       compaction_input_files.push_back(compaction_level);
@@ -625,10 +528,9 @@ class CompactionJobTestBase : public testing::Test {
         *cfd->GetLatestMutableCFOptions(), mutable_db_options_,
         compaction_input_files, output_level, 1024 * 1024, 10 * 1024 * 1024, 0,
         kNoCompression, cfd->GetLatestMutableCFOptions()->compression_opts,
-        Temperature::kUnknown, max_subcompactions, {}, true);
+        Temperature::kUnknown, 0, {}, true);
     compaction.SetInputVersion(cfd->current());
 
-    assert(db_options_.info_log);
     LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
     mutex_.Lock();
     EventLogger event_logger(db_options_.info_log.get());
@@ -658,14 +560,23 @@ class CompactionJobTestBase : public testing::Test {
     ASSERT_OK(compaction_job.Install(*cfd->GetLatestMutableCFOptions()));
     ASSERT_OK(compaction_job.io_status());
     mutex_.Unlock();
-    log_buffer.FlushBufferToLog();
 
     if (verify) {
       ASSERT_GE(compaction_job_stats_.elapsed_micros, 0U);
       ASSERT_EQ(compaction_job_stats_.num_input_files, num_input_files);
 
-      VerifyTables(output_level, expected_results,
-                   expected_oldest_blob_file_numbers);
+      if (expected_results.empty()) {
+        ASSERT_EQ(compaction_job_stats_.num_output_files, 0U);
+      } else {
+        ASSERT_EQ(compaction_job_stats_.num_output_files, 1U);
+        mock_table_factory_->AssertLatestFile(expected_results);
+
+        auto output_files =
+            cfd->current()->storage_info()->LevelFiles(output_level);
+        ASSERT_EQ(output_files.size(), 1);
+        ASSERT_EQ(output_files[0]->oldest_blob_file_number,
+                  expected_oldest_blob_file_number);
+      }
     }
 
     if (check_get_priority) {
@@ -725,9 +636,8 @@ class CompactionJobTestBase : public testing::Test {
   ErrorHandler error_handler_;
   std::string full_history_ts_low_;
   const std::function<std::string(uint64_t)> encode_u64_ts_;
-  const bool test_io_priority_;
+  bool test_io_priority_;
   std::function<void(Compaction& comp)> verify_per_key_placement_;
-  const TableTypeForTest table_type_ = kMockTable;
 };
 
 // TODO(icanadi) Make it simpler once we mock out VersionSet
@@ -736,8 +646,7 @@ class CompactionJobTest : public CompactionJobTestBase {
   CompactionJobTest()
       : CompactionJobTestBase(
             test::PerThreadDBPath("compaction_job_test"), BytewiseComparator(),
-            [](uint64_t /*ts*/) { return ""; }, /*test_io_priority=*/false,
-            TableTypeForTest::kMockTable) {}
+            [](uint64_t /*ts*/) { return ""; }, false) {}
 };
 
 TEST_F(CompactionJobTest, Simple) {
@@ -745,10 +654,9 @@ TEST_F(CompactionJobTest, Simple) {
 
   auto expected_results = CreateTwoFiles(false);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
   ASSERT_EQ(2U, files.size());
-  RunCompaction({files}, {input_level}, {expected_results});
+  RunCompaction({ files }, expected_results);
 }
 
 TEST_F(CompactionJobTest, DISABLED_SimpleCorrupted) {
@@ -756,9 +664,8 @@ TEST_F(CompactionJobTest, DISABLED_SimpleCorrupted) {
 
   auto expected_results = CreateTwoFiles(true);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
   ASSERT_EQ(compaction_job_stats_.num_corrupt_keys, 400U);
 }
 
@@ -777,9 +684,8 @@ TEST_F(CompactionJobTest, SimpleDeletion) {
       mock::MakeMockFile({{KeyStr("b", 0U, kTypeValue), "val"}});
 
   SetLastSequence(4U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, OutputNothing) {
@@ -796,10 +702,8 @@ TEST_F(CompactionJobTest, OutputNothing) {
   auto expected_results = mock::MakeMockFile();
 
   SetLastSequence(4U);
-
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, SimpleOverwrite) {
@@ -820,9 +724,8 @@ TEST_F(CompactionJobTest, SimpleOverwrite) {
                           {KeyStr("b", 0U, kTypeValue), "val3"}});
 
   SetLastSequence(4U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, SimpleNonLastLevel) {
@@ -849,12 +752,9 @@ TEST_F(CompactionJobTest, SimpleNonLastLevel) {
                           {KeyStr("b", 6U, kTypeValue), "val3"}});
 
   SetLastSequence(6U);
-  const std::vector<int> input_levels = {0, 1};
-  auto lvl0_files =
-      cfd_->current()->storage_info()->LevelFiles(input_levels[0]);
-  auto lvl1_files =
-      cfd_->current()->storage_info()->LevelFiles(input_levels[1]);
-  RunCompaction({lvl0_files, lvl1_files}, input_levels, {expected_results});
+  auto lvl0_files = cfd_->current()->storage_info()->LevelFiles(0);
+  auto lvl1_files = cfd_->current()->storage_info()->LevelFiles(1);
+  RunCompaction({lvl0_files, lvl1_files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, SimpleMerge) {
@@ -877,9 +777,8 @@ TEST_F(CompactionJobTest, SimpleMerge) {
                           {KeyStr("b", 0U, kTypeValue), "1,2"}});
 
   SetLastSequence(5U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, NonAssocMerge) {
@@ -902,9 +801,8 @@ TEST_F(CompactionJobTest, NonAssocMerge) {
                           {KeyStr("b", 0U, kTypeValue), "1,2"}});
 
   SetLastSequence(5U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 // Filters merge operands with value 10.
@@ -930,9 +828,8 @@ TEST_F(CompactionJobTest, MergeOperandFilter) {
                           {KeyStr("b", 0U, kTypeValue), test::EncodeInt(2U)}});
 
   SetLastSequence(5U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, FilterSomeMergeOperands) {
@@ -967,9 +864,8 @@ TEST_F(CompactionJobTest, FilterSomeMergeOperands) {
   });
 
   SetLastSequence(5U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 // Test where all operands/merge results are filtered out.
@@ -1002,11 +898,10 @@ TEST_F(CompactionJobTest, FilterAllMergeOperands) {
   AddMockFile(file3, 2);
 
   SetLastSequence(11U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
 
   mock::KVVector empty_map;
-  RunCompaction({files}, {input_level}, {empty_map});
+  RunCompaction({files}, empty_map);
 }
 
 TEST_F(CompactionJobTest, SimpleSingleDelete) {
@@ -1031,9 +926,8 @@ TEST_F(CompactionJobTest, SimpleSingleDelete) {
       mock::MakeMockFile({{KeyStr("a", 5U, kTypeDeletion), ""}});
 
   SetLastSequence(6U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, SingleDeleteSnapshots) {
@@ -1097,9 +991,8 @@ TEST_F(CompactionJobTest, SingleDeleteSnapshots) {
   });
 
   SetLastSequence(22U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results}, {10U, 20U}, 10U);
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results, {10U, 20U}, 10U);
 }
 
 TEST_F(CompactionJobTest, EarliestWriteConflictSnapshot) {
@@ -1176,10 +1069,8 @@ TEST_F(CompactionJobTest, EarliestWriteConflictSnapshot) {
   });
 
   SetLastSequence(24U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results}, {10U, 20U, 30U},
-                20U);
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results, {10U, 20U, 30U}, 20U);
 }
 
 TEST_F(CompactionJobTest, SingleDeleteZeroSeq) {
@@ -1201,9 +1092,8 @@ TEST_F(CompactionJobTest, SingleDeleteZeroSeq) {
   });
 
   SetLastSequence(22U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results}, {});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results, {});
 }
 
 TEST_F(CompactionJobTest, MultiSingleDelete) {
@@ -1357,9 +1247,8 @@ TEST_F(CompactionJobTest, MultiSingleDelete) {
                           {KeyStr("M", 3U, kTypeSingleDeletion), ""}});
 
   SetLastSequence(22U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results}, {10U}, 10U);
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results, {10U}, 10U);
 }
 
 // This test documents the behavior where a corrupt key follows a deletion or a
@@ -1388,9 +1277,8 @@ TEST_F(CompactionJobTest, DISABLED_CorruptionAfterDeletion) {
                           {test::KeyStr("c", 0U, kTypeValue), "val2"}});
 
   SetLastSequence(6U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, OldestBlobFileNumber) {
@@ -1435,12 +1323,10 @@ TEST_F(CompactionJobTest, OldestBlobFileNumber) {
                           expected_blob4, expected_blob5, expected_blob6});
 
   SetLastSequence(6U);
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results},
-                std::vector<SequenceNumber>(), kMaxSequenceNumber,
-                /* output_level */ 1, /* verify */ true,
-                /* expected_oldest_blob_file_numbers */ {19});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results, std::vector<SequenceNumber>(),
+                kMaxSequenceNumber, /* output_level */ 1, /* verify */ true,
+                /* expected_oldest_blob_file_number */ 19);
 }
 
 TEST_F(CompactionJobTest, VerifyPenultimateLevelOutput) {
@@ -1492,15 +1378,13 @@ TEST_F(CompactionJobTest, VerifyPenultimateLevelOutput) {
   AddMockFile(file3_2, 3);
 
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  const std::vector<int> input_levels = {0, 1, 2, 3};
-  auto files0 = cfd->current()->storage_info()->LevelFiles(input_levels[0]);
-  auto files1 = cfd->current()->storage_info()->LevelFiles(input_levels[1]);
-  auto files2 = cfd->current()->storage_info()->LevelFiles(input_levels[2]);
-  auto files3 = cfd->current()->storage_info()->LevelFiles(input_levels[3]);
+  auto files0 = cfd->current()->storage_info()->LevelFiles(0);
+  auto files1 = cfd->current()->storage_info()->LevelFiles(1);
+  auto files2 = cfd->current()->storage_info()->LevelFiles(2);
+  auto files3 = cfd->current()->storage_info()->LevelFiles(3);
 
   RunLastLevelCompaction(
-      {files0, files1, files2, files3}, input_levels,
-      /*verify_func=*/[&](Compaction& comp) {
+      {files0, files1, files2, files3}, /*verify_func=*/[&](Compaction& comp) {
         for (char c = 'a'; c <= 'z'; c++) {
           std::string c_str;
           c_str = c;
@@ -1525,9 +1409,8 @@ TEST_F(CompactionJobTest, NoEnforceSingleDeleteContract) {
   SetLastSequence(4U);
 
   auto expected_results = mock::MakeMockFile();
-  constexpr int input_level = 0;
-  auto files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  auto files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTest, InputSerialization) {
@@ -1727,8 +1610,7 @@ class CompactionJobTimestampTest : public CompactionJobTestBase {
   CompactionJobTimestampTest()
       : CompactionJobTestBase(test::PerThreadDBPath("compaction_job_ts_test"),
                               test::BytewiseComparatorWithU64TsWrapper(),
-                              test::EncodeInt, /*test_io_priority=*/false,
-                              TableTypeForTest::kMockTable) {}
+                              test::EncodeInt, false) {}
 };
 
 TEST_F(CompactionJobTimestampTest, GCDisabled) {
@@ -1760,9 +1642,8 @@ TEST_F(CompactionJobTimestampTest, GCDisabled) {
        {KeyStr("c", 4, ValueType::kTypeValue, 94), "c5"},
        {KeyStr("d", 7, ValueType::kTypeValue, 97), "d7"},
        {KeyStr("d", 3, ValueType::kTypeSingleDeletion, 93), ""}});
-  constexpr int input_level = 0;
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
-  RunCompaction({files}, {input_level}, {expected_results});
+  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTimestampTest, NoKeyExpired) {
@@ -1787,11 +1668,10 @@ TEST_F(CompactionJobTimestampTest, NoKeyExpired) {
                           {KeyStr("b", 7, ValueType::kTypeValue, 101), "b7"},
                           {KeyStr("c", 5, ValueType::kTypeValue, 99), "c5"},
                           {KeyStr("c", 3, ValueType::kTypeValue, 97), "c3"}});
-  constexpr int input_level = 0;
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
+  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
 
   full_history_ts_low_ = encode_u64_ts_(0);
-  RunCompaction({files}, {input_level}, {expected_results});
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTimestampTest, AllKeysExpired) {
@@ -1814,11 +1694,10 @@ TEST_F(CompactionJobTimestampTest, AllKeysExpired) {
 
   auto expected_results =
       mock::MakeMockFile({{KeyStr("c", 0, ValueType::kTypeValue, 0), "c7"}});
-  constexpr int input_level = 0;
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
+  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
 
   full_history_ts_low_ = encode_u64_ts_(std::numeric_limits<uint64_t>::max());
-  RunCompaction({files}, {input_level}, {expected_results});
+  RunCompaction({files}, expected_results);
 }
 
 TEST_F(CompactionJobTimestampTest, SomeKeysExpired) {
@@ -1841,121 +1720,10 @@ TEST_F(CompactionJobTimestampTest, SomeKeysExpired) {
       mock::MakeMockFile({{KeyStr("a", 5, ValueType::kTypeValue, 50), "a5"},
                           {KeyStr("a", 0, ValueType::kTypeValue, 0), "a3"},
                           {KeyStr("b", 6, ValueType::kTypeValue, 49), "b6"}});
-  constexpr int input_level = 0;
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
+  const auto& files = cfd_->current()->storage_info()->LevelFiles(0);
 
   full_history_ts_low_ = encode_u64_ts_(49);
-  RunCompaction({files}, {input_level}, {expected_results});
-}
-
-class CompactionJobTimestampTestWithBbTable : public CompactionJobTestBase {
- public:
-  // Block-based table is needed if we want to test subcompaction partitioning
-  // with anchors.
-  explicit CompactionJobTimestampTestWithBbTable()
-      : CompactionJobTestBase(
-            test::PerThreadDBPath("compaction_job_ts_bbt_test"),
-            test::BytewiseComparatorWithU64TsWrapper(), test::EncodeInt,
-            /*test_io_priority=*/false, TableTypeForTest::kBlockBasedTable) {}
-};
-
-TEST_F(CompactionJobTimestampTestWithBbTable, SubcompactionAnchorL1) {
-  cf_options_.target_file_size_base = 20;
-  mutable_cf_options_.target_file_size_base = 20;
-  NewDB();
-
-  const std::vector<std::string> keys = {
-      KeyStr("a", 20, ValueType::kTypeValue, 200),
-      KeyStr("b", 21, ValueType::kTypeValue, 210),
-      KeyStr("b", 20, ValueType::kTypeValue, 200),
-      KeyStr("b", 18, ValueType::kTypeValue, 180),
-      KeyStr("c", 17, ValueType::kTypeValue, 170),
-      KeyStr("c", 16, ValueType::kTypeValue, 160),
-      KeyStr("c", 15, ValueType::kTypeValue, 150)};
-  const std::vector<std::string> values = {"a20", "b21", "b20", "b18",
-                                           "c17", "c16", "c15"};
-
-  constexpr int input_level = 1;
-
-  auto file1 = mock::MakeMockFile(
-      {{keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}});
-  AddMockFile(file1, input_level);
-
-  auto file2 = mock::MakeMockFile(
-      {{keys[3], values[3]}, {keys[4], values[4]}, {keys[5], values[5]}});
-  AddMockFile(file2, input_level);
-
-  auto file3 = mock::MakeMockFile({{keys[6], values[6]}});
-  AddMockFile(file3, input_level);
-
-  SetLastSequence(20);
-
-  auto output1 = mock::MakeMockFile({{keys[0], values[0]}});
-  auto output2 = mock::MakeMockFile(
-      {{keys[1], values[1]}, {keys[2], values[2]}, {keys[3], values[3]}});
-  auto output3 = mock::MakeMockFile(
-      {{keys[4], values[4]}, {keys[5], values[5]}, {keys[6], values[6]}});
-
-  auto expected_results =
-      std::vector<mock::KVVector>{output1, output2, output3};
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
-
-  constexpr int output_level = 2;
-  constexpr int max_subcompactions = 4;
-  RunCompaction({files}, {input_level}, expected_results, /*snapshots=*/{},
-                /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-                output_level, /*verify=*/true, {kInvalidBlobFileNumber},
-                /*check_get_priority=*/false, Env::IO_TOTAL, Env::IO_TOTAL,
-                max_subcompactions);
-}
-
-TEST_F(CompactionJobTimestampTestWithBbTable, SubcompactionL0) {
-  cf_options_.target_file_size_base = 20;
-  mutable_cf_options_.target_file_size_base = 20;
-  NewDB();
-
-  const std::vector<std::string> keys = {
-      KeyStr("a", 20, ValueType::kTypeValue, 200),
-      KeyStr("b", 20, ValueType::kTypeValue, 200),
-      KeyStr("b", 19, ValueType::kTypeValue, 190),
-      KeyStr("b", 18, ValueType::kTypeValue, 180),
-      KeyStr("c", 17, ValueType::kTypeValue, 170),
-      KeyStr("c", 16, ValueType::kTypeValue, 160),
-      KeyStr("c", 15, ValueType::kTypeValue, 150)};
-  const std::vector<std::string> values = {"a20", "b20", "b19", "b18",
-                                           "c17", "c16", "c15"};
-
-  constexpr int input_level = 0;
-
-  auto file1 = mock::MakeMockFile({{keys[5], values[5]}, {keys[6], values[6]}});
-  AddMockFile(file1, input_level);
-
-  auto file2 = mock::MakeMockFile({{keys[3], values[3]}, {keys[4], values[4]}});
-  AddMockFile(file2, input_level);
-
-  auto file3 = mock::MakeMockFile(
-      {{keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}});
-  AddMockFile(file3, input_level);
-
-  SetLastSequence(20);
-
-  auto output1 = mock::MakeMockFile({{keys[0], values[0]}});
-  auto output2 = mock::MakeMockFile(
-      {{keys[1], values[1]}, {keys[2], values[2]}, {keys[3], values[3]}});
-  auto output3 = mock::MakeMockFile(
-      {{keys[4], values[4]}, {keys[5], values[5]}, {keys[6], values[6]}});
-
-  auto expected_results =
-      std::vector<mock::KVVector>{output1, output2, output3};
-  const auto& files = cfd_->current()->storage_info()->LevelFiles(input_level);
-
-  constexpr int output_level = 1;
-  constexpr int max_subcompactions = 4;
-  RunCompaction({files}, {input_level}, expected_results, /*snapshots=*/{},
-                /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
-                output_level, /*verify=*/true, {kInvalidBlobFileNumber},
-                /*check_get_priority=*/false, Env::IO_TOTAL, Env::IO_TOTAL,
-                max_subcompactions);
+  RunCompaction({files}, expected_results);
 }
 
 // The io priority of the compaction reads and writes are different from
@@ -1967,8 +1735,7 @@ class CompactionJobIOPriorityTest : public CompactionJobTestBase {
   CompactionJobIOPriorityTest()
       : CompactionJobTestBase(
             test::PerThreadDBPath("compaction_job_io_priority_test"),
-            BytewiseComparator(), [](uint64_t /*ts*/) { return ""; },
-            /*test_io_priority=*/true, TableTypeForTest::kBlockBasedTable) {}
+            BytewiseComparator(), [](uint64_t /*ts*/) { return ""; }, true) {}
 };
 
 TEST_F(CompactionJobIOPriorityTest, WriteControllerStateNormal) {
@@ -1976,12 +1743,10 @@ TEST_F(CompactionJobIOPriorityTest, WriteControllerStateNormal) {
   NewDB();
   mock::KVVector expected_results = CreateTwoFiles(false);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
   ASSERT_EQ(2U, files.size());
-  RunCompaction({files}, {input_level}, {expected_results}, {},
-                kMaxSequenceNumber, 1, false, {kInvalidBlobFileNumber}, false,
-                Env::IO_LOW, Env::IO_LOW);
+  RunCompaction({files}, expected_results, {}, kMaxSequenceNumber, 1, false,
+                kInvalidBlobFileNumber, false, Env::IO_LOW, Env::IO_LOW);
 }
 
 TEST_F(CompactionJobIOPriorityTest, WriteControllerStateDelayed) {
@@ -1989,15 +1754,13 @@ TEST_F(CompactionJobIOPriorityTest, WriteControllerStateDelayed) {
   NewDB();
   mock::KVVector expected_results = CreateTwoFiles(false);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
   ASSERT_EQ(2U, files.size());
   {
     std::unique_ptr<WriteControllerToken> delay_token =
         write_controller_.GetDelayToken(1000000);
-    RunCompaction({files}, {input_level}, {expected_results}, {},
-                  kMaxSequenceNumber, 1, false, {kInvalidBlobFileNumber}, false,
-                  Env::IO_USER, Env::IO_USER);
+    RunCompaction({files}, expected_results, {}, kMaxSequenceNumber, 1, false,
+                  kInvalidBlobFileNumber, false, Env::IO_USER, Env::IO_USER);
   }
 }
 
@@ -2006,15 +1769,13 @@ TEST_F(CompactionJobIOPriorityTest, WriteControllerStateStalled) {
   NewDB();
   mock::KVVector expected_results = CreateTwoFiles(false);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
   ASSERT_EQ(2U, files.size());
   {
     std::unique_ptr<WriteControllerToken> stop_token =
         write_controller_.GetStopToken();
-    RunCompaction({files}, {input_level}, {expected_results}, {},
-                  kMaxSequenceNumber, 1, false, {kInvalidBlobFileNumber}, false,
-                  Env::IO_USER, Env::IO_USER);
+    RunCompaction({files}, expected_results, {}, kMaxSequenceNumber, 1, false,
+                  kInvalidBlobFileNumber, false, Env::IO_USER, Env::IO_USER);
   }
 }
 
@@ -2022,12 +1783,10 @@ TEST_F(CompactionJobIOPriorityTest, GetRateLimiterPriority) {
   NewDB();
   mock::KVVector expected_results = CreateTwoFiles(false);
   auto cfd = versions_->GetColumnFamilySet()->GetDefault();
-  constexpr int input_level = 0;
-  auto files = cfd->current()->storage_info()->LevelFiles(input_level);
+  auto files = cfd->current()->storage_info()->LevelFiles(0);
   ASSERT_EQ(2U, files.size());
-  RunCompaction({files}, {input_level}, {expected_results}, {},
-                kMaxSequenceNumber, 1, false, {kInvalidBlobFileNumber}, true,
-                Env::IO_LOW, Env::IO_LOW);
+  RunCompaction({files}, expected_results, {}, kMaxSequenceNumber, 1, false,
+                kInvalidBlobFileNumber, true, Env::IO_LOW, Env::IO_LOW);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

db/compaction/compaction_outputs.cc

@@ -76,107 +76,6 @@ IOStatus CompactionOutputs::WriterSyncClose(const Status& input_status,
   return io_s;
 }
 
-bool CompactionOutputs::ShouldStopBefore(const CompactionIterator& c_iter) {
-  assert(c_iter.Valid());
-
-  // If there's user defined partitioner, check that first
-  if (HasBuilder() && partitioner_ &&
-      partitioner_->ShouldPartition(
-          PartitionerRequest(last_key_for_partitioner_, c_iter.user_key(),
-                             current_output_file_size_)) == kRequired) {
-    return true;
-  }
-
-  // files output to Level 0 won't be split
-  if (compaction_->output_level() == 0) {
-    return false;
-  }
-
-  // reach the target file size
-  if (current_output_file_size_ >= compaction_->max_output_file_size()) {
-    return true;
-  }
-
-  const Slice& internal_key = c_iter.key();
-  const InternalKeyComparator* icmp =
-      &compaction_->column_family_data()->internal_comparator();
-
-  // Check if it needs to split for RoundRobin
-  // Invalid local_output_split_key indicates that we do not need to split
-  if (local_output_split_key_ != nullptr && !is_split_) {
-    // Split occurs when the next key is larger than/equal to the cursor
-    if (icmp->Compare(internal_key, local_output_split_key_->Encode()) >= 0) {
-      is_split_ = true;
-      return true;
-    }
-  }
-
-  // Update grandparent information
-  const std::vector<FileMetaData*>& grandparents = compaction_->grandparents();
-  bool grandparant_file_switched = false;
-  // Scan to find the earliest grandparent file that contains key.
-  while (grandparent_index_ < grandparents.size() &&
-         icmp->Compare(internal_key,
-                       grandparents[grandparent_index_]->largest.Encode()) >
-             0) {
-    if (seen_key_) {
-      overlapped_bytes_ += grandparents[grandparent_index_]->fd.GetFileSize();
-      grandparant_file_switched = true;
-    }
-    assert(grandparent_index_ + 1 >= grandparents.size() ||
-           icmp->Compare(
-               grandparents[grandparent_index_]->largest.Encode(),
-               grandparents[grandparent_index_ + 1]->smallest.Encode()) <= 0);
-    grandparent_index_++;
-  }
-  seen_key_ = true;
-
-  if (grandparant_file_switched &&
-      overlapped_bytes_ + current_output_file_size_ >
-          compaction_->max_compaction_bytes()) {
-    // Too much overlap for current output; start new output
-    overlapped_bytes_ = 0;
-    return true;
-  }
-
-  // check ttl file boundaries if there's any
-  if (!files_to_cut_for_ttl_.empty()) {
-    if (cur_files_to_cut_for_ttl_ != -1) {
-      // Previous key is inside the range of a file
-      if (icmp->Compare(internal_key,
-                        files_to_cut_for_ttl_[cur_files_to_cut_for_ttl_]
-                            ->largest.Encode()) > 0) {
-        next_files_to_cut_for_ttl_ = cur_files_to_cut_for_ttl_ + 1;
-        cur_files_to_cut_for_ttl_ = -1;
-        return true;
-      }
-    } else {
-      // Look for the key position
-      while (next_files_to_cut_for_ttl_ <
-             static_cast<int>(files_to_cut_for_ttl_.size())) {
-        if (icmp->Compare(internal_key,
-                          files_to_cut_for_ttl_[next_files_to_cut_for_ttl_]
-                              ->smallest.Encode()) >= 0) {
-          if (icmp->Compare(internal_key,
-                            files_to_cut_for_ttl_[next_files_to_cut_for_ttl_]
-                                ->largest.Encode()) <= 0) {
-            // With in the current file
-            cur_files_to_cut_for_ttl_ = next_files_to_cut_for_ttl_;
-            return true;
-          }
-          // Beyond the current file
-          next_files_to_cut_for_ttl_++;
-        } else {
-          // Still fall into the gap
-          break;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
 Status CompactionOutputs::AddToOutput(
     const CompactionIterator& c_iter,
     const CompactionFileOpenFunc& open_file_func,
@@ -184,19 +83,27 @@ Status CompactionOutputs::AddToOutput(
   Status s;
   const Slice& key = c_iter.key();
 
-  if (ShouldStopBefore(c_iter) && HasBuilder()) {
+  if (!pending_close_ && c_iter.Valid() && partitioner_ && HasBuilder() &&
+      partitioner_->ShouldPartition(
+          PartitionerRequest(last_key_for_partitioner_, c_iter.user_key(),
+                             current_output_file_size_)) == kRequired) {
+    pending_close_ = true;
+  }
+
+  if (pending_close_) {
     s = close_file_func(*this, c_iter.InputStatus(), key);
-    if (!s.ok()) {
-      return s;
-    }
+    pending_close_ = false;
+  }
+  if (!s.ok()) {
+    return s;
   }
 
   // Open output file if necessary
   if (!HasBuilder()) {
     s = open_file_func(*this);
-    if (!s.ok()) {
-      return s;
-    }
+  }
+  if (!s.ok()) {
+    return s;
   }
 
   Output& curr = current_output();
@@ -223,6 +130,19 @@ Status CompactionOutputs::AddToOutput(
   s = current_output().meta.UpdateBoundaries(key, value, ikey.sequence,
                                              ikey.type);
 
+  // Close output file if it is big enough. Two possibilities determine it's
+  // time to close it: (1) the current key should be this file's last key, (2)
+  // the next key should not be in this file.
+  //
+  // TODO(aekmekji): determine if file should be closed earlier than this
+  // during subcompactions (i.e. if output size, estimated by input size, is
+  // going to be 1.2MB and max_output_file_size = 1MB, prefer to have 0.6MB
+  // and 0.6MB instead of 1MB and 0.2MB)
+  if (compaction_->output_level() != 0 &&
+      current_output_file_size_ >= compaction_->max_output_file_size()) {
+    pending_close_ = true;
+  }
+
   if (partitioner_) {
     last_key_for_partitioner_.assign(c_iter.user_key().data_,
                                      c_iter.user_key().size_);
@@ -398,59 +318,4 @@ Status CompactionOutputs::AddRangeDels(
   }
   return Status::OK();
 }
-
-void CompactionOutputs::FillFilesToCutForTtl() {
-  if (compaction_->immutable_options()->compaction_style !=
-          kCompactionStyleLevel ||
-      compaction_->immutable_options()->compaction_pri !=
-          kMinOverlappingRatio ||
-      compaction_->mutable_cf_options()->ttl == 0 ||
-      compaction_->num_input_levels() < 2 || compaction_->bottommost_level()) {
-    return;
-  }
-
-  // We define new file with the oldest ancestor time to be younger than 1/4
-  // TTL, and an old one to be older than 1/2 TTL time.
-  int64_t temp_current_time;
-  auto get_time_status =
-      compaction_->immutable_options()->clock->GetCurrentTime(
-          &temp_current_time);
-  if (!get_time_status.ok()) {
-    return;
-  }
-
-  auto current_time = static_cast<uint64_t>(temp_current_time);
-  if (current_time < compaction_->mutable_cf_options()->ttl) {
-    return;
-  }
-
-  uint64_t old_age_thres =
-      current_time - compaction_->mutable_cf_options()->ttl / 2;
-  const std::vector<FileMetaData*>& olevel =
-      *(compaction_->inputs(compaction_->num_input_levels() - 1));
-  for (FileMetaData* file : olevel) {
-    // Worth filtering out by start and end?
-    uint64_t oldest_ancester_time = file->TryGetOldestAncesterTime();
-    // We put old files if they are not too small to prevent a flood
-    // of small files.
-    if (oldest_ancester_time < old_age_thres &&
-        file->fd.GetFileSize() >
-            compaction_->mutable_cf_options()->target_file_size_base / 2) {
-      files_to_cut_for_ttl_.push_back(file);
-    }
-  }
-}
-
-CompactionOutputs::CompactionOutputs(const Compaction* compaction,
-                                     const bool is_penultimate_level)
-    : compaction_(compaction), is_penultimate_level_(is_penultimate_level) {
-  partitioner_ = compaction->output_level() == 0
-                     ? nullptr
-                     : compaction->CreateSstPartitioner();
-
-  if (compaction->output_level() != 0) {
-    FillFilesToCutForTtl();
-  }
-}
-
 }  // namespace ROCKSDB_NAMESPACE

db/compaction/compaction_outputs.h

@@ -45,7 +45,12 @@ class CompactionOutputs {
   CompactionOutputs() = delete;
 
   explicit CompactionOutputs(const Compaction* compaction,
-                             const bool is_penultimate_level);
+                             const bool is_penultimate_level)
+      : compaction_(compaction), is_penultimate_level_(is_penultimate_level) {
+    partitioner_ = compaction->output_level() == 0
+                       ? nullptr
+                       : compaction->CreateSstPartitioner();
+  }
 
   // Add generated output to the list
   void AddOutput(FileMetaData&& meta, const InternalKeyComparator& icmp,
@@ -174,6 +179,12 @@ class CompactionOutputs {
                       SequenceNumber earliest_snapshot,
                       const Slice& next_table_min_key);
 
+  // Is the current file is already pending for close
+  bool IsPendingClose() const { return pending_close_; }
+
+  // Current file should close before adding a new key
+  void SetPendingClose() { pending_close_ = true; }
+
   // if the outputs have range delete, range delete is also data
   bool HasRangeDel() const {
     return range_del_agg_ && !range_del_agg_->IsEmpty();
@@ -182,32 +193,6 @@ class CompactionOutputs {
  private:
   friend class SubcompactionState;
 
-  void FillFilesToCutForTtl();
-
-  void SetOutputSlitKey(const std::optional<Slice> start,
-                        const std::optional<Slice> end) {
-    const InternalKeyComparator* icmp =
-        &compaction_->column_family_data()->internal_comparator();
-
-    const InternalKey* output_split_key = compaction_->GetOutputSplitKey();
-    // Invalid output_split_key indicates that we do not need to split
-    if (output_split_key != nullptr) {
-      // We may only split the output when the cursor is in the range. Split
-      if ((!end.has_value() ||
-           icmp->user_comparator()->Compare(
-               ExtractUserKey(output_split_key->Encode()), end.value()) < 0) &&
-          (!start.has_value() || icmp->user_comparator()->Compare(
-                                     ExtractUserKey(output_split_key->Encode()),
-                                     start.value()) > 0)) {
-        local_output_split_key_ = output_split_key;
-      }
-    }
-  }
-
-  // Returns true iff we should stop building the current output
-  // before processing the current key in compaction iterator.
-  bool ShouldStopBefore(const CompactionIterator& c_iter);
-
   void Cleanup() {
     if (builder_ != nullptr) {
       // May happen if we get a shutdown call in the middle of compaction
@@ -220,7 +205,7 @@ class CompactionOutputs {
     return current_output_file_size_;
   }
 
-  // Add current key from compaction_iterator to the output file. If needed
+  // Add curent key from compaction_iterator to the output file. If needed
   // close and open new compaction output with the functions provided.
   Status AddToOutput(const CompactionIterator& c_iter,
                      const CompactionFileOpenFunc& open_file_func,
@@ -270,6 +255,10 @@ class CompactionOutputs {
 
   const Compaction* compaction_;
 
+  // The current file is pending close, which needs to run `close_file_func()`
+  // first to add a new key.
+  bool pending_close_ = false;
+
   // current output builder and writer
   std::unique_ptr<TableBuilder> builder_;
   std::unique_ptr<WritableFileWriter> file_writer_;
@@ -293,30 +282,6 @@ class CompactionOutputs {
   // partitioner information
   std::string last_key_for_partitioner_;
   std::unique_ptr<SstPartitioner> partitioner_;
-
-  // A flag determines if this subcompaction has been split by the cursor
-  bool is_split_ = false;
-
-  // We also maintain the output split key for each subcompaction to avoid
-  // repetitive comparison in ShouldStopBefore()
-  const InternalKey* local_output_split_key_ = nullptr;
-
-  // Some identified files with old oldest ancester time and the range should be
-  // isolated out so that the output file(s) in that range can be merged down
-  // for TTL and clear the timestamps for the range.
-  std::vector<FileMetaData*> files_to_cut_for_ttl_;
-  int cur_files_to_cut_for_ttl_ = -1;
-  int next_files_to_cut_for_ttl_ = 0;
-
-  // An index that used to speed up ShouldStopBefore().
-  size_t grandparent_index_ = 0;
-
-  // The number of bytes overlapping between the current output and
-  // grandparent files used in ShouldStopBefore().
-  uint64_t overlapped_bytes_ = 0;
-
-  // A flag determines whether the key has been seen in ShouldStopBefore()
-  bool seen_key_ = false;
 };
 
 // helper struct to concatenate the last level and penultimate level outputs

db/compaction/compaction_picker.cc

@@ -288,10 +288,8 @@ bool CompactionPicker::RangeOverlapWithCompaction(
   const Comparator* ucmp = icmp_->user_comparator();
   for (Compaction* c : compactions_in_progress_) {
     if (c->output_level() == level &&
-        ucmp->CompareWithoutTimestamp(smallest_user_key,
-                                      c->GetLargestUserKey()) <= 0 &&
-        ucmp->CompareWithoutTimestamp(largest_user_key,
-                                      c->GetSmallestUserKey()) >= 0) {
+        ucmp->Compare(smallest_user_key, c->GetLargestUserKey()) <= 0 &&
+        ucmp->Compare(largest_user_key, c->GetSmallestUserKey()) >= 0) {
       // Overlap
       return true;
     }
@@ -464,7 +462,7 @@ bool CompactionPicker::SetupOtherInputs(
     const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
     VersionStorageInfo* vstorage, CompactionInputFiles* inputs,
     CompactionInputFiles* output_level_inputs, int* parent_index,
-    int base_index, bool only_expand_towards_right) {
+    int base_index) {
   assert(!inputs->empty());
   assert(output_level_inputs->empty());
   const int input_level = inputs->level;
@@ -517,16 +515,8 @@ bool CompactionPicker::SetupOtherInputs(
     InternalKey all_start, all_limit;
     GetRange(*inputs, *output_level_inputs, &all_start, &all_limit);
     bool try_overlapping_inputs = true;
-    if (only_expand_towards_right) {
-      // Round-robin compaction only allows expansion towards the larger side.
-      vstorage->GetOverlappingInputs(input_level, &smallest, &all_limit,
-                                     &expanded_inputs.files, base_index,
-                                     nullptr);
-    } else {
-      vstorage->GetOverlappingInputs(input_level, &all_start, &all_limit,
-                                     &expanded_inputs.files, base_index,
-                                     nullptr);
-    }
+    vstorage->GetOverlappingInputs(input_level, &all_start, &all_limit,
+                                   &expanded_inputs.files, base_index, nullptr);
     uint64_t expanded_inputs_size =
         TotalCompensatedFileSize(expanded_inputs.files);
     if (!ExpandInputsToCleanCut(cf_name, vstorage, &expanded_inputs)) {
@@ -880,21 +870,21 @@ namespace {
 // Test whether two files have overlapping key-ranges.
 bool HaveOverlappingKeyRanges(const Comparator* c, const SstFileMetaData& a,
                               const SstFileMetaData& b) {
-  if (c->CompareWithoutTimestamp(a.smallestkey, b.smallestkey) >= 0) {
-    if (c->CompareWithoutTimestamp(a.smallestkey, b.largestkey) <= 0) {
+  if (c->Compare(a.smallestkey, b.smallestkey) >= 0) {
+    if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
       // b.smallestkey <= a.smallestkey <= b.largestkey
       return true;
     }
-  } else if (c->CompareWithoutTimestamp(a.largestkey, b.smallestkey) >= 0) {
+  } else if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
     // a.smallestkey < b.smallestkey <= a.largestkey
     return true;
   }
-  if (c->CompareWithoutTimestamp(a.largestkey, b.largestkey) <= 0) {
-    if (c->CompareWithoutTimestamp(a.largestkey, b.smallestkey) >= 0) {
+  if (c->Compare(a.largestkey, b.largestkey) <= 0) {
+    if (c->Compare(a.largestkey, b.smallestkey) >= 0) {
       // b.smallestkey <= a.largestkey <= b.largestkey
       return true;
     }
-  } else if (c->CompareWithoutTimestamp(a.smallestkey, b.largestkey) <= 0) {
+  } else if (c->Compare(a.smallestkey, b.largestkey) <= 0) {
     // a.smallestkey <= b.largestkey < a.largestkey
     return true;
   }
@@ -933,16 +923,15 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
     // identify the first and the last compaction input files
     // in the current level.
     for (size_t f = 0; f < current_files.size(); ++f) {
-      const uint64_t file_number = TableFileNameToNumber(current_files[f].name);
-      if (input_files->find(file_number) == input_files->end()) {
-        continue;
-      }
-      first_included = std::min(first_included, static_cast<int>(f));
-      last_included = std::max(last_included, static_cast<int>(f));
-      if (is_first == false) {
-        smallestkey = current_files[f].smallestkey;
-        largestkey = current_files[f].largestkey;
-        is_first = true;
+      if (input_files->find(TableFileNameToNumber(current_files[f].name)) !=
+          input_files->end()) {
+        first_included = std::min(first_included, static_cast<int>(f));
+        last_included = std::max(last_included, static_cast<int>(f));
+        if (is_first == false) {
+          smallestkey = current_files[f].smallestkey;
+          largestkey = current_files[f].largestkey;
+          is_first = true;
+        }
       }
     }
     if (last_included == kNotFound) {
@@ -950,22 +939,21 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
     }
 
     if (l != 0) {
-      // expand the compaction input of the current level if it
+      // expend the compaction input of the current level if it
       // has overlapping key-range with other non-compaction input
       // files in the same level.
       while (first_included > 0) {
-        if (comparator->CompareWithoutTimestamp(
-                current_files[first_included - 1].largestkey,
-                current_files[first_included].smallestkey) < 0) {
+        if (comparator->Compare(current_files[first_included - 1].largestkey,
+                                current_files[first_included].smallestkey) <
+            0) {
           break;
         }
         first_included--;
       }
 
       while (last_included < static_cast<int>(current_files.size()) - 1) {
-        if (comparator->CompareWithoutTimestamp(
-                current_files[last_included + 1].smallestkey,
-                current_files[last_included].largestkey) > 0) {
+        if (comparator->Compare(current_files[last_included + 1].smallestkey,
+                                current_files[last_included].largestkey) > 0) {
           break;
         }
         last_included++;
@@ -987,22 +975,21 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
     // update smallest and largest key
     if (l == 0) {
       for (int f = first_included; f <= last_included; ++f) {
-        if (comparator->CompareWithoutTimestamp(
-                smallestkey, current_files[f].smallestkey) > 0) {
+        if (comparator->Compare(smallestkey, current_files[f].smallestkey) >
+            0) {
           smallestkey = current_files[f].smallestkey;
         }
-        if (comparator->CompareWithoutTimestamp(
-                largestkey, current_files[f].largestkey) < 0) {
+        if (comparator->Compare(largestkey, current_files[f].largestkey) < 0) {
           largestkey = current_files[f].largestkey;
         }
       }
     } else {
-      if (comparator->CompareWithoutTimestamp(
-              smallestkey, current_files[first_included].smallestkey) > 0) {
+      if (comparator->Compare(smallestkey,
+                              current_files[first_included].smallestkey) > 0) {
         smallestkey = current_files[first_included].smallestkey;
       }
-      if (comparator->CompareWithoutTimestamp(
-              largestkey, current_files[last_included].largestkey) < 0) {
+      if (comparator->Compare(largestkey,
+                              current_files[last_included].largestkey) < 0) {
         largestkey = current_files[last_included].largestkey;
       }
     }

db/compaction/compaction_picker.h

@@ -189,8 +189,7 @@ class CompactionPicker {
                         VersionStorageInfo* vstorage,
                         CompactionInputFiles* inputs,
                         CompactionInputFiles* output_level_inputs,
-                        int* parent_index, int base_index,
-                        bool only_expand_towards_right = false);
+                        int* parent_index, int base_index);
 
   void GetGrandparents(VersionStorageInfo* vstorage,
                        const CompactionInputFiles& inputs,

db/compaction/compaction_picker_fifo.cc

@@ -83,7 +83,7 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
           break;
         }
       }
-      total_size -= f->fd.file_size;
+      total_size -= f->compensated_file_size;
       inputs[0].files.push_back(f);
     }
   }
@@ -191,7 +191,7 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
 
   for (auto ritr = level_files.rbegin(); ritr != level_files.rend(); ++ritr) {
     auto f = *ritr;
-    total_size -= f->fd.file_size;
+    total_size -= f->compensated_file_size;
     inputs[0].files.push_back(f);
     char tmp_fsize[16];
     AppendHumanBytes(f->fd.GetFileSize(), tmp_fsize, sizeof(tmp_fsize));

db/compaction/compaction_picker_level.cc

@@ -76,9 +76,6 @@ class LevelCompactionBuilder {
   // files if needed.
   bool SetupOtherL0FilesIfNeeded();
 
-  // Compaction with round-robin compaction priority allows more files to be
-  // picked to form a large compaction
-  void SetupOtherFilesWithRoundRobinExpansion();
   // Based on initial files, setup other files need to be compacted
   // in this compaction, accordingly.
   bool SetupOtherInputsIfNeeded();
@@ -87,9 +84,7 @@ class LevelCompactionBuilder {
 
   // For the specfied level, pick a file that we want to compact.
   // Returns false if there is no file to compact.
-  // If it returns true, inputs->files.size() will be exactly one for
-  // all compaction priorities except round-robin. For round-robin,
-  // multiple consecutive files may be put into inputs->files.
+  // If it returns true, inputs->files.size() will be exactly one.
   // If level is 0 and there is already a compaction on that level, this
   // function will return false.
   bool PickFileToCompact();
@@ -283,141 +278,16 @@ bool LevelCompactionBuilder::SetupOtherL0FilesIfNeeded() {
   return true;
 }
 
-void LevelCompactionBuilder::SetupOtherFilesWithRoundRobinExpansion() {
-  // We only expand when the start level is not L0 under round robin
-  assert(start_level_ >= 1);
-
-  // For round-robin compaction priority, we have 3 constraints when picking
-  // multiple files.
-  // Constraint 1: We can only pick consecutive files
-  //  -> Constraint 1a: When a file is being compacted (or some input files
-  //                    are being compacted after expanding, we cannot
-  //                    choose it and have to stop choosing more files
-  //  -> Constraint 1b: When we reach the last file (with largest keys), we
-  //                    cannot choose more files (the next file will be the
-  //                    first one)
-  // Constraint 2: We should ensure the total compaction bytes (including the
-  //               overlapped files from the next level) is no more than
-  //               mutable_cf_options_.max_compaction_bytes
-  // Constraint 3: We try our best to pick as many files as possible so that
-  //               the post-compaction level size is less than
-  //               MaxBytesForLevel(start_level_)
-  // Constraint 4: We do not expand if it is possible to apply a trivial move
-  // Constraint 5 (TODO): Try to pick minimal files to split into the target
-  //               number of subcompactions
-  TEST_SYNC_POINT("LevelCompactionPicker::RoundRobin");
-
-  // Only expand the inputs when we have selected a file in start_level_inputs_
-  if (start_level_inputs_.size() == 0) return;
-
-  uint64_t start_lvl_bytes_no_compacting = 0;
-  uint64_t curr_bytes_to_compact = 0;
-  uint64_t start_lvl_max_bytes_to_compact = 0;
-  const std::vector<FileMetaData*>& level_files =
-      vstorage_->LevelFiles(start_level_);
-  // Constraint 3 (pre-calculate the ideal max bytes to compact)
-  for (auto f : level_files) {
-    if (!f->being_compacted) {
-      start_lvl_bytes_no_compacting += f->compensated_file_size;
-    }
-  }
-  if (start_lvl_bytes_no_compacting >
-      vstorage_->MaxBytesForLevel(start_level_)) {
-    start_lvl_max_bytes_to_compact = start_lvl_bytes_no_compacting -
-                                     vstorage_->MaxBytesForLevel(start_level_);
-  }
-
-  size_t start_index = vstorage_->FilesByCompactionPri(start_level_)[0];
-  InternalKey smallest, largest;
-  // Constraint 4 (No need to check again later)
-  compaction_picker_->GetRange(start_level_inputs_, &smallest, &largest);
-  CompactionInputFiles output_level_inputs;
-  output_level_inputs.level = output_level_;
-  vstorage_->GetOverlappingInputs(output_level_, &smallest, &largest,
-                                  &output_level_inputs.files);
-  if (output_level_inputs.empty()) {
-    if (TryExtendNonL0TrivialMove((int)start_index)) {
-      return;
-    }
-  }
-  // Constraint 3
-  if (start_level_inputs_[0]->compensated_file_size >=
-      start_lvl_max_bytes_to_compact) {
-    return;
-  }
-  CompactionInputFiles tmp_start_level_inputs;
-  tmp_start_level_inputs = start_level_inputs_;
-  // TODO (zichen): Future parallel round-robin may also need to update this
-  // Constraint 1b (only expand till the end)
-  for (size_t i = start_index + 1; i < level_files.size(); i++) {
-    auto* f = level_files[i];
-    if (f->being_compacted) {
-      // Constraint 1a
-      return;
-    }
-
-    tmp_start_level_inputs.files.push_back(f);
-    if (!compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
-                                                    &tmp_start_level_inputs) ||
-        compaction_picker_->FilesRangeOverlapWithCompaction(
-            {tmp_start_level_inputs}, output_level_)) {
-      // Constraint 1a
-      tmp_start_level_inputs.clear();
-      return;
-    }
-
-    curr_bytes_to_compact = 0;
-    for (auto start_lvl_f : tmp_start_level_inputs.files) {
-      curr_bytes_to_compact += start_lvl_f->compensated_file_size;
-    }
-
-    // Check whether any output level files are locked
-    compaction_picker_->GetRange(tmp_start_level_inputs, &smallest, &largest);
-    vstorage_->GetOverlappingInputs(output_level_, &smallest, &largest,
-                                    &output_level_inputs.files);
-    if (!output_level_inputs.empty() &&
-        !compaction_picker_->ExpandInputsToCleanCut(cf_name_, vstorage_,
-                                                    &output_level_inputs)) {
-      // Constraint 1a
-      tmp_start_level_inputs.clear();
-      return;
-    }
-
-    uint64_t start_lvl_curr_bytes_to_compact = curr_bytes_to_compact;
-    for (auto output_lvl_f : output_level_inputs.files) {
-      curr_bytes_to_compact += output_lvl_f->compensated_file_size;
-    }
-    if (curr_bytes_to_compact > mutable_cf_options_.max_compaction_bytes) {
-      // Constraint 2
-      tmp_start_level_inputs.clear();
-      return;
-    }
-
-    start_level_inputs_.files = tmp_start_level_inputs.files;
-    // Constraint 3
-    if (start_lvl_curr_bytes_to_compact > start_lvl_max_bytes_to_compact) {
-      return;
-    }
-  }
-}
-
 bool LevelCompactionBuilder::SetupOtherInputsIfNeeded() {
   // Setup input files from output level. For output to L0, we only compact
   // spans of files that do not interact with any pending compactions, so don't
   // need to consider other levels.
   if (output_level_ != 0) {
     output_level_inputs_.level = output_level_;
-    bool round_robin_expanding =
-        ioptions_.compaction_pri == kRoundRobin &&
-        compaction_reason_ == CompactionReason::kLevelMaxLevelSize;
-    if (round_robin_expanding) {
-      SetupOtherFilesWithRoundRobinExpansion();
-    }
     if (!is_l0_trivial_move_ &&
         !compaction_picker_->SetupOtherInputs(
             cf_name_, mutable_cf_options_, vstorage_, &start_level_inputs_,
-            &output_level_inputs_, &parent_index_, base_index_,
-            round_robin_expanding)) {
+            &output_level_inputs_, &parent_index_, base_index_)) {
       return false;
     }
 
@@ -662,14 +532,9 @@ bool LevelCompactionBuilder::TryExtendNonL0TrivialMove(int start_index) {
         break;
       }
       if (i < static_cast<int>(level_files.size()) - 1 &&
-          compaction_picker_->icmp()
-                  ->user_comparator()
-                  ->CompareWithoutTimestamp(
-                      next_file->largest.user_key(),
-                      level_files[i + 1]->smallest.user_key()) == 0) {
-        TEST_SYNC_POINT_CALLBACK(
-            "LevelCompactionBuilder::TryExtendNonL0TrivialMove:NoCleanCut",
-            nullptr);
+          compaction_picker_->icmp()->user_comparator()->Compare(
+              next_file->largest.user_key(),
+              level_files[i + 1]->smallest.user_key()) == 0) {
         // Not a clean up after adding the next file. Skip.
         break;
       }
@@ -741,6 +606,9 @@ bool LevelCompactionBuilder::PickFileToCompact() {
       // user-key overlap.
       start_level_inputs_.clear();
 
+      // To ensure every file is selcted in a round-robin manner, we cannot
+      // skip the current file. So we return false and wait for the next time
+      // we can pick this file to compact
       if (ioptions_.compaction_pri == kRoundRobin) {
         return false;
       }
@@ -773,7 +641,6 @@ bool LevelCompactionBuilder::PickFileToCompact() {
         continue;
       }
     }
-
     base_index_ = index;
     break;
   }

db/compaction/compaction_picker_test.cc

@@ -27,7 +27,7 @@ class CountingLogger : public Logger {
   size_t log_count;
 };
 
-class CompactionPickerTestBase : public testing::Test {
+class CompactionPickerTest : public testing::Test {
  public:
   const Comparator* ucmp_;
   InternalKeyComparator icmp_;
@@ -49,10 +49,9 @@ class CompactionPickerTestBase : public testing::Test {
   std::vector<CompactionInputFiles> input_files_;
   int compaction_level_start_;
 
-  explicit CompactionPickerTestBase(const Comparator* _ucmp)
-      : ucmp_(_ucmp),
+  CompactionPickerTest()
+      : ucmp_(BytewiseComparator()),
         icmp_(ucmp_),
-        options_(CreateOptions(ucmp_)),
         ioptions_(options_),
         mutable_cf_options_(options_),
         mutable_db_options_(),
@@ -72,7 +71,7 @@ class CompactionPickerTestBase : public testing::Test {
                                     std::numeric_limits<uint64_t>::max());
   }
 
-  ~CompactionPickerTestBase() override {}
+  ~CompactionPickerTest() override {}
 
   void NewVersionStorage(int num_levels, CompactionStyle style) {
     DeleteVersionStorage();
@@ -98,17 +97,12 @@ class CompactionPickerTestBase : public testing::Test {
     input_files_.clear();
   }
 
-  // REQUIRES: smallest and largest are c-style strings ending with '\0'
   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,
-           Slice ts_of_smallest = Slice(), Slice ts_of_largest = Slice()) {
-    assert(ts_of_smallest.size() == ucmp_->timestamp_size());
-    assert(ts_of_largest.size() == ucmp_->timestamp_size());
-
+           uint64_t oldest_ancestor_time = kUnknownOldestAncesterTime) {
     VersionStorageInfo* vstorage;
     if (temp_vstorage_) {
       vstorage = temp_vstorage_.get();
@@ -116,46 +110,20 @@ class CompactionPickerTestBase : public testing::Test {
       vstorage = vstorage_.get();
     }
     assert(level < vstorage->num_levels());
-    char* smallest_key_buf = nullptr;
-    char* largest_key_buf = nullptr;
-
-    if (!ts_of_smallest.empty()) {
-      smallest_key_buf = new char[strlen(smallest) + ucmp_->timestamp_size()];
-      memcpy(smallest_key_buf, smallest, strlen(smallest));
-      memcpy(smallest_key_buf + strlen(smallest), ts_of_smallest.data(),
-             ucmp_->timestamp_size());
-      largest_key_buf = new char[strlen(largest) + ucmp_->timestamp_size()];
-      memcpy(largest_key_buf, largest, strlen(largest));
-      memcpy(largest_key_buf + strlen(largest), ts_of_largest.data(),
-             ucmp_->timestamp_size());
-    }
-
-    InternalKey smallest_ikey = InternalKey(
-        smallest_key_buf ? Slice(smallest_key_buf,
-                                 ucmp_->timestamp_size() + strlen(smallest))
-                         : smallest,
-        smallest_seq, kTypeValue);
-    InternalKey largest_ikey = InternalKey(
-        largest_key_buf
-            ? Slice(largest_key_buf, ucmp_->timestamp_size() + strlen(largest))
-            : largest,
-        largest_seq, kTypeValue);
-
     FileMetaData* f = new FileMetaData(
-        file_number, path_id, file_size, smallest_ikey, largest_ikey,
-        smallest_seq, largest_seq, marked_for_compact, temperature,
-        kInvalidBlobFileNumber, kUnknownOldestAncesterTime,
-        kUnknownFileCreationTime, kUnknownFileChecksum,
-        kUnknownFileChecksumFuncName, kNullUniqueId64x2);
+        file_number, path_id, file_size,
+        InternalKey(smallest, smallest_seq, kTypeValue),
+        InternalKey(largest, largest_seq, kTypeValue), smallest_seq,
+        largest_seq, marked_for_compact, temperature, kInvalidBlobFileNumber,
+        kUnknownOldestAncesterTime, kUnknownFileCreationTime,
+        kUnknownFileChecksum, kUnknownFileChecksumFuncName,
+        kDisableUserTimestamp, kDisableUserTimestamp, kNullUniqueId64x2);
     f->compensated_file_size =
         (compensated_file_size != 0) ? compensated_file_size : file_size;
     f->oldest_ancester_time = oldest_ancestor_time;
     vstorage->AddFile(level, f);
     files_.emplace_back(f);
     file_map_.insert({file_number, {f, level}});
-
-    delete[] smallest_key_buf;
-    delete[] largest_key_buf;
   }
 
   void SetCompactionInputFilesLevels(int level_count, int start_level) {
@@ -188,31 +156,9 @@ class CompactionPickerTestBase : public testing::Test {
   }
 
  private:
-  Options CreateOptions(const Comparator* ucmp) const {
-    Options opts;
-    opts.comparator = ucmp;
-    return opts;
-  }
-
   std::unique_ptr<VersionStorageInfo> temp_vstorage_;
 };
 
-class CompactionPickerTest : public CompactionPickerTestBase {
- public:
-  explicit CompactionPickerTest()
-      : CompactionPickerTestBase(BytewiseComparator()) {}
-
-  ~CompactionPickerTest() override {}
-};
-
-class CompactionPickerU64TsTest : public CompactionPickerTestBase {
- public:
-  explicit CompactionPickerU64TsTest()
-      : CompactionPickerTestBase(test::BytewiseComparatorWithU64TsWrapper()) {}
-
-  ~CompactionPickerU64TsTest() override {}
-};
-
 TEST_F(CompactionPickerTest, Empty) {
   NewVersionStorage(6, kCompactionStyleLevel);
   UpdateVersionStorageInfo();
@@ -1372,7 +1318,7 @@ TEST_F(CompactionPickerTest, CompactionPriRoundRobin) {
   std::vector<uint32_t> selected_files = {8U, 6U, 6U};
 
   ioptions_.compaction_pri = kRoundRobin;
-  mutable_cf_options_.max_bytes_for_level_base = 12000000;
+  mutable_cf_options_.max_bytes_for_level_base = 10000000;
   mutable_cf_options_.max_bytes_for_level_multiplier = 10;
   for (size_t i = 0; i < test_cursors.size(); i++) {
     // start a brand new version in each test.
@@ -1396,9 +1342,6 @@ TEST_F(CompactionPickerTest, CompactionPriRoundRobin) {
             cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
             &log_buffer_));
     ASSERT_TRUE(compaction.get() != nullptr);
-    // Since the max bytes for level 2 is 120M, picking one file to compact
-    // makes the post-compaction level size less than 120M, there is exactly one
-    // file picked for round-robin compaction
     ASSERT_EQ(1U, compaction->num_input_files(0));
     ASSERT_EQ(selected_files[i], compaction->input(0, 0)->fd.GetNumber());
     // release the version storage
@@ -1406,132 +1349,6 @@ TEST_F(CompactionPickerTest, CompactionPriRoundRobin) {
   }
 }
 
-TEST_F(CompactionPickerTest, CompactionPriMultipleFilesRoundRobin1) {
-  ioptions_.compaction_pri = kRoundRobin;
-  mutable_cf_options_.max_compaction_bytes = 100000000u;
-  mutable_cf_options_.max_bytes_for_level_base = 120;
-  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-  // start a brand new version in each test.
-  NewVersionStorage(6, kCompactionStyleLevel);
-  vstorage_->ResizeCompactCursors(6);
-  // Set the cursor (file picking should start with 7U)
-  vstorage_->AddCursorForOneLevel(2, InternalKey("199", 100, kTypeValue));
-  Add(2, 6U, "150", "199", 500U);
-  Add(2, 7U, "200", "249", 500U);
-  Add(2, 8U, "300", "600", 500U);
-  Add(2, 9U, "700", "800", 500U);
-  Add(2, 10U, "850", "950", 500U);
-
-  Add(3, 26U, "130", "165", 600U);
-  Add(3, 27U, "166", "170", 600U);
-  Add(3, 28U, "270", "340", 600U);
-  Add(3, 29U, "401", "500", 600U);
-  Add(3, 30U, "601", "800", 600U);
-  Add(3, 31U, "830", "890", 600U);
-  UpdateVersionStorageInfo();
-  LevelCompactionPicker local_level_compaction_picker =
-      LevelCompactionPicker(ioptions_, &icmp_);
-  std::unique_ptr<Compaction> compaction(
-      local_level_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-
-  // The maximum compaction bytes is very large in this case so we can igore its
-  // constraint in this test case. The maximum bytes for level 2 is 1200
-  // bytes, and thus at least 3 files should be picked so that the bytes in
-  // level 2 is less than the maximum
-  ASSERT_EQ(3U, compaction->num_input_files(0));
-  ASSERT_EQ(7U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(8U, compaction->input(0, 1)->fd.GetNumber());
-  ASSERT_EQ(9U, compaction->input(0, 2)->fd.GetNumber());
-  // release the version storage
-  DeleteVersionStorage();
-}
-
-TEST_F(CompactionPickerTest, CompactionPriMultipleFilesRoundRobin2) {
-  ioptions_.compaction_pri = kRoundRobin;
-  mutable_cf_options_.max_compaction_bytes = 2500u;
-  mutable_cf_options_.max_bytes_for_level_base = 120;
-  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-  // start a brand new version in each test.
-  NewVersionStorage(6, kCompactionStyleLevel);
-  vstorage_->ResizeCompactCursors(6);
-  // Set the cursor (file picking should start with 6U)
-  vstorage_->AddCursorForOneLevel(2, InternalKey("1000", 100, kTypeValue));
-  Add(2, 6U, "150", "199", 500U);  // Overlap with 26U, 27U
-  Add(2, 7U, "200", "249", 500U);  // Overlap with 27U
-  Add(2, 8U, "300", "600", 500U);  // Overlap with 28U, 29U
-  Add(2, 9U, "700", "800", 500U);
-  Add(2, 10U, "850", "950", 500U);
-
-  Add(3, 26U, "130", "165", 600U);
-  Add(3, 27U, "166", "230", 600U);
-  Add(3, 28U, "270", "340", 600U);
-  Add(3, 29U, "401", "500", 600U);
-  Add(3, 30U, "601", "800", 600U);
-  Add(3, 31U, "830", "890", 600U);
-  UpdateVersionStorageInfo();
-  LevelCompactionPicker local_level_compaction_picker =
-      LevelCompactionPicker(ioptions_, &icmp_);
-  std::unique_ptr<Compaction> compaction(
-      local_level_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-
-  // The maximum compaction bytes is only 2500 bytes now. Even though we are
-  // required to choose 3 files so that the post-compaction level size is less
-  // than 1200 bytes. We cannot pick 3 files to compact since the maximum
-  // compaction size is 2500. After picking files 6U and 7U, the number of
-  // compaction bytes has reached 2200, and thus no more space to add another
-  // input file with 50M bytes.
-  ASSERT_EQ(2U, compaction->num_input_files(0));
-  ASSERT_EQ(6U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(7U, compaction->input(0, 1)->fd.GetNumber());
-  // release the version storage
-  DeleteVersionStorage();
-}
-
-TEST_F(CompactionPickerTest, CompactionPriMultipleFilesRoundRobin3) {
-  ioptions_.compaction_pri = kRoundRobin;
-  mutable_cf_options_.max_compaction_bytes = 1000000u;
-  mutable_cf_options_.max_bytes_for_level_base = 120;
-  mutable_cf_options_.max_bytes_for_level_multiplier = 10;
-  // start a brand new version in each test.
-  NewVersionStorage(6, kCompactionStyleLevel);
-  vstorage_->ResizeCompactCursors(6);
-  // Set the cursor (file picking should start with 9U)
-  vstorage_->AddCursorForOneLevel(2, InternalKey("700", 100, kTypeValue));
-  Add(2, 6U, "150", "199", 500U);
-  Add(2, 7U, "200", "249", 500U);
-  Add(2, 8U, "300", "600", 500U);
-  Add(2, 9U, "700", "800", 500U);
-  Add(2, 10U, "850", "950", 500U);
-
-  Add(3, 26U, "130", "165", 600U);
-  Add(3, 27U, "166", "170", 600U);
-  Add(3, 28U, "270", "340", 600U);
-  Add(3, 29U, "401", "500", 600U);
-  Add(3, 30U, "601", "800", 600U);
-  Add(3, 31U, "830", "890", 600U);
-  UpdateVersionStorageInfo();
-  LevelCompactionPicker local_level_compaction_picker =
-      LevelCompactionPicker(ioptions_, &icmp_);
-  std::unique_ptr<Compaction> compaction(
-      local_level_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-  ASSERT_TRUE(compaction.get() != nullptr);
-
-  // Cannot pick more files since we reach the last file in level 2
-  ASSERT_EQ(2U, compaction->num_input_files(0));
-  ASSERT_EQ(9U, compaction->input(0, 0)->fd.GetNumber());
-  ASSERT_EQ(10U, compaction->input(0, 1)->fd.GetNumber());
-  // release the version storage
-  DeleteVersionStorage();
-}
-
 TEST_F(CompactionPickerTest, CompactionPriMinOverlappingManyFiles) {
   NewVersionStorage(6, kCompactionStyleLevel);
   ioptions_.compaction_pri = kMinOverlappingRatio;
@@ -3230,249 +3047,6 @@ TEST_F(CompactionPickerTest, UniversalMarkedManualCompaction) {
   ASSERT_EQ(0U, vstorage_->FilesMarkedForCompaction().size());
 }
 
-TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionNonLastLevel) {
-  // This test make sure size amplification compaction could still be triggered
-  // if the last sorted run is not the last level.
-  const uint64_t kFileSize = 100000;
-  const int kNumLevels = 7;
-  const int kLastLevel = kNumLevels - 1;
-
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.preclude_last_level_data_seconds = 1000;
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-
-  NewVersionStorage(kNumLevels, kCompactionStyleUniversal);
-  Add(0, 100U, "100", "300", 1 * kFileSize);
-  Add(0, 101U, "200", "400", 1 * kFileSize);
-  Add(4, 90U, "100", "600", 4 * kFileSize);
-  Add(5, 80U, "200", "300", 2 * kFileSize);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(
-      universal_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-
-  // Make sure it's a size amp compaction and includes all files
-  ASSERT_EQ(compaction->compaction_reason(),
-            CompactionReason::kUniversalSizeAmplification);
-  ASSERT_EQ(compaction->output_level(), kLastLevel);
-  ASSERT_EQ(compaction->input_levels(0)->num_files, 2);
-  ASSERT_EQ(compaction->input_levels(4)->num_files, 1);
-  ASSERT_EQ(compaction->input_levels(5)->num_files, 1);
-}
-
-TEST_F(CompactionPickerTest, UniversalSizeRatioTierCompactionLastLevel) {
-  // This test makes sure the size amp calculation skips the last level (L6), so
-  // size amp compaction is not triggered, instead a size ratio compaction is
-  // triggered.
-  const uint64_t kFileSize = 100000;
-  const int kNumLevels = 7;
-  const int kLastLevel = kNumLevels - 1;
-  const int kPenultimateLevel = kLastLevel - 1;
-
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.preclude_last_level_data_seconds = 1000;
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-
-  NewVersionStorage(kNumLevels, kCompactionStyleUniversal);
-  Add(0, 100U, "100", "300", 1 * kFileSize);
-  Add(0, 101U, "200", "400", 1 * kFileSize);
-  Add(5, 90U, "100", "600", 4 * kFileSize);
-  Add(6, 80U, "200", "300", 2 * kFileSize);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(
-      universal_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-
-  // Internally, size amp compaction is evaluated before size ratio compaction.
-  // Here to make sure it's size ratio compaction instead of size amp
-  ASSERT_EQ(compaction->compaction_reason(),
-            CompactionReason::kUniversalSizeRatio);
-  ASSERT_EQ(compaction->output_level(), kPenultimateLevel - 1);
-  ASSERT_EQ(compaction->input_levels(0)->num_files, 2);
-  ASSERT_EQ(compaction->input_levels(5)->num_files, 0);
-  ASSERT_EQ(compaction->input_levels(6)->num_files, 0);
-}
-
-TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionNotSuport) {
-  // Tiered compaction only support level_num > 2 (otherwise the penultimate
-  // level is going to be level 0, which may make thing more complicated), so
-  // when there's only 2 level, still treating level 1 as the last level for
-  // size amp compaction
-  const uint64_t kFileSize = 100000;
-  const int kNumLevels = 2;
-  const int kLastLevel = kNumLevels - 1;
-
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.preclude_last_level_data_seconds = 1000;
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-
-  NewVersionStorage(kNumLevels, kCompactionStyleUniversal);
-  Add(0, 100U, "100", "300", 1 * kFileSize);
-  Add(0, 101U, "200", "400", 1 * kFileSize);
-  Add(0, 90U, "100", "600", 4 * kFileSize);
-  Add(1, 80U, "200", "300", 2 * kFileSize);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(
-      universal_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-
-  // size amp compaction is still triggered even preclude_last_level is set
-  ASSERT_EQ(compaction->compaction_reason(),
-            CompactionReason::kUniversalSizeAmplification);
-  ASSERT_EQ(compaction->output_level(), kLastLevel);
-  ASSERT_EQ(compaction->input_levels(0)->num_files, 3);
-  ASSERT_EQ(compaction->input_levels(1)->num_files, 1);
-}
-
-TEST_F(CompactionPickerTest, UniversalSizeAmpTierCompactionLastLevel) {
-  // This test makes sure the size amp compaction for tiered storage could still
-  // be triggered, but only for non-last-level files
-  const uint64_t kFileSize = 100000;
-  const int kNumLevels = 7;
-  const int kLastLevel = kNumLevels - 1;
-  const int kPenultimateLevel = kLastLevel - 1;
-
-  ioptions_.compaction_style = kCompactionStyleUniversal;
-  ioptions_.preclude_last_level_data_seconds = 1000;
-  mutable_cf_options_.compaction_options_universal
-      .max_size_amplification_percent = 200;
-  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-
-  NewVersionStorage(kNumLevels, kCompactionStyleUniversal);
-  Add(0, 100U, "100", "300", 3 * kFileSize);
-  Add(0, 101U, "200", "400", 2 * kFileSize);
-  Add(5, 90U, "100", "600", 2 * kFileSize);
-  Add(6, 80U, "200", "300", 2 * kFileSize);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(
-      universal_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-
-  // It's a Size Amp compaction, but doesn't include the last level file and
-  // output to the penultimate level.
-  ASSERT_EQ(compaction->compaction_reason(),
-            CompactionReason::kUniversalSizeAmplification);
-  ASSERT_EQ(compaction->output_level(), kPenultimateLevel);
-  ASSERT_EQ(compaction->input_levels(0)->num_files, 2);
-  ASSERT_EQ(compaction->input_levels(5)->num_files, 1);
-  ASSERT_EQ(compaction->input_levels(6)->num_files, 0);
-}
-
-TEST_F(CompactionPickerU64TsTest, Overlap) {
-  int num_levels = ioptions_.num_levels;
-  NewVersionStorage(num_levels, kCompactionStyleLevel);
-
-  constexpr int level = 0;
-  constexpr uint64_t file_number = 20ULL;
-  constexpr char smallest[4] = "500";
-  constexpr char largest[4] = "600";
-  constexpr uint64_t ts_of_smallest = 12345ULL;
-  constexpr uint64_t ts_of_largest = 56789ULL;
-
-  {
-    std::string ts1;
-    PutFixed64(&ts1, ts_of_smallest);
-    std::string ts2;
-    PutFixed64(&ts2, ts_of_largest);
-    Add(level, file_number, smallest, largest,
-        /*file_size=*/1U, /*path_id=*/0,
-        /*smallest_seq=*/100, /*largest_seq=*/100, /*compensated_file_size=*/0,
-        /*marked_for_compact=*/false, /*temperature=*/Temperature::kUnknown,
-        /*oldest_ancestor_time=*/kUnknownOldestAncesterTime, ts1, ts2);
-    UpdateVersionStorageInfo();
-  }
-
-  std::unordered_set<uint64_t> input{file_number};
-
-  std::vector<CompactionInputFiles> input_files;
-  ASSERT_OK(level_compaction_picker.GetCompactionInputsFromFileNumbers(
-      &input_files, &input, vstorage_.get(), CompactionOptions()));
-  std::unique_ptr<Compaction> comp1(level_compaction_picker.CompactFiles(
-      CompactionOptions(), input_files, level, vstorage_.get(),
-      mutable_cf_options_, mutable_db_options_, /*output_path_id=*/0));
-
-  {
-    // [600, ts=50000] to [600, ts=50000] is the range to check.
-    // ucmp->Compare(smallest_user_key, c->GetLargestUserKey()) > 0, but
-    // ucmp->CompareWithoutTimestamp(smallest_user_key,
-    //                               c->GetLargestUserKey()) == 0.
-    // Should still be considered overlapping.
-    std::string user_key_with_ts1(largest);
-    PutFixed64(&user_key_with_ts1, ts_of_largest - 1);
-    std::string user_key_with_ts2(largest);
-    PutFixed64(&user_key_with_ts2, ts_of_largest - 1);
-    ASSERT_TRUE(level_compaction_picker.RangeOverlapWithCompaction(
-        user_key_with_ts1, user_key_with_ts2, level));
-  }
-  {
-    // [500, ts=60000] to [500, ts=60000] is the range to check.
-    // ucmp->Compare(largest_user_key, c->GetSmallestUserKey()) < 0, but
-    // ucmp->CompareWithoutTimestamp(largest_user_key,
-    //                               c->GetSmallestUserKey()) == 0.
-    // Should still be considered overlapping.
-    std::string user_key_with_ts1(smallest);
-    PutFixed64(&user_key_with_ts1, ts_of_smallest + 1);
-    std::string user_key_with_ts2(smallest);
-    PutFixed64(&user_key_with_ts2, ts_of_smallest + 1);
-    ASSERT_TRUE(level_compaction_picker.RangeOverlapWithCompaction(
-        user_key_with_ts1, user_key_with_ts2, level));
-  }
-}
-
-TEST_F(CompactionPickerU64TsTest, CannotTrivialMoveUniversal) {
-  constexpr uint64_t kFileSize = 100000;
-
-  mutable_cf_options_.level0_file_num_compaction_trigger = 2;
-  mutable_cf_options_.compaction_options_universal.allow_trivial_move = true;
-  NewVersionStorage(1, kCompactionStyleUniversal);
-  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
-  UpdateVersionStorageInfo();
-  // must return false when there's no files.
-  ASSERT_FALSE(universal_compaction_picker.NeedsCompaction(vstorage_.get()));
-
-  std::string ts1;
-  PutFixed64(&ts1, 9000);
-  std::string ts2;
-  PutFixed64(&ts2, 8000);
-  std::string ts3;
-  PutFixed64(&ts3, 7000);
-  std::string ts4;
-  PutFixed64(&ts4, 6000);
-
-  NewVersionStorage(3, kCompactionStyleUniversal);
-  // A compaction should be triggered and pick file 2
-  Add(1, 1U, "150", "150", kFileSize, /*path_id=*/0, /*smallest_seq=*/100,
-      /*largest_seq=*/100, /*compensated_file_size=*/kFileSize,
-      /*marked_for_compact=*/false, Temperature::kUnknown,
-      kUnknownOldestAncesterTime, ts1, ts2);
-  Add(2, 2U, "150", "150", kFileSize, /*path_id=*/0, /*smallest_seq=*/100,
-      /*largest_seq=*/100, /*compensated_file_size=*/kFileSize,
-      /*marked_for_compact=*/false, Temperature::kUnknown,
-      kUnknownOldestAncesterTime, ts3, ts4);
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(
-      universal_compaction_picker.PickCompaction(
-          cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-          &log_buffer_));
-  assert(compaction);
-  ASSERT_TRUE(!compaction->is_trivial_move());
-}
-
 class PerKeyPlacementCompactionPickerTest
     : public CompactionPickerTest,
       public testing::WithParamInterface<bool> {

db/compaction/compaction_picker_universal.cc

@@ -106,9 +106,6 @@ class UniversalCompactionBuilder {
   Compaction* PickCompactionToOldest(size_t start_index,
                                      CompactionReason compaction_reason);
 
-  Compaction* PickCompactionWithSortedRunRange(
-      size_t start_index, size_t end_index, CompactionReason compaction_reason);
-
   // Try to pick periodic compaction. The caller should only call it
   // if there is at least one file marked for periodic compaction.
   // null will be returned if no such a compaction can be formed
@@ -164,8 +161,8 @@ struct SmallestKeyHeapComparator {
   explicit SmallestKeyHeapComparator(const Comparator* ucmp) { ucmp_ = ucmp; }
 
   bool operator()(InputFileInfo i1, InputFileInfo i2) const {
-    return (ucmp_->CompareWithoutTimestamp(i1.f->smallest.user_key(),
-                                           i2.f->smallest.user_key()) > 0);
+    return (ucmp_->Compare(i1.f->smallest.user_key(),
+                           i2.f->smallest.user_key()) > 0);
   }
 
  private:
@@ -249,13 +246,13 @@ bool UniversalCompactionBuilder::IsInputFilesNonOverlapping(Compaction* c) {
       prev = curr;
       first_iter = 0;
     } else {
-      if (comparator->CompareWithoutTimestamp(
-              prev.f->largest.user_key(), curr.f->smallest.user_key()) >= 0) {
+      if (comparator->Compare(prev.f->largest.user_key(),
+                              curr.f->smallest.user_key()) >= 0) {
         // found overlapping files, return false
         return false;
       }
-      assert(comparator->CompareWithoutTimestamp(
-                 curr.f->largest.user_key(), prev.f->largest.user_key()) > 0);
+      assert(comparator->Compare(curr.f->largest.user_key(),
+                                 prev.f->largest.user_key()) > 0);
       prev = curr;
     }
 
@@ -755,9 +752,9 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSortedRuns(
                                             kCompactionStyleUniversal),
                         GetMaxOverlappingBytes(), path_id,
                         GetCompressionType(vstorage_, mutable_cf_options_,
-                                           output_level, 1, enable_compression),
+                                           start_level, 1, enable_compression),
                         GetCompressionOptions(mutable_cf_options_, vstorage_,
-                                              output_level, enable_compression),
+                                              start_level, enable_compression),
                         Temperature::kUnknown,
                         /* max_subcompactions */ 0, grandparents,
                         /* is manual */ false, /* trim_ts */ "", score_,
@@ -814,20 +811,8 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
         cf_name_.c_str(), file_num_buf, start_index, " to reduce size amp.\n");
   }
 
-  // size of the base sorted run for size amp calculation
-  uint64_t base_sr_size = sorted_runs_.back().size;
-  size_t sr_end_idx = sorted_runs_.size() - 1;
-  // If tiered compaction is enabled and the last sorted run is the last level
-  if (ioptions_.preclude_last_level_data_seconds > 0 &&
-      ioptions_.num_levels > 2 &&
-      sorted_runs_.back().level == ioptions_.num_levels - 1 &&
-      sorted_runs_.size() > 1) {
-    sr_end_idx = sorted_runs_.size() - 2;
-    base_sr_size = sorted_runs_[sr_end_idx].size;
-  }
-
   // keep adding up all the remaining files
-  for (size_t loop = start_index; loop < sr_end_idx; loop++) {
+  for (size_t loop = start_index; loop + 1 < sorted_runs_.size(); loop++) {
     sr = &sorted_runs_[loop];
     if (sr->being_compacted) {
       // TODO with incremental compaction is supported, we might want to
@@ -847,20 +832,23 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
     return nullptr;
   }
 
+  // size of earliest file
+  uint64_t earliest_file_size = sorted_runs_.back().size;
+
   // size amplification = percentage of additional size
-  if (candidate_size * 100 < ratio * base_sr_size) {
+  if (candidate_size * 100 < ratio * earliest_file_size) {
     ROCKS_LOG_BUFFER(
         log_buffer_,
         "[%s] Universal: size amp not needed. newer-files-total-size %" PRIu64
         " earliest-file-size %" PRIu64,
-        cf_name_.c_str(), candidate_size, base_sr_size);
+        cf_name_.c_str(), candidate_size, earliest_file_size);
     return nullptr;
   } else {
     ROCKS_LOG_BUFFER(
         log_buffer_,
         "[%s] Universal: size amp needed. newer-files-total-size %" PRIu64
         " earliest-file-size %" PRIu64,
-        cf_name_.c_str(), candidate_size, base_sr_size);
+        cf_name_.c_str(), candidate_size, earliest_file_size);
   }
   // Since incremental compaction can't include more than second last
   // level, it can introduce penalty, compared to full compaction. We
@@ -872,7 +860,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
   // This also prevent the case when compaction falls behind and we
   // need to compact more levels for compactions to catch up.
   if (mutable_cf_options_.compaction_options_universal.incremental) {
-    double fanout_threshold = static_cast<double>(base_sr_size) /
+    double fanout_threshold = static_cast<double>(earliest_file_size) /
                               static_cast<double>(candidate_size) * 1.8;
     Compaction* picked = PickIncrementalForReduceSizeAmp(fanout_threshold);
     if (picked != nullptr) {
@@ -881,8 +869,8 @@ Compaction* UniversalCompactionBuilder::PickCompactionToReduceSizeAmp() {
       return picked;
     }
   }
-  return PickCompactionWithSortedRunRange(
-      start_index, sr_end_idx, CompactionReason::kUniversalSizeAmplification);
+  return PickCompactionToOldest(start_index,
+                                CompactionReason::kUniversalSizeAmplification);
 }
 
 Compaction* UniversalCompactionBuilder::PickIncrementalForReduceSizeAmp(
@@ -1245,17 +1233,11 @@ Compaction* UniversalCompactionBuilder::PickDeleteTriggeredCompaction() {
 
 Compaction* UniversalCompactionBuilder::PickCompactionToOldest(
     size_t start_index, CompactionReason compaction_reason) {
-  return PickCompactionWithSortedRunRange(start_index, sorted_runs_.size() - 1,
-                                          compaction_reason);
-}
-
-Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
-    size_t start_index, size_t end_index, CompactionReason compaction_reason) {
   assert(start_index < sorted_runs_.size());
 
   // Estimate total file size
   uint64_t estimated_total_size = 0;
-  for (size_t loop = start_index; loop <= end_index; loop++) {
+  for (size_t loop = start_index; loop < sorted_runs_.size(); loop++) {
     estimated_total_size += sorted_runs_[loop].size;
   }
   uint32_t path_id =
@@ -1266,7 +1248,7 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
   for (size_t i = 0; i < inputs.size(); ++i) {
     inputs[i].level = start_level + static_cast<int>(i);
   }
-  for (size_t loop = start_index; loop <= end_index; loop++) {
+  for (size_t loop = start_index; loop < sorted_runs_.size(); loop++) {
     auto& picking_sr = sorted_runs_[loop];
     if (picking_sr.level == 0) {
       FileMetaData* f = picking_sr.file;
@@ -1297,19 +1279,12 @@ Compaction* UniversalCompactionBuilder::PickCompactionWithSortedRunRange(
                      file_num_buf);
   }
 
-  int output_level;
-  if (end_index == sorted_runs_.size() - 1) {
-    // output files at the last level, unless it's reserved
-    output_level = vstorage_->num_levels() - 1;
-    // last level is reserved for the files ingested behind
-    if (ioptions_.allow_ingest_behind) {
-      assert(output_level > 1);
-      output_level--;
-    }
-  } else {
-    // if it's not including all sorted_runs, it can only output to the level
-    // above the `end_index + 1` sorted_run.
-    output_level = sorted_runs_[end_index + 1].level - 1;
+  // output files at the bottom most level, unless it's reserved
+  int output_level = vstorage_->num_levels() - 1;
+  // last level is reserved for the files ingested behind
+  if (ioptions_.allow_ingest_behind) {
+    assert(output_level > 1);
+    output_level--;
   }
 
   // We never check size for

db/compaction/compaction_service_job.cc

@@ -47,10 +47,10 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
   compaction_input.db_options =
       BuildDBOptions(db_options_, mutable_db_options_copy_);
   compaction_input.snapshots = existing_snapshots_;
-  compaction_input.has_begin = sub_compact->start.has_value();
+  compaction_input.has_begin = sub_compact->start;
   compaction_input.begin =
       compaction_input.has_begin ? sub_compact->start->ToString() : "";
-  compaction_input.has_end = sub_compact->end.has_value();
+  compaction_input.has_end = sub_compact->end;
   compaction_input.end =
       compaction_input.has_end ? sub_compact->end->ToString() : "";
 
@@ -264,12 +264,8 @@ Status CompactionServiceCompactionJob::Run() {
   Slice begin = compaction_input_.begin;
   Slice end = compaction_input_.end;
   compact_->sub_compact_states.emplace_back(
-      c,
-      compaction_input_.has_begin ? std::optional<Slice>(begin)
-                                  : std::optional<Slice>(),
-      compaction_input_.has_end ? std::optional<Slice>(end)
-                                : std::optional<Slice>(),
-      /*sub_job_id*/ 0);
+      c, compaction_input_.has_begin ? &begin : nullptr,
+      compaction_input_.has_end ? &end : nullptr, /*sub_job_id*/ 0);
 
   log_buffer_->FlushBufferToLog();
   LogCompaction();

db/compaction/compaction_service_test.cc

@@ -289,6 +289,16 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
         auto s = static_cast<Status*>(status);
         *s = Status::Aborted("MyTestCompactionService failed to compact!");
       });
+
+  // tracking success unique id verification
+  std::atomic_int verify_passed{0};
+  SyncPoint::GetInstance()->SetCallBack(
+      "Version::VerifySstUniqueIds::Passed", [&](void* arg) {
+        // override job status
+        auto id = static_cast<UniqueId64x2*>(arg);
+        assert(*id != kNullUniqueId64x2);
+        verify_passed++;
+      });
   SyncPoint::GetInstance()->EnableProcessing();
 
   Status s;
@@ -314,15 +324,9 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
   }
   ASSERT_TRUE(s.IsAborted());
 
-  // Test re-open and successful unique id verification
-  std::atomic_int verify_passed{0};
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlockBasedTable::Open::PassedVerifyUniqueId", [&](void* arg) {
-        // override job status
-        auto id = static_cast<UniqueId64x2*>(arg);
-        assert(*id != kNullUniqueId64x2);
-        verify_passed++;
-      });
+  // Test verification
+  ASSERT_EQ(verify_passed, 0);
+  options.verify_sst_unique_id_in_manifest = true;
   Reopen(options);
   ASSERT_GT(verify_passed, 0);
 }

db/compaction/subcompaction_state.cc

@@ -23,6 +23,46 @@ void SubcompactionState::AggregateCompactionStats(
   }
 }
 
+void SubcompactionState::FillFilesToCutForTtl() {
+  if (compaction->immutable_options()->compaction_style !=
+          CompactionStyle::kCompactionStyleLevel ||
+      compaction->immutable_options()->compaction_pri !=
+          CompactionPri::kMinOverlappingRatio ||
+      compaction->mutable_cf_options()->ttl == 0 ||
+      compaction->num_input_levels() < 2 || compaction->bottommost_level()) {
+    return;
+  }
+
+  // We define new file with the oldest ancestor time to be younger than 1/4
+  // TTL, and an old one to be older than 1/2 TTL time.
+  int64_t temp_current_time;
+  auto get_time_status = compaction->immutable_options()->clock->GetCurrentTime(
+      &temp_current_time);
+  if (!get_time_status.ok()) {
+    return;
+  }
+  auto current_time = static_cast<uint64_t>(temp_current_time);
+  if (current_time < compaction->mutable_cf_options()->ttl) {
+    return;
+  }
+  uint64_t old_age_thres =
+      current_time - compaction->mutable_cf_options()->ttl / 2;
+
+  const std::vector<FileMetaData*>& olevel =
+      *(compaction->inputs(compaction->num_input_levels() - 1));
+  for (FileMetaData* file : olevel) {
+    // Worth filtering out by start and end?
+    uint64_t oldest_ancester_time = file->TryGetOldestAncesterTime();
+    // We put old files if they are not too small to prevent a flood
+    // of small files.
+    if (oldest_ancester_time < old_age_thres &&
+        file->fd.GetFileSize() >
+            compaction->mutable_cf_options()->target_file_size_base / 2) {
+      files_to_cut_for_ttl_.push_back(file);
+    }
+  }
+}
+
 OutputIterator SubcompactionState::GetOutputs() const {
   return OutputIterator(penultimate_level_outputs_.outputs_,
                         compaction_outputs_.outputs_);
@@ -88,6 +128,83 @@ Slice SubcompactionState::LargestUserKey() const {
   }
 }
 
+bool SubcompactionState::ShouldStopBefore(const Slice& internal_key) {
+  uint64_t curr_file_size = Current().GetCurrentOutputFileSize();
+  const InternalKeyComparator* icmp =
+      &compaction->column_family_data()->internal_comparator();
+
+  // Invalid local_output_split_key indicates that we do not need to split
+  if (local_output_split_key_ != nullptr && !is_split_) {
+    // Split occurs when the next key is larger than/equal to the cursor
+    if (icmp->Compare(internal_key, local_output_split_key_->Encode()) >= 0) {
+      is_split_ = true;
+      return true;
+    }
+  }
+
+  const std::vector<FileMetaData*>& grandparents = compaction->grandparents();
+  bool grandparant_file_switched = false;
+  // Scan to find the earliest grandparent file that contains key.
+  while (grandparent_index_ < grandparents.size() &&
+         icmp->Compare(internal_key,
+                       grandparents[grandparent_index_]->largest.Encode()) >
+             0) {
+    if (seen_key_) {
+      overlapped_bytes_ += grandparents[grandparent_index_]->fd.GetFileSize();
+      grandparant_file_switched = true;
+    }
+    assert(grandparent_index_ + 1 >= grandparents.size() ||
+           icmp->Compare(
+               grandparents[grandparent_index_]->largest.Encode(),
+               grandparents[grandparent_index_ + 1]->smallest.Encode()) <= 0);
+    grandparent_index_++;
+  }
+  seen_key_ = true;
+
+  if (grandparant_file_switched &&
+      overlapped_bytes_ + curr_file_size > compaction->max_compaction_bytes()) {
+    // Too much overlap for current output; start new output
+    overlapped_bytes_ = 0;
+    return true;
+  }
+
+  if (!files_to_cut_for_ttl_.empty()) {
+    if (cur_files_to_cut_for_ttl_ != -1) {
+      // Previous key is inside the range of a file
+      if (icmp->Compare(internal_key,
+                        files_to_cut_for_ttl_[cur_files_to_cut_for_ttl_]
+                            ->largest.Encode()) > 0) {
+        next_files_to_cut_for_ttl_ = cur_files_to_cut_for_ttl_ + 1;
+        cur_files_to_cut_for_ttl_ = -1;
+        return true;
+      }
+    } else {
+      // Look for the key position
+      while (next_files_to_cut_for_ttl_ <
+             static_cast<int>(files_to_cut_for_ttl_.size())) {
+        if (icmp->Compare(internal_key,
+                          files_to_cut_for_ttl_[next_files_to_cut_for_ttl_]
+                              ->smallest.Encode()) >= 0) {
+          if (icmp->Compare(internal_key,
+                            files_to_cut_for_ttl_[next_files_to_cut_for_ttl_]
+                                ->largest.Encode()) <= 0) {
+            // With in the current file
+            cur_files_to_cut_for_ttl_ = next_files_to_cut_for_ttl_;
+            return true;
+          }
+          // Beyond the current file
+          next_files_to_cut_for_ttl_++;
+        } else {
+          // Still fall into the gap
+          break;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
 Status SubcompactionState::AddToOutput(
     const CompactionIterator& iter,
     const CompactionFileOpenFunc& open_file_func,

db/compaction/subcompaction_state.h

@@ -10,8 +10,6 @@
 
 #pragma once
 
-#include <optional>
-
 #include "db/blob/blob_file_addition.h"
 #include "db/blob/blob_garbage_meter.h"
 #include "db/compaction/compaction.h"
@@ -54,7 +52,7 @@ class SubcompactionState {
   // The boundaries of the key-range this compaction is interested in. No two
   // sub-compactions may have overlapping key-ranges.
   // 'start' is inclusive, 'end' is exclusive, and nullptr means unbounded
-  const std::optional<Slice> start, end;
+  const Slice *start, *end;
 
   // The return status of this sub-compaction
   Status status;
@@ -119,8 +117,8 @@ class SubcompactionState {
   SubcompactionState(const SubcompactionState&) = delete;
   SubcompactionState& operator=(const SubcompactionState&) = delete;
 
-  SubcompactionState(Compaction* c, const std::optional<Slice> _start,
-                     const std::optional<Slice> _end, uint32_t _sub_job_id)
+  SubcompactionState(Compaction* c, Slice* _start, Slice* _end,
+                     uint32_t _sub_job_id)
       : compaction(c),
         start(_start),
         end(_end),
@@ -128,12 +126,21 @@ class SubcompactionState {
         compaction_outputs_(c, /*is_penultimate_level=*/false),
         penultimate_level_outputs_(c, /*is_penultimate_level=*/true) {
     assert(compaction != nullptr);
-    // Set output split key (used for RoundRobin feature) only for normal
-    // compaction_outputs, output to penultimate_level feature doesn't support
-    // RoundRobin feature (and may never going to be supported, because for
-    // RoundRobin, the data time is mostly naturally sorted, no need to have
-    // per-key placement with output_to_penultimate_level).
-    compaction_outputs_.SetOutputSlitKey(start, end);
+    const InternalKeyComparator* icmp =
+        &compaction->column_family_data()->internal_comparator();
+    const InternalKey* output_split_key = compaction->GetOutputSplitKey();
+    // Invalid output_split_key indicates that we do not need to split
+    if (output_split_key != nullptr) {
+      // We may only split the output when the cursor is in the range. Split
+      if ((end == nullptr || icmp->user_comparator()->Compare(
+                                 ExtractUserKey(output_split_key->Encode()),
+                                 ExtractUserKey(*end)) < 0) &&
+          (start == nullptr || icmp->user_comparator()->Compare(
+                                   ExtractUserKey(output_split_key->Encode()),
+                                   ExtractUserKey(*start)) > 0)) {
+        local_output_split_key_ = output_split_key;
+      }
+    }
   }
 
   SubcompactionState(SubcompactionState&& state) noexcept
@@ -146,6 +153,12 @@ class SubcompactionState {
             state.notify_on_subcompaction_completion),
         compaction_job_stats(std::move(state.compaction_job_stats)),
         sub_job_id(state.sub_job_id),
+        files_to_cut_for_ttl_(std::move(state.files_to_cut_for_ttl_)),
+        cur_files_to_cut_for_ttl_(state.cur_files_to_cut_for_ttl_),
+        next_files_to_cut_for_ttl_(state.next_files_to_cut_for_ttl_),
+        grandparent_index_(state.grandparent_index_),
+        overlapped_bytes_(state.overlapped_bytes_),
+        seen_key_(state.seen_key_),
         compaction_outputs_(std::move(state.compaction_outputs_)),
         penultimate_level_outputs_(std::move(state.penultimate_level_outputs_)),
         is_current_penultimate_level_(state.is_current_penultimate_level_),
@@ -160,6 +173,12 @@ class SubcompactionState {
            penultimate_level_outputs_.HasRangeDel();
   }
 
+  void FillFilesToCutForTtl();
+
+  // Returns true iff we should stop building the current output
+  // before processing "internal_key".
+  bool ShouldStopBefore(const Slice& internal_key);
+
   bool IsCurrentPenultimateLevel() const {
     return is_current_penultimate_level_;
   }
@@ -203,6 +222,28 @@ class SubcompactionState {
   }
 
  private:
+  // Some identified files with old oldest ancester time and the range should be
+  // isolated out so that the output file(s) in that range can be merged down
+  // for TTL and clear the timestamps for the range.
+  std::vector<FileMetaData*> files_to_cut_for_ttl_;
+  int cur_files_to_cut_for_ttl_ = -1;
+  int next_files_to_cut_for_ttl_ = 0;
+
+  // An index that used to speed up ShouldStopBefore().
+  size_t grandparent_index_ = 0;
+  // The number of bytes overlapping between the current output and
+  // grandparent files used in ShouldStopBefore().
+  uint64_t overlapped_bytes_ = 0;
+  // A flag determines whether the key has been seen in ShouldStopBefore()
+  bool seen_key_ = false;
+
+  // A flag determines if this subcompaction has been split by the cursor
+  bool is_split_ = false;
+
+  // We also maintain the output split key for each subcompaction to avoid
+  // repetitive comparison in ShouldStopBefore()
+  const InternalKey* local_output_split_key_ = nullptr;
+
   // State kept for output being generated
   CompactionOutputs compaction_outputs_;
   CompactionOutputs penultimate_level_outputs_;

db/compaction/tiered_compaction_test.cc

@@ -16,8 +16,7 @@ namespace ROCKSDB_NAMESPACE {
 
 #if !defined(ROCKSDB_LITE)
 
-class TieredCompactionTest : public DBTestBase,
-                             public testing::WithParamInterface<bool> {
+class TieredCompactionTest : public DBTestBase {
  public:
   TieredCompactionTest()
       : DBTestBase("tiered_compaction_test", /*env_do_fsync=*/true),
@@ -121,16 +120,6 @@ class TieredCompactionTest : public DBTestBase,
     pl_stats.Clear();
   }
 
-  // bottommost_temperature is renaming to last_level_temperature, set either
-  // of them should have the same effect.
-  void SetColdTemperature(Options& options) {
-    if (GetParam()) {
-      options.bottommost_temperature = Temperature::kCold;
-    } else {
-      options.last_level_temperature = Temperature::kCold;
-    }
-  }
-
  private:
   void CompareStats(uint64_t val, uint64_t expect) {
     if (expect > 0) {
@@ -170,7 +159,7 @@ class TieredCompactionTest : public DBTestBase,
   }
 };
 
-TEST_P(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
+TEST_F(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 100;
@@ -178,7 +167,7 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
 
   auto options = CurrentOptions();
   options.compaction_style = kCompactionStyleUniversal;
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.statistics = CreateDBStatistics();
   options.max_subcompactions = 10;
@@ -332,7 +321,7 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageUniversal) {
   ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 }
 
-TEST_P(TieredCompactionTest, RangeBasedTieredStorageUniversal) {
+TEST_F(TieredCompactionTest, RangeBasedTieredStorageUniversal) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 100;
@@ -340,7 +329,7 @@ TEST_P(TieredCompactionTest, RangeBasedTieredStorageUniversal) {
 
   auto options = CurrentOptions();
   options.compaction_style = kCompactionStyleUniversal;
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.statistics = CreateDBStatistics();
   options.max_subcompactions = 10;
@@ -524,14 +513,13 @@ TEST_P(TieredCompactionTest, RangeBasedTieredStorageUniversal) {
       1);
 }
 
-TEST_P(TieredCompactionTest, LevelColdRangeDelete) {
+TEST_F(TieredCompactionTest, LevelColdRangeDelete) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 100;
-  const int kLastLevel = kNumLevels - 1;
 
   auto options = CurrentOptions();
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.num_levels = kNumLevels;
   options.statistics = CreateDBStatistics();
@@ -556,13 +544,11 @@ TEST_P(TieredCompactionTest, LevelColdRangeDelete) {
   CompactRangeOptions cro;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-  ASSERT_EQ("0,1",
-            FilesPerLevel());  // bottommost but not last level file is hot
-  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
+  ASSERT_EQ("0,1", FilesPerLevel());
+  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
+  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 
-  // explicitly move the data to the last level
-  MoveFilesToLevel(kLastLevel);
+  MoveFilesToLevel(kNumLevels - 1);
 
   ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
 
@@ -630,14 +616,14 @@ class SingleKeySstPartitionerFactory : public SstPartitionerFactory {
   }
 };
 
-TEST_P(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
+TEST_F(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
   const int kNumTrigger = 4;
   const int kNumLevels = 3;
   const int kNumKeys = 10;
 
   auto factory = std::make_shared<SingleKeySstPartitionerFactory>();
   auto options = CurrentOptions();
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.num_levels = kNumLevels;
   options.statistics = CreateDBStatistics();
@@ -748,7 +734,7 @@ TEST_P(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
   ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 }
 
-TEST_P(TieredCompactionTest, UniversalRangeDelete) {
+TEST_F(TieredCompactionTest, UniversalRangeDelete) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 10;
@@ -757,7 +743,7 @@ TEST_P(TieredCompactionTest, UniversalRangeDelete) {
 
   auto options = CurrentOptions();
   options.compaction_style = kCompactionStyleUniversal;
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.statistics = CreateDBStatistics();
   options.sst_partitioner_factory = factory;
@@ -880,14 +866,14 @@ TEST_P(TieredCompactionTest, UniversalRangeDelete) {
   ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 }
 
-TEST_P(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
+TEST_F(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 100;
   const int kLastLevel = kNumLevels - 1;
 
   auto options = CurrentOptions();
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.num_levels = kNumLevels;
   options.statistics = CreateDBStatistics();
@@ -918,22 +904,23 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
   }
   ASSERT_OK(dbfull()->WaitForCompact(true));
 
-  // non last level is hot
+  // non-last-level compaction doesn't support per_key_placement
   ASSERT_EQ("0,1", FilesPerLevel());
-  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
+  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
+  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 
   expect_stats[1].Add(kBasicCompStats);
   expect_stats[1].Add(kBasicPerLevelStats);
   expect_stats[1].ResetCompactionReason(CompactionReason::kLevelL0FilesNum);
   VerifyCompactionStats(expect_stats, expect_pl_stats);
 
-  // move all data to the last level
   MoveFilesToLevel(kLastLevel);
 
   ResetAllStats(expect_stats, expect_pl_stats);
 
-  // The compaction won't move the data up
+  // the data should be all hot, and it's a last level compaction, but all
+  // sequence numbers have been zeroed out, so they're still treated as old
+  // data.
   CompactRangeOptions cro;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
@@ -986,19 +973,49 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
 
   // move forward the cold_seq, try to split the data into cold and hot, but in
   // this case it's unsafe to split the data
-  // because it's non-last-level but bottommost file, the sequence number will
-  // be zeroed out and lost the time information (with
-  // `level_compaction_dynamic_level_bytes` or Universal Compaction, it should
-  // be rare.)
-  // TODO(zjay): ideally we should avoid zero out non-last-level bottommost file
   latest_cold_seq = seq_history[1];
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
-  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
-  ASSERT_EQ(GetSstSizeHelper(Temperature::kCold), 0);
+  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
+  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 
   seq_history.clear();
 
+  // Add new data again
+  for (int i = 0; i < kNumTrigger; i++) {
+    for (int j = 0; j < kNumKeys; j++) {
+      ASSERT_OK(Put(Key(i * 10 + j), "value" + std::to_string(i)));
+    }
+    ASSERT_OK(Flush());
+    seq_history.emplace_back(dbfull()->GetLatestSequenceNumber());
+  }
+  ASSERT_OK(dbfull()->WaitForCompact(true));
+
+  ResetAllStats(expect_stats, expect_pl_stats);
+
+  // Try to split the last level cold data into hot and cold, which
+  // is not supported
+  latest_cold_seq = seq_history[0];
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  ASSERT_EQ("0,0,0,0,0,1", FilesPerLevel());
+  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown), 0);
+  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
+
+  auto comp_stats = kBasicCompStats;
+  comp_stats.ResetCompactionReason(CompactionReason::kManualCompaction);
+  const int bottommost_level = 5;
+  expect_stats[bottommost_level].Add(comp_stats);
+  expect_stats[bottommost_level].Add(
+      comp_stats);  // bottommost level has 2 compactions
+  expect_stats[bottommost_level].Add(kBasicPerLevelStats);
+  expect_stats[bottommost_level].bytes_read_output_level = kHasValue;
+  expect_stats[bottommost_level].num_input_files_in_output_level = kHasValue;
+
+  for (int level = 2; level < bottommost_level; level++) {
+    expect_stats[level].bytes_moved = kHasValue;
+  }
+  VerifyCompactionStats(expect_stats, expect_pl_stats);
+
   // manually move all data (cold) to last level
   MoveFilesToLevel(kLastLevel);
   seq_history.clear();
@@ -1080,6 +1097,9 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
 
   db_->ReleaseSnapshot(snap);
 
+  // TODO: it should push the data to last level, but penultimate level file is
+  //  already bottommost, it's a conflict between bottommost_temperature and
+  //  tiered compaction which only applies to last level compaction.
   ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
   ASSERT_EQ("0,0,0,0,0,1,1", FilesPerLevel());
   ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
@@ -1104,13 +1124,13 @@ TEST_P(TieredCompactionTest, SequenceBasedTieredStorageLevel) {
   ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
 }
 
-TEST_P(TieredCompactionTest, RangeBasedTieredStorageLevel) {
+TEST_F(TieredCompactionTest, RangeBasedTieredStorageLevel) {
   const int kNumTrigger = 4;
   const int kNumLevels = 7;
   const int kNumKeys = 100;
 
   auto options = CurrentOptions();
-  SetColdTemperature(options);
+  options.bottommost_temperature = Temperature::kCold;
   options.level0_file_num_compaction_trigger = kNumTrigger;
   options.level_compaction_dynamic_level_bytes = true;
   options.num_levels = kNumLevels;
@@ -1212,9 +1232,6 @@ TEST_P(TieredCompactionTest, RangeBasedTieredStorageLevel) {
       1);
 }
 
-INSTANTIATE_TEST_CASE_P(TieredCompactionTest, TieredCompactionTest,
-                        testing::Bool());
-
 #endif  // !defined(ROCKSDB_LITE)
 
 }  // namespace ROCKSDB_NAMESPACE

db/corruption_test.cc

@@ -764,7 +764,6 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
     delete db_;
     db_ = nullptr;
     s = DestroyDB(dbname_, options);
-    ASSERT_OK(s);
     std::shared_ptr<mock::MockTableFactory> mock =
         std::make_shared<mock::MockTableFactory>();
     options.table_factory = mock;

db/db_basic_test.cc

@@ -253,7 +253,6 @@ TEST_F(DBBasicTest, CompactedDB) {
   ASSERT_OK(Put("bbb", DummyString(kFileSize / 2, 'b')));
   ASSERT_OK(Put("eee", DummyString(kFileSize / 2, 'e')));
   ASSERT_OK(Flush());
-  ASSERT_OK(Put("something_not_flushed", "x"));
   Close();
 
   ASSERT_OK(ReadOnlyReopen(options));
@@ -261,20 +260,6 @@ TEST_F(DBBasicTest, CompactedDB) {
   s = Put("new", "value");
   ASSERT_EQ(s.ToString(),
             "Not implemented: Not supported operation in read only mode.");
-
-  // TODO: validate that other write ops return NotImplemented
-  // (DBImplReadOnly is missing some overrides)
-
-  // Ensure no deadlock on flush triggered by another API function
-  // (Old deadlock bug depends on something_not_flushed above.)
-  std::vector<std::string> files;
-  uint64_t manifest_file_size;
-  ASSERT_OK(db_->GetLiveFiles(files, &manifest_file_size, /*flush*/ true));
-  LiveFilesStorageInfoOptions lfsi_opts;
-  lfsi_opts.wal_size_for_flush = 0;  // always
-  std::vector<LiveFileStorageInfo> files2;
-  ASSERT_OK(db_->GetLiveFilesStorageInfo(lfsi_opts, &files2));
-
   Close();
 
   // Full compaction
@@ -305,13 +290,6 @@ TEST_F(DBBasicTest, CompactedDB) {
   ASSERT_EQ(DummyString(kFileSize / 2, 'j'), Get("jjj"));
   ASSERT_EQ("NOT_FOUND", Get("kkk"));
 
-  // TODO: validate that other write ops return NotImplemented
-  // (CompactedDB is missing some overrides)
-
-  // Ensure no deadlock on flush triggered by another API function
-  ASSERT_OK(db_->GetLiveFiles(files, &manifest_file_size, /*flush*/ true));
-  ASSERT_OK(db_->GetLiveFilesStorageInfo(lfsi_opts, &files2));
-
   // MultiGet
   std::vector<std::string> values;
   std::vector<Status> status_list = dbfull()->MultiGet(
@@ -2035,10 +2013,12 @@ TEST_P(DBMultiGetTestWithParam, MultiGetBatchedValueSize) {
 }
 
 TEST_P(DBMultiGetTestWithParam, MultiGetBatchedValueSizeMultiLevelMerge) {
+#ifndef USE_COROUTINES
   if (std::get<1>(GetParam())) {
-    ROCKSDB_GTEST_BYPASS("This test needs to be fixed for async IO");
+    ROCKSDB_GTEST_SKIP("This test requires coroutine support");
     return;
   }
+#endif  // USE_COROUTINES
   // Skip for unbatched MultiGet
   if (!std::get<0>(GetParam())) {
     ROCKSDB_GTEST_BYPASS("This test is only for batched MultiGet");
@@ -2151,8 +2131,7 @@ INSTANTIATE_TEST_CASE_P(DBMultiGetTestWithParam, DBMultiGetTestWithParam,
                         testing::Combine(testing::Bool(), testing::Bool()));
 
 #if USE_COROUTINES
-class DBMultiGetAsyncIOTest : public DBBasicTest,
-                              public ::testing::WithParamInterface<bool> {
+class DBMultiGetAsyncIOTest : public DBBasicTest {
  public:
   DBMultiGetAsyncIOTest()
       : DBBasicTest(), statistics_(ROCKSDB_NAMESPACE::CreateDBStatistics()) {
@@ -2167,7 +2146,7 @@ class DBMultiGetAsyncIOTest : public DBBasicTest,
 
     // Put all keys in the bottommost level, and overwrite some keys
     // in L0 and L1
-    for (int i = 0; i < 256; ++i) {
+    for (int i = 0; i < 128; ++i) {
       EXPECT_OK(Put(Key(i), "val_l2_" + std::to_string(i)));
       num_keys++;
       if (num_keys == 8) {
@@ -2193,21 +2172,6 @@ class DBMultiGetAsyncIOTest : public DBBasicTest,
       EXPECT_OK(Flush());
       num_keys = 0;
     }
-    // Put some range deletes in L1
-    for (int i = 128; i < 256; i += 32) {
-      std::string range_begin = Key(i);
-      std::string range_end = Key(i + 16);
-      EXPECT_OK(dbfull()->DeleteRange(WriteOptions(),
-                                      dbfull()->DefaultColumnFamily(),
-                                      range_begin, range_end));
-      // Also do some Puts to force creation of bloom filter
-      for (int j = i + 16; j < i + 32; ++j) {
-        if (j % 3 == 0) {
-          EXPECT_OK(Put(Key(j), "val_l1_" + std::to_string(j)));
-        }
-      }
-      EXPECT_OK(Flush());
-    }
     MoveFilesToLevel(1);
 
     for (int i = 0; i < 128; i += 5) {
@@ -2231,7 +2195,7 @@ class DBMultiGetAsyncIOTest : public DBBasicTest,
   std::shared_ptr<Statistics> statistics_;
 };
 
-TEST_P(DBMultiGetAsyncIOTest, GetFromL0) {
+TEST_F(DBMultiGetAsyncIOTest, GetFromL0) {
   // All 3 keys in L0. The L0 files should be read serially.
   std::vector<std::string> key_strs{Key(0), Key(40), Key(80)};
   std::vector<Slice> keys{key_strs[0], key_strs[1], key_strs[2]};
@@ -2240,7 +2204,6 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL0) {
 
   ReadOptions ro;
   ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
   dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
                      keys.data(), values.data(), statuses.data());
   ASSERT_EQ(values.size(), 3);
@@ -2255,19 +2218,13 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL0) {
 
   statistics()->histogramData(MULTIGET_IO_BATCH_SIZE, &multiget_io_batch_size);
 
-  // With async IO, lookups will happen in parallel for each key
-  if (GetParam()) {
-    ASSERT_EQ(multiget_io_batch_size.count, 1);
-    ASSERT_EQ(multiget_io_batch_size.max, 3);
-    ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 3);
-  } else {
-    // Without Async IO, MultiGet will call MultiRead 3 times, once for each
-    // L0 file
-    ASSERT_EQ(multiget_io_batch_size.count, 3);
-  }
+  // No async IO in this case since we don't do parallel lookup in L0
+  ASSERT_EQ(multiget_io_batch_size.count, 0);
+  ASSERT_EQ(multiget_io_batch_size.max, 0);
+  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 0);
 }
 
-TEST_P(DBMultiGetAsyncIOTest, GetFromL1) {
+TEST_F(DBMultiGetAsyncIOTest, GetFromL1) {
   std::vector<std::string> key_strs;
   std::vector<Slice> keys;
   std::vector<PinnableSlice> values;
@@ -2284,7 +2241,6 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL1) {
 
   ReadOptions ro;
   ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
   dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
                      keys.data(), values.data(), statuses.data());
   ASSERT_EQ(values.size(), 3);
@@ -2305,7 +2261,7 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL1) {
   ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 3);
 }
 
-TEST_P(DBMultiGetAsyncIOTest, LastKeyInFile) {
+TEST_F(DBMultiGetAsyncIOTest, LastKeyInFile) {
   std::vector<std::string> key_strs;
   std::vector<Slice> keys;
   std::vector<PinnableSlice> values;
@@ -2323,7 +2279,6 @@ TEST_P(DBMultiGetAsyncIOTest, LastKeyInFile) {
 
   ReadOptions ro;
   ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
   dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
                      keys.data(), values.data(), statuses.data());
   ASSERT_EQ(values.size(), 3);
@@ -2346,7 +2301,7 @@ TEST_P(DBMultiGetAsyncIOTest, LastKeyInFile) {
   ASSERT_EQ(multiget_io_batch_size.max, 2);
 }
 
-TEST_P(DBMultiGetAsyncIOTest, GetFromL1AndL2) {
+TEST_F(DBMultiGetAsyncIOTest, GetFromL1AndL2) {
   std::vector<std::string> key_strs;
   std::vector<Slice> keys;
   std::vector<PinnableSlice> values;
@@ -2364,7 +2319,6 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL1AndL2) {
 
   ReadOptions ro;
   ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
   dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
                      keys.data(), values.data(), statuses.data());
   ASSERT_EQ(values.size(), 3);
@@ -2379,102 +2333,11 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL1AndL2) {
 
   statistics()->histogramData(MULTIGET_IO_BATCH_SIZE, &multiget_io_batch_size);
 
-  // There are 2 keys in L1 in twp separate files, and 1 in L2. With
-  // optimize_multiget_for_io, all three lookups will happen in parallel.
-  // Otherwise, the L2 lookup will happen after L1.
-  ASSERT_EQ(multiget_io_batch_size.count, GetParam() ? 1 : 2);
-  ASSERT_EQ(multiget_io_batch_size.max, GetParam() ? 3 : 2);
+  // There is only one MultiGet key in the bottommost level - 56. Thus
+  // the bottommost level will not use async IO.
+  ASSERT_EQ(multiget_io_batch_size.count, 1);
+  ASSERT_EQ(multiget_io_batch_size.max, 2);
 }
-
-TEST_P(DBMultiGetAsyncIOTest, GetFromL2WithRangeOverlapL0L1) {
-  std::vector<std::string> key_strs;
-  std::vector<Slice> keys;
-  std::vector<PinnableSlice> values;
-  std::vector<Status> statuses;
-
-  // 19 and 26 are in L2, but overlap with L0 and L1 file ranges
-  key_strs.push_back(Key(19));
-  key_strs.push_back(Key(26));
-  keys.push_back(key_strs[0]);
-  keys.push_back(key_strs[1]);
-  values.resize(keys.size());
-  statuses.resize(keys.size());
-
-  ReadOptions ro;
-  ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data());
-  ASSERT_EQ(values.size(), 2);
-  ASSERT_EQ(statuses[0], Status::OK());
-  ASSERT_EQ(statuses[1], Status::OK());
-  ASSERT_EQ(values[0], "val_l2_" + std::to_string(19));
-  ASSERT_EQ(values[1], "val_l2_" + std::to_string(26));
-
-  // Bloom filters in L0/L1 will avoid the coroutine calls in those levels
-  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 2);
-}
-
-TEST_P(DBMultiGetAsyncIOTest, GetFromL2WithRangeDelInL1) {
-  std::vector<std::string> key_strs;
-  std::vector<Slice> keys;
-  std::vector<PinnableSlice> values;
-  std::vector<Status> statuses;
-
-  // 139 and 163 are in L2, but overlap with a range deletes in L1
-  key_strs.push_back(Key(139));
-  key_strs.push_back(Key(163));
-  keys.push_back(key_strs[0]);
-  keys.push_back(key_strs[1]);
-  values.resize(keys.size());
-  statuses.resize(keys.size());
-
-  ReadOptions ro;
-  ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data());
-  ASSERT_EQ(values.size(), 2);
-  ASSERT_EQ(statuses[0], Status::NotFound());
-  ASSERT_EQ(statuses[1], Status::NotFound());
-
-  // Bloom filters in L0/L1 will avoid the coroutine calls in those levels
-  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 2);
-}
-
-TEST_P(DBMultiGetAsyncIOTest, GetFromL1AndL2WithRangeDelInL1) {
-  std::vector<std::string> key_strs;
-  std::vector<Slice> keys;
-  std::vector<PinnableSlice> values;
-  std::vector<Status> statuses;
-
-  // 139 and 163 are in L2, but overlap with a range deletes in L1
-  key_strs.push_back(Key(139));
-  key_strs.push_back(Key(144));
-  key_strs.push_back(Key(163));
-  keys.push_back(key_strs[0]);
-  keys.push_back(key_strs[1]);
-  keys.push_back(key_strs[2]);
-  values.resize(keys.size());
-  statuses.resize(keys.size());
-
-  ReadOptions ro;
-  ro.async_io = true;
-  ro.optimize_multiget_for_io = GetParam();
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data());
-  ASSERT_EQ(values.size(), keys.size());
-  ASSERT_EQ(statuses[0], Status::NotFound());
-  ASSERT_EQ(statuses[1], Status::OK());
-  ASSERT_EQ(values[1], "val_l1_" + std::to_string(144));
-  ASSERT_EQ(statuses[2], Status::NotFound());
-
-  // Bloom filters in L0/L1 will avoid the coroutine calls in those levels
-  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 3);
-}
-
-INSTANTIATE_TEST_CASE_P(DBMultiGetAsyncIOTest, DBMultiGetAsyncIOTest,
-                        testing::Bool());
 #endif  // USE_COROUTINES
 
 TEST_F(DBBasicTest, MultiGetStats) {

db/db_block_cache_test.cc

@@ -13,6 +13,7 @@
 
 #include "cache/cache_entry_roles.h"
 #include "cache/cache_key.h"
+#include "cache/clock_cache.h"
 #include "cache/fast_lru_cache.h"
 #include "cache/lru_cache.h"
 #include "db/column_family.h"
@@ -677,8 +678,8 @@ INSTANTIATE_TEST_CASE_P(DBBlockCacheTest1, DBBlockCacheTest1,
 TEST_P(DBBlockCacheTest1, WarmCacheWithBlocksDuringFlush) {
   Options options = CurrentOptions();
   options.create_if_missing = true;
-  options.disable_auto_compactions = true;
   options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+  options.max_compaction_bytes = 2000;
 
   BlockBasedTableOptions table_options;
   table_options.block_cache = NewLRUCache(1 << 25, 0, false);
@@ -736,10 +737,8 @@ TEST_P(DBBlockCacheTest1, WarmCacheWithBlocksDuringFlush) {
   }
 
   // Verify compaction not counted
-  CompactRangeOptions cro;
-  // Ensure files are rewritten, not just trivially moved.
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForceOptimized;
-  ASSERT_OK(db_->CompactRange(cro, /*begin=*/nullptr, /*end=*/nullptr));
+  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
@@ -820,8 +819,8 @@ class MockCache : public LRUCache {
 
   MockCache()
       : LRUCache((size_t)1 << 25 /*capacity*/, 0 /*num_shard_bits*/,
-                 false /*strict_capacity_limit*/, 0.0 /*high_pri_pool_ratio*/,
-                 0.0 /*low_pri_pool_ratio*/) {}
+                 false /*strict_capacity_limit*/, 0.0 /*high_pri_pool_ratio*/) {
+  }
 
   using ShardedCache::Insert;
 
@@ -937,11 +936,9 @@ TEST_F(DBBlockCacheTest, AddRedundantStats) {
   int iterations_tested = 0;
   for (std::shared_ptr<Cache> base_cache :
        {NewLRUCache(capacity, num_shard_bits),
-        HyperClockCacheOptions(
-            capacity,
-            BlockBasedTableOptions().block_size /*estimated_value_size*/,
-            num_shard_bits)
-            .MakeSharedCache(),
+        ExperimentalNewClockCache(
+            capacity, 1 /*estimated_value_size*/, num_shard_bits,
+            false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy),
         NewFastLRUCache(capacity, 1 /*estimated_value_size*/, num_shard_bits,
                         false /*strict_capacity_limit*/,
                         kDefaultCacheMetadataChargePolicy)}) {
@@ -1297,12 +1294,10 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {
   const size_t capacity = size_t{1} << 25;
   int iterations_tested = 0;
   for (bool partition : {false, true}) {
-    for (std::shared_ptr<Cache> cache :
-         {NewLRUCache(capacity),
-          HyperClockCacheOptions(
-              capacity,
-              BlockBasedTableOptions().block_size /*estimated_value_size*/)
-              .MakeSharedCache()}) {
+    for (std::shared_ptr<Cache> cache : {NewLRUCache(capacity)}) {
+      // This test doesn't support FastLRUCache nor ClockCache because the
+      // keys used are not 16B long.
+      // TODO(guido) Add support for FastLRUCache and ClockCache.
       if (!cache) {
         // Skip clock cache when not supported
         continue;
@@ -1455,16 +1450,9 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {
       // even if the cache is full
       ClearCache(cache.get());
       Cache::Handle* h = nullptr;
-      if (strcmp(cache->Name(), "LRUCache") == 0) {
-        ASSERT_OK(cache->Insert("Fill-it-up", nullptr, capacity + 1,
-                                GetNoopDeleterForRole<CacheEntryRole::kMisc>(),
-                                &h, Cache::Priority::HIGH));
-      } else {
-        // For ClockCache we use a 16-byte key.
-        ASSERT_OK(cache->Insert("Fill-it-up-xxxxx", nullptr, capacity + 1,
-                                GetNoopDeleterForRole<CacheEntryRole::kMisc>(),
-                                &h, Cache::Priority::HIGH));
-      }
+      ASSERT_OK(cache->Insert("Fill-it-up", nullptr, capacity + 1,
+                              GetNoopDeleterForRole<CacheEntryRole::kMisc>(),
+                              &h, Cache::Priority::HIGH));
       ASSERT_GT(cache->GetUsage(), cache->GetCapacity());
       expected = {};
       // For CacheEntryStatsCollector
@@ -1571,10 +1559,6 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
   options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
   options.env = test_env.get();
 
-  // Corrupting the table properties corrupts the unique id.
-  // Ignore the unique id recorded in the manifest.
-  options.verify_sst_unique_id_in_manifest = false;
-
   BlockBasedTableOptions table_options;
 
   int key_count = 0;
@@ -1725,7 +1709,7 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
   delete metadata_ptr_;
   metadata_ptr_ = nullptr;
 
-  ASSERT_OK(DestroyDB(export_files_dir, options));
+  DestroyDB(export_files_dir, options);
 
   ReopenWithColumnFamilies({"default", "yoyo"}, options);
 
@@ -1743,60 +1727,51 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
 
 class CacheKeyTest : public testing::Test {
  public:
-  CacheKey GetBaseCacheKey() {
-    CacheKey rv = GetOffsetableCacheKey(0, /*min file_number*/ 1).WithOffset(0);
-    // Correct for file_number_ == 1
-    *reinterpret_cast<uint64_t*>(&rv) ^= ReverseBits(uint64_t{1});
-    return rv;
-  }
-  CacheKey GetCacheKey(uint64_t session_counter, uint64_t file_number,
-                       uint64_t offset) {
-    OffsetableCacheKey offsetable =
-        GetOffsetableCacheKey(session_counter, file_number);
-    // * 4 to counteract optimization that strips lower 2 bits in encoding
-    // the offset in BlockBasedTable::GetCacheKey (which we prefer to include
-    // in unit tests to maximize functional coverage).
-    EXPECT_GE(offset * 4, offset);  // no overflow
-    return BlockBasedTable::GetCacheKey(offsetable,
-                                        BlockHandle(offset * 4, /*size*/ 5));
-  }
-
- protected:
-  OffsetableCacheKey GetOffsetableCacheKey(uint64_t session_counter,
-                                           uint64_t file_number) {
+  void SetupStableBase() {
     // Like SemiStructuredUniqueIdGen::GenerateNext
     tp_.db_session_id = EncodeSessionId(base_session_upper_,
-                                        base_session_lower_ ^ session_counter);
+                                        base_session_lower_ ^ session_counter_);
     tp_.db_id = std::to_string(db_id_);
-    tp_.orig_file_number = file_number;
+    tp_.orig_file_number = file_number_;
     bool is_stable;
     std::string cur_session_id = "";  // ignored
     uint64_t cur_file_number = 42;    // ignored
-    OffsetableCacheKey rv;
     BlockBasedTable::SetupBaseCacheKey(&tp_, cur_session_id, cur_file_number,
-                                       &rv, &is_stable);
-    EXPECT_TRUE(is_stable);
-    EXPECT_TRUE(!rv.IsEmpty());
-    // BEGIN some assertions in relation to SST unique IDs
-    std::string external_unique_id_str;
-    EXPECT_OK(GetUniqueIdFromTableProperties(tp_, &external_unique_id_str));
-    UniqueId64x2 sst_unique_id = {};
-    EXPECT_OK(DecodeUniqueIdBytes(external_unique_id_str, &sst_unique_id));
-    ExternalUniqueIdToInternal(&sst_unique_id);
-    OffsetableCacheKey ock =
-        OffsetableCacheKey::FromInternalUniqueId(&sst_unique_id);
-    EXPECT_EQ(rv.WithOffset(0).AsSlice(), ock.WithOffset(0).AsSlice());
-    EXPECT_EQ(ock.ToInternalUniqueId(), sst_unique_id);
-    // END some assertions in relation to SST unique IDs
-    return rv;
+                                       file_size_, &base_cache_key_,
+                                       &is_stable);
+    ASSERT_TRUE(is_stable);
+  }
+  CacheKey WithOffset(uint64_t offset) {
+    return BlockBasedTable::GetCacheKey(base_cache_key_,
+                                        BlockHandle(offset, /*size*/ 5));
   }
 
+ protected:
+  OffsetableCacheKey base_cache_key_;
   TableProperties tp_;
+  uint64_t file_size_ = 0;
   uint64_t base_session_upper_ = 0;
   uint64_t base_session_lower_ = 0;
+  uint64_t session_counter_ = 0;
+  uint64_t file_number_ = 0;
   uint64_t db_id_ = 0;
 };
 
+namespace {
+template <typename T>
+int CountBitsDifferent(const T& t1, const T& t2) {
+  int diff = 0;
+  const uint8_t* p1 = reinterpret_cast<const uint8_t*>(&t1);
+  const uint8_t* p2 = reinterpret_cast<const uint8_t*>(&t2);
+  static_assert(sizeof(*p1) == 1, "Expecting uint8_t byte");
+  for (size_t i = 0; i < sizeof(T); ++i) {
+    diff += BitsSetToOne(p1[i] ^ p2[i]);
+  }
+  return diff;
+}
+
+}  // namespace
+
 TEST_F(CacheKeyTest, DBImplSessionIdStructure) {
   // We have to generate our own session IDs for simulation purposes in other
   // tests. Here we verify that the DBImpl implementation seems to match
@@ -1815,202 +1790,171 @@ TEST_F(CacheKeyTest, DBImplSessionIdStructure) {
   ASSERT_NE(Lower32of64(lower1), Lower32of64(lower2));
 }
 
-namespace {
-// Deconstruct cache key, based on knowledge of implementation details.
-void DeconstructNonemptyCacheKey(const CacheKey& key, uint64_t* file_num_etc64,
-                                 uint64_t* offset_etc64) {
-  *file_num_etc64 = *reinterpret_cast<const uint64_t*>(key.AsSlice().data());
-  *offset_etc64 = *reinterpret_cast<const uint64_t*>(key.AsSlice().data() + 8);
-  assert(*file_num_etc64 != 0);
-  if (*offset_etc64 == 0) {
-    std::swap(*file_num_etc64, *offset_etc64);
-  }
-  assert(*offset_etc64 != 0);
+TEST_F(CacheKeyTest, StandardEncodingLimit) {
+  base_session_upper_ = 1234;
+  base_session_lower_ = 5678;
+  session_counter_ = 42;
+  file_number_ = 42;
+  db_id_ = 1234;
+
+  file_size_ = 42;
+  SetupStableBase();
+  CacheKey ck1;
+  ASSERT_TRUE(ck1.IsEmpty());
+  ck1 = WithOffset(0);
+  ASSERT_FALSE(ck1.IsEmpty());
+
+  // Should use same encoding
+  file_size_ = BlockBasedTable::kMaxFileSizeStandardEncoding;
+  SetupStableBase();
+  CacheKey ck2 = WithOffset(0);
+  ASSERT_EQ(CountBitsDifferent(ck1, ck2), 0);
+
+  // Should use different encoding
+  ++file_size_;
+  SetupStableBase();
+  CacheKey ck3 = WithOffset(0);
+  ASSERT_GT(CountBitsDifferent(ck2, ck3), 0);
 }
 
-// Make a bit mask of 0 to 64 bits
-uint64_t MakeMask64(int bits) {
-  if (bits >= 64) {
-    return uint64_t{0} - 1;
-  } else {
-    return (uint64_t{1} << bits) - 1;
-  }
-}
-
-// See CacheKeyTest::Encodings
-struct CacheKeyDecoder {
-  // Inputs
-  uint64_t base_file_num_etc64, base_offset_etc64;
-  int session_counter_bits, file_number_bits, offset_bits;
-
-  // Derived
-  uint64_t session_counter_mask, file_number_mask, offset_mask;
-
-  // Outputs
-  uint64_t decoded_session_counter, decoded_file_num, decoded_offset;
-
-  void SetBaseCacheKey(const CacheKey& base) {
-    DeconstructNonemptyCacheKey(base, &base_file_num_etc64, &base_offset_etc64);
-  }
-
-  void SetRanges(int _session_counter_bits, int _file_number_bits,
-                 int _offset_bits) {
-    session_counter_bits = _session_counter_bits;
-    session_counter_mask = MakeMask64(session_counter_bits);
-    file_number_bits = _file_number_bits;
-    file_number_mask = MakeMask64(file_number_bits);
-    offset_bits = _offset_bits;
-    offset_mask = MakeMask64(offset_bits);
-  }
-
-  void Decode(const CacheKey& key) {
-    uint64_t file_num_etc64, offset_etc64;
-    DeconstructNonemptyCacheKey(key, &file_num_etc64, &offset_etc64);
-
-    // First decode session counter
-    if (offset_bits + session_counter_bits <= 64) {
-      // fully recoverable from offset_etc64
-      decoded_session_counter =
-          ReverseBits((offset_etc64 ^ base_offset_etc64)) &
-          session_counter_mask;
-    } else if (file_number_bits + session_counter_bits <= 64) {
-      // fully recoverable from file_num_etc64
-      decoded_session_counter = DownwardInvolution(
-          (file_num_etc64 ^ base_file_num_etc64) & session_counter_mask);
-    } else {
-      // Need to combine parts from each word.
-      // Piece1 will contain some correct prefix of the bottom bits of
-      // session counter.
-      uint64_t piece1 =
-          ReverseBits((offset_etc64 ^ base_offset_etc64) & ~offset_mask);
-      int piece1_bits = 64 - offset_bits;
-      // Piece2 will contain involuded bits that we can combine with piece1
-      // to infer rest of session counter
-      int piece2_bits = std::min(64 - file_number_bits, 64 - piece1_bits);
-      ASSERT_LT(piece2_bits, 64);
-      uint64_t piece2_mask = MakeMask64(piece2_bits);
-      uint64_t piece2 = (file_num_etc64 ^ base_file_num_etc64) & piece2_mask;
-
-      // Cancel out the part of piece2 that we can infer from piece1
-      // (DownwardInvolution distributes over xor)
-      piece2 ^= DownwardInvolution(piece1) & piece2_mask;
-
-      // Now we need to solve for the unknown original bits in higher
-      // positions than piece1 provides. We use Gaussian elimination
-      // because we know that a piece2_bits X piece2_bits submatrix of
-      // the matrix underlying DownwardInvolution times the vector of
-      // unknown original bits equals piece2.
-      //
-      // Build an augmented row matrix for that submatrix, built column by
-      // column.
-      std::array<uint64_t, 64> aug_rows{};
-      for (int i = 0; i < piece2_bits; ++i) {  // over columns
-        uint64_t col_i = DownwardInvolution(uint64_t{1} << piece1_bits << i);
-        ASSERT_NE(col_i & 1U, 0);
-        for (int j = 0; j < piece2_bits; ++j) {  // over rows
-          aug_rows[j] |= (col_i & 1U) << i;
-          col_i >>= 1;
-        }
-      }
-      // Augment with right hand side
-      for (int j = 0; j < piece2_bits; ++j) {  // over rows
-        aug_rows[j] |= (piece2 & 1U) << piece2_bits;
-        piece2 >>= 1;
-      }
-      // Run Gaussian elimination
-      for (int i = 0; i < piece2_bits; ++i) {  // over columns
-        // Find a row that can be used to cancel others
-        uint64_t canceller = 0;
-        // Note: Rows 0 through i-1 contain 1s in columns already eliminated
-        for (int j = i; j < piece2_bits; ++j) {  // over rows
-          if (aug_rows[j] & (uint64_t{1} << i)) {
-            // Swap into appropriate row
-            std::swap(aug_rows[i], aug_rows[j]);
-            // Keep a handy copy for row reductions
-            canceller = aug_rows[i];
-            break;
-          }
-        }
-        ASSERT_NE(canceller, 0);
-        for (int j = 0; j < piece2_bits; ++j) {  // over rows
-          if (i != j && ((aug_rows[j] >> i) & 1) != 0) {
-            // Row reduction
-            aug_rows[j] ^= canceller;
-          }
-        }
-      }
-      // Extract result
-      decoded_session_counter = piece1;
-      for (int j = 0; j < piece2_bits; ++j) {  // over rows
-        ASSERT_EQ(aug_rows[j] & piece2_mask, uint64_t{1} << j);
-        decoded_session_counter |= aug_rows[j] >> piece2_bits << piece1_bits
-                                                              << j;
-      }
-    }
-
-    decoded_offset =
-        offset_etc64 ^ base_offset_etc64 ^ ReverseBits(decoded_session_counter);
-
-    decoded_file_num = ReverseBits(file_num_etc64 ^ base_file_num_etc64 ^
-                                   DownwardInvolution(decoded_session_counter));
-  }
-};
-}  // namespace
-
 TEST_F(CacheKeyTest, Encodings) {
-  // This test primarily verifies this claim from cache_key.cc:
-  // // In fact, if DB ids were not involved, we would be guaranteed unique
-  // // cache keys for files generated in a single process until total bits for
-  // // biggest session_id_counter, orig_file_number, and offset_in_file
-  // // reach 128 bits.
-  //
-  // To demonstrate this, CacheKeyDecoder can reconstruct the structured inputs
-  // to the cache key when provided an output cache key, the unstructured
-  // inputs, and bounds on the structured inputs.
-  //
-  // See OffsetableCacheKey comments in cache_key.cc.
+  // Claim from cache_key.cc:
+  // In fact, if our SST files are all < 4TB (see
+  // BlockBasedTable::kMaxFileSizeStandardEncoding), then SST files generated
+  // in a single process are guaranteed to have unique cache keys, unless/until
+  // number session ids * max file number = 2**86, e.g. 1 trillion DB::Open in
+  // a single process and 64 trillion files generated.
 
-  // We are going to randomly initialize some values that *should* not affect
+  // We can generalize that. For
+  // * z bits in maximum file size
+  // * n bits in maximum file number
+  // * s bits in maximum session counter
+  // uniqueness is guaranteed at least when all of these hold:
+  // *  z + n + s <= 121  (128 - 2 meta + 2 offset trim - (8-1) byte granularity
+  //                       in encoding)
+  // *  n + s <= 86       (encoding limitation)
+  // *  s <= 62           (because of 2-bit metadata)
+
+  // We can verify this indirectly by how input bits get into the cache key,
+  // but we have to be mindful that for sufficiently large file sizes,
+  // different encodings might be used. But for cases mixing large and small
+  // files, we have to verify uniqueness between encodings.
+
+  // Going through all combinations would be a little expensive, so we test
+  // only one random "stripe" of the configuration space per run.
+  constexpr uint32_t kStripeBits = 8;
+  constexpr uint32_t kStripeMask = (uint32_t{1} << kStripeBits) - 1;
+
+  // Also cycle through stripes on repeated runs (not thread safe)
+  static uint32_t stripe =
+      static_cast<uint32_t>(std::random_device{}()) & kStripeMask;
+  stripe = (stripe + 1) & kStripeMask;
+
+  fprintf(stderr, "%u\n", stripe);
+
+  // We are going to randomly initialize some values which *should* not affect
   // result
   Random64 r{std::random_device{}()};
 
-  CacheKeyDecoder decoder;
-  db_id_ = r.Next();
-  base_session_upper_ = r.Next();
-  base_session_lower_ = r.Next();
-  if (base_session_lower_ == 0) {
-    base_session_lower_ = 1;
-  }
+  int max_num_encodings = 0;
+  uint32_t config_num = 0;
+  uint32_t session_counter_bits, file_number_bits, max_file_size_bits;
 
-  decoder.SetBaseCacheKey(GetBaseCacheKey());
+  // Inner loop body, used later in a loop over configurations
+  auto TestConfig = [&]() {
+    base_session_upper_ = r.Next();
+    base_session_lower_ = r.Next();
+    session_counter_ = r.Next();
+    if (session_counter_bits < 64) {
+      // Avoid shifting UB
+      session_counter_ = session_counter_ >> 1 >> (63 - session_counter_bits);
+    }
+    file_number_ = r.Next() >> (64 - file_number_bits);
+    // Need two bits set to avoid temporary zero below
+    if (BitsSetToOne(file_number_) < 2) {
+      file_number_ = 3;
+    }
+    db_id_ = r.Next();
 
-  // Loop over configurations and test those
-  for (int session_counter_bits = 0; session_counter_bits <= 64;
+    // Work-around clang-analyzer which thinks empty last_base is garbage
+    CacheKey last_base = CacheKey::CreateUniqueForProcessLifetime();
+
+    std::unordered_set<std::string> seen;
+    int num_encodings = 0;
+
+    // Loop over encodings by increasing file size bits
+    for (uint32_t file_size_bits = 1; file_size_bits <= max_file_size_bits;
+         ++file_size_bits) {
+      file_size_ = uint64_t{1} << (file_size_bits - 1);
+      SetupStableBase();
+      CacheKey new_base = WithOffset(0);
+      if (CountBitsDifferent(last_base, new_base) == 0) {
+        // Same as previous encoding
+        continue;
+      }
+
+      // New encoding
+      ++num_encodings;
+      ASSERT_TRUE(seen.insert(new_base.AsSlice().ToString()).second);
+      last_base = new_base;
+      for (uint32_t i = 0; i < file_size_bits; ++i) {
+        CacheKey ck = WithOffset(uint64_t{1} << i);
+        if (i < 2) {
+          // These cases are not relevant and optimized by dropping two
+          // lowest bits because there's always at least 5 bytes between
+          // blocks.
+          ASSERT_EQ(CountBitsDifferent(ck, new_base), 0);
+        } else {
+          // Normal case
+          // 1 bit different from base and never been seen implies the bit
+          // is encoded into cache key without overlapping other structured
+          // data.
+          ASSERT_EQ(CountBitsDifferent(ck, new_base), 1);
+          ASSERT_TRUE(seen.insert(ck.AsSlice().ToString()).second);
+        }
+      }
+      for (uint32_t i = 0; i < session_counter_bits; ++i) {
+        SaveAndRestore<uint64_t> tmp(&session_counter_,
+                                     session_counter_ ^ (uint64_t{1} << i));
+        SetupStableBase();
+        CacheKey ck = WithOffset(0);
+        ASSERT_EQ(CountBitsDifferent(ck, new_base), 1);
+        ASSERT_TRUE(seen.insert(ck.AsSlice().ToString()).second);
+      }
+      for (uint32_t i = 0; i < file_number_bits; ++i) {
+        SaveAndRestore<uint64_t> tmp(&file_number_,
+                                     file_number_ ^ (uint64_t{1} << i));
+        SetupStableBase();
+        CacheKey ck = WithOffset(0);
+        ASSERT_EQ(CountBitsDifferent(ck, new_base), 1);
+        ASSERT_TRUE(seen.insert(ck.AsSlice().ToString()).second);
+      }
+      max_num_encodings = std::max(max_num_encodings, num_encodings);
+    }
+  };
+
+  // Loop over configurations and test those in stripe
+  for (session_counter_bits = 0; session_counter_bits <= 62;
        ++session_counter_bits) {
-    for (int file_number_bits = 1; file_number_bits <= 64; ++file_number_bits) {
-      // 62 bits max because unoptimized offset will be 64 bits in that case
-      for (int offset_bits = 0; offset_bits <= 62; ++offset_bits) {
-        if (session_counter_bits + file_number_bits + offset_bits > 128) {
-          break;
+    uint32_t max_file_number_bits =
+        std::min(uint32_t{64}, uint32_t{86} - session_counter_bits);
+    // Start with 2 to avoid file_number_ == 0 in testing
+    for (file_number_bits = 2; file_number_bits <= max_file_number_bits;
+         ++file_number_bits) {
+      uint32_t max_max_file_size_bits =
+          std::min(uint32_t{64},
+                   uint32_t{121} - file_number_bits - session_counter_bits);
+      for (max_file_size_bits = 1; max_file_size_bits <= max_max_file_size_bits;
+           ++max_file_size_bits) {
+        if ((config_num++ & kStripeMask) == stripe) {
+          TestConfig();
         }
-
-        decoder.SetRanges(session_counter_bits, file_number_bits, offset_bits);
-
-        uint64_t session_counter = r.Next() & decoder.session_counter_mask;
-        uint64_t file_number = r.Next() & decoder.file_number_mask;
-        if (file_number == 0) {
-          // Minimum
-          file_number = 1;
-        }
-        uint64_t offset = r.Next() & decoder.offset_mask;
-        decoder.Decode(GetCacheKey(session_counter, file_number, offset));
-
-        EXPECT_EQ(decoder.decoded_session_counter, session_counter);
-        EXPECT_EQ(decoder.decoded_file_num, file_number);
-        EXPECT_EQ(decoder.decoded_offset, offset);
       }
     }
   }
+
+  // Make sure the current implementation is exercised
+  ASSERT_EQ(max_num_encodings, 4);
 }
 
 INSTANTIATE_TEST_CASE_P(DBBlockCacheKeyTest, DBBlockCacheKeyTest,

db/db_compaction_filter_test.cc

@@ -328,9 +328,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
   Arena arena;
   {
     InternalKeyComparator icmp(options.comparator);
+    ReadRangeDelAggregator range_del_agg(&icmp,
+                                         kMaxSequenceNumber /* upper_bound */);
     ReadOptions read_options;
     ScopedArenaIterator iter(dbfull()->NewInternalIterator(
-        read_options, &arena, kMaxSequenceNumber, handles_[1]));
+        read_options, &arena, &range_del_agg, kMaxSequenceNumber, handles_[1]));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
@@ -420,9 +422,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilter) {
   count = 0;
   {
     InternalKeyComparator icmp(options.comparator);
+    ReadRangeDelAggregator range_del_agg(&icmp,
+                                         kMaxSequenceNumber /* upper_bound */);
     ReadOptions read_options;
     ScopedArenaIterator iter(dbfull()->NewInternalIterator(
-        read_options, &arena, kMaxSequenceNumber, handles_[1]));
+        read_options, &arena, &range_del_agg, kMaxSequenceNumber, handles_[1]));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {
@@ -697,9 +701,11 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
     int total = 0;
     Arena arena;
     InternalKeyComparator icmp(options.comparator);
+    ReadRangeDelAggregator range_del_agg(&icmp,
+                                         kMaxSequenceNumber /* snapshots */);
     ReadOptions read_options;
-    ScopedArenaIterator iter(dbfull()->NewInternalIterator(read_options, &arena,
-                                                           kMaxSequenceNumber));
+    ScopedArenaIterator iter(dbfull()->NewInternalIterator(
+        read_options, &arena, &range_del_agg, kMaxSequenceNumber));
     iter->SeekToFirst();
     ASSERT_OK(iter->status());
     while (iter->Valid()) {

db/db_compaction_test.cc

@@ -161,32 +161,8 @@ class ChangeLevelConflictsWithAuto
   ChangeLevelConflictsWithAuto() : DBCompactionTest() {}
 };
 
-// Param = true: grab the compaction pressure token (enable
-// parallel compactions)
-// Param = false: Not grab the token (no parallel compactions)
-class RoundRobinSubcompactionsAgainstPressureToken
-    : public DBCompactionTest,
-      public ::testing::WithParamInterface<bool> {
- public:
-  RoundRobinSubcompactionsAgainstPressureToken() {
-    grab_pressure_token_ = GetParam();
-  }
-  bool grab_pressure_token_;
-};
-
-class RoundRobinSubcompactionsAgainstResources
-    : public DBCompactionTest,
-      public ::testing::WithParamInterface<std::tuple<int, int>> {
- public:
-  RoundRobinSubcompactionsAgainstResources() {
-    total_low_pri_threads_ = std::get<0>(GetParam());
-    max_compaction_limits_ = std::get<1>(GetParam());
-  }
-  int total_low_pri_threads_;
-  int max_compaction_limits_;
-};
-
 namespace {
+
 class FlushedFileCollector : public EventListener {
  public:
   FlushedFileCollector() {}
@@ -2660,9 +2636,8 @@ TEST_F(DBCompactionTest, ManualAutoRace) {
   TEST_SYNC_POINT("DBCompactionTest::ManualAutoRace:1");
   // The auto compaction will wait until the manual compaction is registerd
   // before processing so that it will be cancelled.
-  CompactRangeOptions cro;
-  cro.exclusive_manual_compaction = true;
-  ASSERT_OK(dbfull()->CompactRange(cro, handles_[1], nullptr, nullptr));
+  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), handles_[1], nullptr,
+                                   nullptr));
   ASSERT_EQ("0,1", FilesPerLevel(1));
 
   // Eventually the cancelled compaction will be rescheduled and executed.
@@ -5331,255 +5306,6 @@ TEST_F(DBCompactionTest, PersistRoundRobinCompactCursor) {
   }
 }
 
-TEST_P(RoundRobinSubcompactionsAgainstPressureToken, PressureTokenTest) {
-  const int kKeysPerBuffer = 100;
-  Options options = CurrentOptions();
-  options.num_levels = 4;
-  options.max_bytes_for_level_multiplier = 2;
-  options.level0_file_num_compaction_trigger = 4;
-  options.target_file_size_base = kKeysPerBuffer * 1024;
-  options.compaction_pri = CompactionPri::kRoundRobin;
-  options.max_bytes_for_level_base = 8 * kKeysPerBuffer * 1024;
-  options.disable_auto_compactions = true;
-  // Setup 7 threads but limited subcompactions so that
-  // RoundRobin requires extra compactions from reserved threads
-  options.max_subcompactions = 1;
-  options.max_background_compactions = 7;
-  options.max_compaction_bytes = 100000000;
-  DestroyAndReopen(options);
-  env_->SetBackgroundThreads(7, Env::LOW);
-
-  Random rnd(301);
-  const std::vector<int> files_per_level = {0, 15, 25};
-  for (int lvl = 2; lvl > 0; lvl--) {
-    for (int i = 0; i < files_per_level[lvl]; i++) {
-      for (int j = 0; j < kKeysPerBuffer; j++) {
-        // Add (lvl-1) to ensure nearly equivallent number of files
-        // in L2 are overlapped with fils selected to compact from
-        // L1
-        ASSERT_OK(Put(Key(2 * i * kKeysPerBuffer + 2 * j + (lvl - 1)),
-                      rnd.RandomString(1010)));
-      }
-      ASSERT_OK(Flush());
-    }
-    MoveFilesToLevel(lvl);
-    ASSERT_EQ(files_per_level[lvl], NumTableFilesAtLevel(lvl, 0));
-  }
-  // 15 files in L1; 25 files in L2
-
-  // This is a variable for making sure the following callback is called
-  // and the assertions in it are indeed excuted.
-  bool num_planned_subcompactions_verified = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::GenSubcompactionBoundaries:0", [&](void* arg) {
-        uint64_t num_planned_subcompactions = *(static_cast<uint64_t*>(arg));
-        if (grab_pressure_token_) {
-          // 7 files are selected for round-robin under auto
-          // compaction. The number of planned subcompaction is restricted by
-          // the limited number of max_background_compactions
-          ASSERT_EQ(num_planned_subcompactions, 7);
-        } else {
-          ASSERT_EQ(num_planned_subcompactions, 1);
-        }
-        num_planned_subcompactions_verified = true;
-      });
-
-  // The following 3 dependencies have to be added to ensure the auto
-  // compaction and the pressure token is correctly enabled. Same for
-  // RoundRobinSubcompactionsUsingResources and
-  // DBCompactionTest.RoundRobinSubcompactionsShrinkResources
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"RoundRobinSubcompactionsAgainstPressureToken:0",
-        "BackgroundCallCompaction:0"},
-       {"CompactionJob::AcquireSubcompactionResources:0",
-        "RoundRobinSubcompactionsAgainstPressureToken:1"},
-       {"RoundRobinSubcompactionsAgainstPressureToken:2",
-        "CompactionJob::AcquireSubcompactionResources:1"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(dbfull()->EnableAutoCompaction({dbfull()->DefaultColumnFamily()}));
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstPressureToken:0");
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstPressureToken:1");
-  std::unique_ptr<WriteControllerToken> pressure_token;
-  if (grab_pressure_token_) {
-    pressure_token =
-        dbfull()->TEST_write_controler().GetCompactionPressureToken();
-  }
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstPressureToken:2");
-
-  ASSERT_OK(dbfull()->WaitForCompact());
-  ASSERT_TRUE(num_planned_subcompactions_verified);
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-INSTANTIATE_TEST_CASE_P(RoundRobinSubcompactionsAgainstPressureToken,
-                        RoundRobinSubcompactionsAgainstPressureToken,
-                        testing::Bool());
-
-TEST_P(RoundRobinSubcompactionsAgainstResources, SubcompactionsUsingResources) {
-  const int kKeysPerBuffer = 200;
-  Options options = CurrentOptions();
-  options.num_levels = 4;
-  options.level0_file_num_compaction_trigger = 3;
-  options.target_file_size_base = kKeysPerBuffer * 1024;
-  options.compaction_pri = CompactionPri::kRoundRobin;
-  options.max_bytes_for_level_base = 30 * kKeysPerBuffer * 1024;
-  options.disable_auto_compactions = true;
-  options.max_subcompactions = 1;
-  options.max_background_compactions = max_compaction_limits_;
-  // Set a large number for max_compaction_bytes so that one round-robin
-  // compaction is enough to make post-compaction L1 size less than
-  // the maximum size (this test assumes only one round-robin compaction
-  // is triggered by kLevelMaxLevelSize)
-  options.max_compaction_bytes = 100000000;
-
-  DestroyAndReopen(options);
-  env_->SetBackgroundThreads(total_low_pri_threads_, Env::LOW);
-
-  Random rnd(301);
-  const std::vector<int> files_per_level = {0, 40, 100};
-  for (int lvl = 2; lvl > 0; lvl--) {
-    for (int i = 0; i < files_per_level[lvl]; i++) {
-      for (int j = 0; j < kKeysPerBuffer; j++) {
-        // Add (lvl-1) to ensure nearly equivallent number of files
-        // in L2 are overlapped with fils selected to compact from
-        // L1
-        ASSERT_OK(Put(Key(2 * i * kKeysPerBuffer + 2 * j + (lvl - 1)),
-                      rnd.RandomString(1010)));
-      }
-      ASSERT_OK(Flush());
-    }
-    MoveFilesToLevel(lvl);
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-    ASSERT_EQ(files_per_level[lvl], NumTableFilesAtLevel(lvl, 0));
-  }
-
-  // 40 files in L1; 100 files in L2
-  // This is a variable for making sure the following callback is called
-  // and the assertions in it are indeed excuted.
-  bool num_planned_subcompactions_verified = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::GenSubcompactionBoundaries:0", [&](void* arg) {
-        uint64_t num_planned_subcompactions = *(static_cast<uint64_t*>(arg));
-        // More than 10 files are selected for round-robin under auto
-        // compaction. The number of planned subcompaction is restricted by
-        // the minimum number between available threads and compaction limits
-        ASSERT_EQ(num_planned_subcompactions - options.max_subcompactions,
-                  std::min(total_low_pri_threads_, max_compaction_limits_) - 1);
-        num_planned_subcompactions_verified = true;
-      });
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"RoundRobinSubcompactionsAgainstResources:0",
-        "BackgroundCallCompaction:0"},
-       {"CompactionJob::AcquireSubcompactionResources:0",
-        "RoundRobinSubcompactionsAgainstResources:1"},
-       {"RoundRobinSubcompactionsAgainstResources:2",
-        "CompactionJob::AcquireSubcompactionResources:1"},
-       {"CompactionJob::ReleaseSubcompactionResources:0",
-        "RoundRobinSubcompactionsAgainstResources:3"},
-       {"RoundRobinSubcompactionsAgainstResources:4",
-        "CompactionJob::ReleaseSubcompactionResources:1"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(dbfull()->WaitForCompact());
-  ASSERT_OK(dbfull()->EnableAutoCompaction({dbfull()->DefaultColumnFamily()}));
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstResources:0");
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstResources:1");
-  auto pressure_token =
-      dbfull()->TEST_write_controler().GetCompactionPressureToken();
-
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstResources:2");
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstResources:3");
-  // We can reserve more threads now except one is being used
-  ASSERT_EQ(total_low_pri_threads_ - 1,
-            env_->ReserveThreads(total_low_pri_threads_, Env::Priority::LOW));
-  ASSERT_EQ(
-      total_low_pri_threads_ - 1,
-      env_->ReleaseThreads(total_low_pri_threads_ - 1, Env::Priority::LOW));
-  TEST_SYNC_POINT("RoundRobinSubcompactionsAgainstResources:4");
-  ASSERT_OK(dbfull()->WaitForCompact());
-  ASSERT_TRUE(num_planned_subcompactions_verified);
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
-INSTANTIATE_TEST_CASE_P(RoundRobinSubcompactionsAgainstResources,
-                        RoundRobinSubcompactionsAgainstResources,
-                        ::testing::Values(std::make_tuple(1, 5),
-                                          std::make_tuple(5, 1),
-                                          std::make_tuple(10, 5),
-                                          std::make_tuple(5, 10),
-                                          std::make_tuple(10, 10)));
-
-TEST_P(DBCompactionTestWithParam, RoundRobinWithoutAdditionalResources) {
-  const int kKeysPerBuffer = 200;
-  Options options = CurrentOptions();
-  options.num_levels = 4;
-  options.level0_file_num_compaction_trigger = 3;
-  options.target_file_size_base = kKeysPerBuffer * 1024;
-  options.compaction_pri = CompactionPri::kRoundRobin;
-  options.max_bytes_for_level_base = 30 * kKeysPerBuffer * 1024;
-  options.disable_auto_compactions = true;
-  options.max_subcompactions = max_subcompactions_;
-  options.max_background_compactions = 1;
-  options.max_compaction_bytes = 100000000;
-  // Similar experiment setting as above except the max_subcompactions
-  // is given by max_subcompactions_ (1 or 4), and we fix the
-  // additional resources as (1, 1) and thus no more extra resources
-  // can be used
-  DestroyAndReopen(options);
-  env_->SetBackgroundThreads(1, Env::LOW);
-
-  Random rnd(301);
-  const std::vector<int> files_per_level = {0, 33, 100};
-  for (int lvl = 2; lvl > 0; lvl--) {
-    for (int i = 0; i < files_per_level[lvl]; i++) {
-      for (int j = 0; j < kKeysPerBuffer; j++) {
-        // Add (lvl-1) to ensure nearly equivallent number of files
-        // in L2 are overlapped with fils selected to compact from
-        // L1
-        ASSERT_OK(Put(Key(2 * i * kKeysPerBuffer + 2 * j + (lvl - 1)),
-                      rnd.RandomString(1010)));
-      }
-      ASSERT_OK(Flush());
-    }
-    MoveFilesToLevel(lvl);
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-    ASSERT_EQ(files_per_level[lvl], NumTableFilesAtLevel(lvl, 0));
-  }
-
-  // 33 files in L1; 100 files in L2
-  // This is a variable for making sure the following callback is called
-  // and the assertions in it are indeed excuted.
-  bool num_planned_subcompactions_verified = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "CompactionJob::GenSubcompactionBoundaries:0", [&](void* arg) {
-        uint64_t num_planned_subcompactions = *(static_cast<uint64_t*>(arg));
-        // At most 4 files are selected for round-robin under auto
-        // compaction. The number of planned subcompaction is restricted by
-        // the max_subcompactions since no extra resources can be used
-        ASSERT_EQ(num_planned_subcompactions, options.max_subcompactions);
-        num_planned_subcompactions_verified = true;
-      });
-  // No need to setup dependency for pressure token since
-  // AcquireSubcompactionResources may not be called and it anyway cannot
-  // reserve any additional resources
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBCompactionTest::RoundRobinWithoutAdditionalResources:0",
-        "BackgroundCallCompaction:0"}});
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_OK(dbfull()->WaitForCompact());
-  ASSERT_OK(dbfull()->EnableAutoCompaction({dbfull()->DefaultColumnFamily()}));
-  TEST_SYNC_POINT("DBCompactionTest::RoundRobinWithoutAdditionalResources:0");
-
-  ASSERT_OK(dbfull()->WaitForCompact());
-  ASSERT_TRUE(num_planned_subcompactions_verified);
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-}
-
 TEST_F(DBCompactionTest, RoundRobinCutOutputAtCompactCursor) {
   Options options = CurrentOptions();
   options.num_levels = 3;
@@ -5933,10 +5659,18 @@ TEST_P(DBCompactionTestWithParam, FixFileIngestionCompactionDeadlock) {
     for (int j = 0; j != kNumKeysPerFile; ++j) {
       ASSERT_OK(Put(Key(j), rnd.RandomString(990)));
     }
-    if (i > 0) {
-      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-      ASSERT_EQ(NumTableFilesAtLevel(0 /*level*/, 0 /*cf*/), i);
+    if (0 == i) {
+      // When we reach here, the memtables have kNumKeysPerFile keys. Note that
+      // flush is not yet triggered. We need to write an extra key so that the
+      // write path will call PreprocessWrite and flush the previous key-value
+      // pairs to e flushed. After that, there will be the newest key in the
+      // memtable, and a bunch of L0 files. Since there is already one key in
+      // the memtable, then for i = 1, 2, ..., we do not have to write this
+      // extra key to trigger flush.
+      ASSERT_OK(Put("", ""));
     }
+    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
+    ASSERT_EQ(NumTableFilesAtLevel(0 /*level*/, 0 /*cf*/), i + 1);
   }
   // When we reach this point, there will be level0_stop_writes_trigger L0
   // files and one extra key (99) in memory, which overlaps with the external
@@ -7958,42 +7692,6 @@ TEST_F(DBCompactionTest, BottomPriCompactionCountsTowardConcurrencyLimit) {
   compact_range_thread.join();
 }
 
-TEST_F(DBCompactionTest, BottommostFileCompactionAllowIngestBehind) {
-  // allow_ingest_behind prevents seqnum zeroing, and could cause
-  // compaction loop with reason kBottommostFiles.
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.compaction_style = kCompactionStyleLevel;
-  options.allow_ingest_behind = true;
-  options.comparator = BytewiseComparator();
-  DestroyAndReopen(options);
-
-  WriteOptions write_opts;
-  ASSERT_OK(db_->Put(write_opts, "infinite", "compaction loop"));
-  ASSERT_OK(db_->Put(write_opts, "infinite", "loop"));
-
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-  ASSERT_OK(db_->Put(write_opts, "bumpseqnum", ""));
-  ASSERT_OK(Flush());
-  auto snapshot = db_->GetSnapshot();
-  // Bump up oldest_snapshot_seqnum_ in VersionStorageInfo.
-  db_->ReleaseSnapshot(snapshot);
-  bool compacted = false;
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "LevelCompactionPicker::PickCompaction:Return", [&](void* /* arg */) {
-        // There should not be a compaction.
-        compacted = true;
-      });
-  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  // Wait for compaction to be scheduled.
-  env_->SleepForMicroseconds(2000000);
-  ASSERT_FALSE(compacted);
-  // The following assert can be used to check for compaction loop:
-  // it used to wait forever before the fix.
-  // ASSERT_OK(dbfull()->TEST_WaitForCompact(true /* wait_unscheduled */));
-}
-
 #endif  // !defined(ROCKSDB_LITE)
 
 }  // namespace ROCKSDB_NAMESPACE

db/db_impl/compacted_db_impl.cc

@@ -72,9 +72,9 @@ Status CompactedDBImpl::Get(const ReadOptions& options, ColumnFamilyHandle*,
       user_comparator_->timestamp_size() > 0 ? timestamp : nullptr;
   LookupKey lkey(key, kMaxSequenceNumber, options.timestamp);
   GetContext get_context(user_comparator_, nullptr, nullptr, nullptr,
-                         GetContext::kNotFound, lkey.user_key(), value,
-                         /*columns=*/nullptr, ts, nullptr, nullptr, true,
-                         nullptr, nullptr, nullptr, nullptr, &read_cb);
+                         GetContext::kNotFound, lkey.user_key(), value, ts,
+                         nullptr, nullptr, true, nullptr, nullptr, nullptr,
+                         nullptr, &read_cb);
 
   const FdWithKeyRange& f = files_.files[FindFile(lkey.user_key())];
   if (user_comparator_->CompareWithoutTimestamp(
@@ -159,7 +159,7 @@ std::vector<Status> CompactedDBImpl::MultiGet(
       std::string* timestamp = timestamps ? &(*timestamps)[idx] : nullptr;
       GetContext get_context(
           user_comparator_, nullptr, nullptr, nullptr, GetContext::kNotFound,
-          lkey.user_key(), &pinnable_val, /*columns=*/nullptr,
+          lkey.user_key(), &pinnable_val,
           user_comparator_->timestamp_size() > 0 ? timestamp : nullptr, nullptr,
           nullptr, true, nullptr, nullptr, nullptr, nullptr, &read_cb);
       Status s = r->Get(options, lkey.internal_key(), &get_context, nullptr);
@@ -242,7 +242,7 @@ Status CompactedDBImpl::Open(const Options& options,
   std::unique_ptr<CompactedDBImpl> db(new CompactedDBImpl(db_options, dbname));
   Status s = db->Init(options);
   if (s.ok()) {
-    s = db->StartPeriodicTaskScheduler();
+    s = db->StartPeriodicWorkScheduler();
   }
   if (s.ok()) {
     ROCKS_LOG_INFO(db->immutable_db_options_.info_log,

db/db_impl/compacted_db_impl.h

@@ -11,7 +11,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-// TODO: Share common structure with DBImplSecondary and DBImplReadOnly
 class CompactedDBImpl : public DBImpl {
  public:
   CompactedDBImpl(const DBOptions& options, const std::string& dbname);
@@ -128,17 +127,6 @@ class CompactedDBImpl : public DBImpl {
     return Status::NotSupported("Not supported in compacted db mode.");
   }
 
-  // FIXME: some missing overrides for more "write" functions
-  // Share with DBImplReadOnly?
-
- protected:
-#ifndef ROCKSDB_LITE
-  Status FlushForGetLiveFiles() override {
-    // No-op for read-only DB
-    return Status::OK();
-  }
-#endif  // !ROCKSDB_LITE
-
  private:
   friend class DB;
   inline size_t FindFile(const Slice& key);

db/db_impl/db_impl.cc

@@ -45,7 +45,7 @@
 #include "db/memtable_list.h"
 #include "db/merge_context.h"
 #include "db/merge_helper.h"
-#include "db/periodic_task_scheduler.h"
+#include "db/periodic_work_scheduler.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/table_cache.h"
 #include "db/table_properties_collector.h"
@@ -165,13 +165,8 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       fs_(immutable_db_options_.fs, io_tracer_),
       mutable_db_options_(initial_db_options_),
       stats_(immutable_db_options_.stats),
-#ifdef COERCE_CONTEXT_SWITCH
-      mutex_(stats_, immutable_db_options_.clock, DB_MUTEX_WAIT_MICROS, &bg_cv_,
-             immutable_db_options_.use_adaptive_mutex),
-#else   // COERCE_CONTEXT_SWITCH
       mutex_(stats_, immutable_db_options_.clock, DB_MUTEX_WAIT_MICROS,
              immutable_db_options_.use_adaptive_mutex),
-#endif  // COERCE_CONTEXT_SWITCH
       default_cf_handle_(nullptr),
       error_handler_(this, immutable_db_options_, &mutex_),
       event_logger_(immutable_db_options_.info_log.get()),
@@ -190,7 +185,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       log_dir_synced_(false),
       log_empty_(true),
       persist_stats_cf_handle_(nullptr),
-      log_sync_cv_(&log_write_mutex_),
+      log_sync_cv_(&mutex_),
       total_log_size_(0),
       is_snapshot_supported_(true),
       write_buffer_manager_(immutable_db_options_.write_buffer_manager.get()),
@@ -222,7 +217,7 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
       refitting_level_(false),
       opened_successfully_(false),
 #ifndef ROCKSDB_LITE
-      periodic_task_scheduler_(),
+      periodic_work_scheduler_(nullptr),
 #endif  // ROCKSDB_LITE
       two_write_queues_(options.two_write_queues),
       manual_wal_flush_(options.manual_wal_flush),
@@ -265,18 +260,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
   SetDbSessionId();
   assert(!db_session_id_.empty());
 
-#ifndef ROCKSDB_LITE
-  periodic_task_functions_.emplace(PeriodicTaskType::kDumpStats,
-                                   [this]() { this->DumpStats(); });
-  periodic_task_functions_.emplace(PeriodicTaskType::kPersistStats,
-                                   [this]() { this->PersistStats(); });
-  periodic_task_functions_.emplace(PeriodicTaskType::kFlushInfoLog,
-                                   [this]() { this->FlushInfoLog(); });
-  periodic_task_functions_.emplace(
-      PeriodicTaskType::kRecordSeqnoTime,
-      [this]() { this->RecordSeqnoToTimeMapping(); });
-#endif  // ROCKSDB_LITE
-
   versions_.reset(new VersionSet(dbname_, &immutable_db_options_, file_options_,
                                  table_cache_.get(), write_buffer_manager_,
                                  &write_controller_, &block_cache_tracer_,
@@ -290,8 +273,6 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname,
   mutable_db_options_.Dump(immutable_db_options_.info_log.get());
   DumpSupportInfo(immutable_db_options_.info_log.get());
 
-  max_total_wal_size_.store(mutable_db_options_.max_total_wal_size,
-                            std::memory_order_relaxed);
   if (write_buffer_manager_) {
     wbm_stall_.reset(new WBMStallInterface());
   }
@@ -497,15 +478,9 @@ void DBImpl::CancelAllBackgroundWork(bool wait) {
                  "Shutdown: canceling all background work");
 
 #ifndef ROCKSDB_LITE
-  for (uint8_t task_type = 0;
-       task_type < static_cast<uint8_t>(PeriodicTaskType::kMax); task_type++) {
-    Status s = periodic_task_scheduler_.Unregister(
-        static_cast<PeriodicTaskType>(task_type));
-    if (!s.ok()) {
-      ROCKS_LOG_WARN(immutable_db_options_.info_log,
-                     "Failed to unregister periodic task %d, status: %s",
-                     task_type, s.ToString().c_str());
-    }
+  if (periodic_work_scheduler_ != nullptr) {
+    periodic_work_scheduler_->Unregister(this);
+    periodic_work_scheduler_->UnregisterRecordSeqnoTimeWorker(this);
   }
 #endif  // !ROCKSDB_LITE
 
@@ -650,28 +625,26 @@ Status DBImpl::CloseHelper() {
     job_context.Clean();
     mutex_.Lock();
   }
-  {
-    InstrumentedMutexLock lock(&log_write_mutex_);
-    for (auto l : logs_to_free_) {
-      delete l;
-    }
-    for (auto& log : logs_) {
-      uint64_t log_number = log.writer->get_log_number();
-      Status s = log.ClearWriter();
-      if (!s.ok()) {
-        ROCKS_LOG_WARN(
-            immutable_db_options_.info_log,
-            "Unable to Sync WAL file %s with error -- %s",
-            LogFileName(immutable_db_options_.GetWalDir(), log_number).c_str(),
-            s.ToString().c_str());
-        // Retain the first error
-        if (ret.ok()) {
-          ret = s;
-        }
+
+  for (auto l : logs_to_free_) {
+    delete l;
+  }
+  for (auto& log : logs_) {
+    uint64_t log_number = log.writer->get_log_number();
+    Status s = log.ClearWriter();
+    if (!s.ok()) {
+      ROCKS_LOG_WARN(
+          immutable_db_options_.info_log,
+          "Unable to Sync WAL file %s with error -- %s",
+          LogFileName(immutable_db_options_.GetWalDir(), log_number).c_str(),
+          s.ToString().c_str());
+      // Retain the first error
+      if (ret.ok()) {
+        ret = s;
       }
     }
-    logs_.clear();
   }
+  logs_.clear();
 
   // Table cache may have table handles holding blocks from the block cache.
   // We need to release them before the block cache is destroyed. The block
@@ -790,50 +763,30 @@ void DBImpl::PrintStatistics() {
   }
 }
 
-Status DBImpl::StartPeriodicTaskScheduler() {
+Status DBImpl::StartPeriodicWorkScheduler() {
 #ifndef ROCKSDB_LITE
 
 #ifndef NDEBUG
   // It only used by test to disable scheduler
   bool disable_scheduler = false;
   TEST_SYNC_POINT_CALLBACK(
-      "DBImpl::StartPeriodicTaskScheduler:DisableScheduler",
+      "DBImpl::StartPeriodicWorkScheduler:DisableScheduler",
       &disable_scheduler);
   if (disable_scheduler) {
     return Status::OK();
   }
+#endif  // !NDEBUG
 
   {
     InstrumentedMutexLock l(&mutex_);
-    TEST_SYNC_POINT_CALLBACK("DBImpl::StartPeriodicTaskScheduler:Init",
-                             &periodic_task_scheduler_);
+    periodic_work_scheduler_ = PeriodicWorkScheduler::Default();
+    TEST_SYNC_POINT_CALLBACK("DBImpl::StartPeriodicWorkScheduler:Init",
+                             &periodic_work_scheduler_);
   }
 
-#endif  // !NDEBUG
-  if (mutable_db_options_.stats_dump_period_sec > 0) {
-    Status s = periodic_task_scheduler_.Register(
-        PeriodicTaskType::kDumpStats,
-        periodic_task_functions_.at(PeriodicTaskType::kDumpStats),
-        mutable_db_options_.stats_dump_period_sec);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-  if (mutable_db_options_.stats_persist_period_sec > 0) {
-    Status s = periodic_task_scheduler_.Register(
-        PeriodicTaskType::kPersistStats,
-        periodic_task_functions_.at(PeriodicTaskType::kPersistStats),
-        mutable_db_options_.stats_persist_period_sec);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  Status s = periodic_task_scheduler_.Register(
-      PeriodicTaskType::kFlushInfoLog,
-      periodic_task_functions_.at(PeriodicTaskType::kFlushInfoLog));
-
-  return s;
+  return periodic_work_scheduler_->Register(
+      this, mutable_db_options_.stats_dump_period_sec,
+      mutable_db_options_.stats_persist_period_sec);
 #else
   return Status::OK();
 #endif  // !ROCKSDB_LITE
@@ -841,6 +794,9 @@ Status DBImpl::StartPeriodicTaskScheduler() {
 
 Status DBImpl::RegisterRecordSeqnoTimeWorker() {
 #ifndef ROCKSDB_LITE
+  if (!periodic_work_scheduler_) {
+    return Status::OK();
+  }
   uint64_t min_time_duration = std::numeric_limits<uint64_t>::max();
   uint64_t max_time_duration = std::numeric_limits<uint64_t>::min();
   {
@@ -868,13 +824,26 @@ Status DBImpl::RegisterRecordSeqnoTimeWorker() {
   }
 
   Status s;
-  if (seqno_time_cadence == 0) {
-    s = periodic_task_scheduler_.Unregister(PeriodicTaskType::kRecordSeqnoTime);
-  } else {
-    s = periodic_task_scheduler_.Register(
-        PeriodicTaskType::kRecordSeqnoTime,
-        periodic_task_functions_.at(PeriodicTaskType::kRecordSeqnoTime),
-        seqno_time_cadence);
+  if (seqno_time_cadence != record_seqno_time_cadence_) {
+    if (seqno_time_cadence == 0) {
+      periodic_work_scheduler_->UnregisterRecordSeqnoTimeWorker(this);
+    } else {
+      s = periodic_work_scheduler_->RegisterRecordSeqnoTimeWorker(
+          this, seqno_time_cadence);
+    }
+
+    if (s.ok()) {
+      record_seqno_time_cadence_ = seqno_time_cadence;
+    }
+
+    if (s.IsNotSupported()) {
+      // TODO: Fix the timer cannot cancel and re-add the same task
+      ROCKS_LOG_WARN(
+          immutable_db_options_.info_log,
+          "Updating seqno to time worker cadence is not supported yet, to make "
+          "the change effective, please reopen the DB instance.");
+      s = Status::OK();
+    }
   }
 
   return s;
@@ -1114,10 +1083,6 @@ void DBImpl::DumpStats() {
   PrintStatistics();
 }
 
-// Periodically flush info log out of application buffer at a low frequency.
-// This improves debuggability in case of RocksDB hanging since it ensures the
-// log messages leading up to the hang will eventually become visible in the
-// log.
 void DBImpl::FlushInfoLog() {
   if (shutdown_initiated_) {
     return;
@@ -1143,7 +1108,6 @@ Status DBImpl::TablesRangeTombstoneSummary(ColumnFamilyHandle* column_family,
 }
 
 void DBImpl::ScheduleBgLogWriterClose(JobContext* job_context) {
-  mutex_.AssertHeld();
   if (!job_context->logs_to_free.empty()) {
     for (auto l : job_context->logs_to_free) {
       AddToLogsToFreeQueue(l);
@@ -1310,36 +1274,17 @@ Status DBImpl::SetDBOptions(
         MaybeScheduleFlushOrCompaction();
       }
 
-      mutex_.Unlock();
-      if (new_options.stats_dump_period_sec == 0) {
-        s = periodic_task_scheduler_.Unregister(PeriodicTaskType::kDumpStats);
-      } else {
-        s = periodic_task_scheduler_.Register(
-            PeriodicTaskType::kDumpStats,
-            periodic_task_functions_.at(PeriodicTaskType::kDumpStats),
-            new_options.stats_dump_period_sec);
+      if (new_options.stats_dump_period_sec !=
+              mutable_db_options_.stats_dump_period_sec ||
+          new_options.stats_persist_period_sec !=
+              mutable_db_options_.stats_persist_period_sec) {
+        mutex_.Unlock();
+        periodic_work_scheduler_->Unregister(this);
+        s = periodic_work_scheduler_->Register(
+            this, new_options.stats_dump_period_sec,
+            new_options.stats_persist_period_sec);
+        mutex_.Lock();
       }
-      if (new_options.max_total_wal_size !=
-          mutable_db_options_.max_total_wal_size) {
-        max_total_wal_size_.store(new_options.max_total_wal_size,
-                                  std::memory_order_release);
-      }
-      if (s.ok()) {
-        if (new_options.stats_persist_period_sec == 0) {
-          s = periodic_task_scheduler_.Unregister(
-              PeriodicTaskType::kPersistStats);
-        } else {
-          s = periodic_task_scheduler_.Register(
-              PeriodicTaskType::kPersistStats,
-              periodic_task_functions_.at(PeriodicTaskType::kPersistStats),
-              new_options.stats_persist_period_sec);
-        }
-      }
-      mutex_.Lock();
-      if (!s.ok()) {
-        return s;
-      }
-
       write_controller_.set_max_delayed_write_rate(
           new_options.delayed_write_rate);
       table_cache_.get()->SetCapacity(new_options.max_open_files == -1
@@ -1460,7 +1405,7 @@ Status DBImpl::SyncWAL() {
   uint64_t current_log_number;
 
   {
-    InstrumentedMutexLock l(&log_write_mutex_);
+    InstrumentedMutexLock l(&mutex_);
     assert(!logs_.empty());
 
     // This SyncWAL() call only cares about logs up to this number.
@@ -1517,37 +1462,19 @@ Status DBImpl::SyncWAL() {
   TEST_SYNC_POINT("DBWALTest::SyncWALNotWaitWrite:2");
 
   TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:1");
-  VersionEdit synced_wals;
   {
-    InstrumentedMutexLock l(&log_write_mutex_);
+    InstrumentedMutexLock l(&mutex_);
     if (status.ok()) {
-      MarkLogsSynced(current_log_number, need_log_dir_sync, &synced_wals);
+      status = MarkLogsSynced(current_log_number, need_log_dir_sync);
     } else {
       MarkLogsNotSynced(current_log_number);
     }
   }
-  if (status.ok() && synced_wals.IsWalAddition()) {
-    InstrumentedMutexLock l(&mutex_);
-    status = ApplyWALToManifest(&synced_wals);
-  }
-
   TEST_SYNC_POINT("DBImpl::SyncWAL:BeforeMarkLogsSynced:2");
 
   return status;
 }
 
-Status DBImpl::ApplyWALToManifest(VersionEdit* synced_wals) {
-  // not empty, write to MANIFEST.
-  mutex_.AssertHeld();
-  Status status = versions_->LogAndApplyToDefaultColumnFamily(
-      synced_wals, &mutex_, directories_.GetDbDir());
-  if (!status.ok() && versions_->io_status().IsIOError()) {
-    status = error_handler_.SetBGError(versions_->io_status(),
-                                       BackgroundErrorReason::kManifestWrite);
-  }
-  return status;
-}
-
 Status DBImpl::LockWAL() {
   log_write_mutex_.Lock();
   auto cur_log_writer = logs_.back().writer;
@@ -1567,43 +1494,48 @@ Status DBImpl::UnlockWAL() {
   return Status::OK();
 }
 
-void DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir,
-                            VersionEdit* synced_wals) {
-  log_write_mutex_.AssertHeld();
+Status DBImpl::MarkLogsSynced(uint64_t up_to, bool synced_dir) {
+  mutex_.AssertHeld();
   if (synced_dir && logfile_number_ == up_to) {
     log_dir_synced_ = true;
   }
+  VersionEdit synced_wals;
   for (auto it = logs_.begin(); it != logs_.end() && it->number <= up_to;) {
     auto& wal = *it;
     assert(wal.IsSyncing());
 
-    if (wal.number < logs_.back().number) {
-      // Inactive WAL
+    if (logs_.size() > 1) {
       if (immutable_db_options_.track_and_verify_wals_in_manifest &&
           wal.GetPreSyncSize() > 0) {
-        synced_wals->AddWal(wal.number, WalMetadata(wal.GetPreSyncSize()));
-      }
-      if (wal.GetPreSyncSize() == wal.writer->file()->GetFlushedSize()) {
-        // Fully synced
-        logs_to_free_.push_back(wal.ReleaseWriter());
-        it = logs_.erase(it);
-      } else {
-        assert(wal.GetPreSyncSize() < wal.writer->file()->GetFlushedSize());
-        wal.FinishSync();
-        ++it;
+        synced_wals.AddWal(wal.number, WalMetadata(wal.GetPreSyncSize()));
       }
+      logs_to_free_.push_back(wal.ReleaseWriter());
+      // To modify logs_ both mutex_ and log_write_mutex_ must be held
+      InstrumentedMutexLock l(&log_write_mutex_);
+      it = logs_.erase(it);
     } else {
-      assert(wal.number == logs_.back().number);
-      // Active WAL
       wal.FinishSync();
       ++it;
     }
   }
+  assert(logs_.empty() || logs_[0].number > up_to ||
+         (logs_.size() == 1 && !logs_[0].IsSyncing()));
+
+  Status s;
+  if (synced_wals.IsWalAddition()) {
+    // not empty, write to MANIFEST.
+    s = versions_->LogAndApplyToDefaultColumnFamily(&synced_wals, &mutex_);
+    if (!s.ok() && versions_->io_status().IsIOError()) {
+      s = error_handler_.SetBGError(versions_->io_status(),
+                                    BackgroundErrorReason::kManifestWrite);
+    }
+  }
   log_sync_cv_.SignalAll();
+  return s;
 }
 
 void DBImpl::MarkLogsNotSynced(uint64_t up_to) {
-  log_write_mutex_.AssertHeld();
+  mutex_.AssertHeld();
   for (auto it = logs_.begin(); it != logs_.end() && it->number <= up_to;
        ++it) {
     auto& wal = *it;
@@ -1646,6 +1578,7 @@ Status DBImpl::GetFullHistoryTsLow(ColumnFamilyHandle* column_family,
 
 InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
                                               Arena* arena,
+                                              RangeDelAggregator* range_del_agg,
                                               SequenceNumber sequence,
                                               ColumnFamilyHandle* column_family,
                                               bool allow_unprepared_value) {
@@ -1660,8 +1593,8 @@ InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
   mutex_.Lock();
   SuperVersion* super_version = cfd->GetSuperVersion()->Ref();
   mutex_.Unlock();
-  return NewInternalIterator(read_options, cfd, super_version, arena, sequence,
-                             allow_unprepared_value);
+  return NewInternalIterator(read_options, cfd, super_version, arena,
+                             range_del_agg, sequence, allow_unprepared_value);
 }
 
 void DBImpl::SchedulePurge() {
@@ -1726,16 +1659,9 @@ void DBImpl::BackgroundCallPurge() {
 }
 
 namespace {
-
-// A `SuperVersionHandle` holds a non-null `SuperVersion*` pointing at a
-// `SuperVersion` referenced once for this object. It also contains the state
-// needed to clean up the `SuperVersion` reference from outside of `DBImpl`
-// using `CleanupSuperVersionHandle()`.
-struct SuperVersionHandle {
-  // `_super_version` must be non-nullptr and `Ref()`'d once as long as the
-  // `SuperVersionHandle` may use it.
-  SuperVersionHandle(DBImpl* _db, InstrumentedMutex* _mu,
-                     SuperVersion* _super_version, bool _background_purge)
+struct IterState {
+  IterState(DBImpl* _db, InstrumentedMutex* _mu, SuperVersion* _super_version,
+            bool _background_purge)
       : db(_db),
         mu(_mu),
         super_version(_super_version),
@@ -1747,104 +1673,84 @@ struct SuperVersionHandle {
   bool background_purge;
 };
 
-static void CleanupSuperVersionHandle(void* arg1, void* /*arg2*/) {
-  SuperVersionHandle* sv_handle = reinterpret_cast<SuperVersionHandle*>(arg1);
+static void CleanupIteratorState(void* arg1, void* /*arg2*/) {
+  IterState* state = reinterpret_cast<IterState*>(arg1);
 
-  if (sv_handle->super_version->Unref()) {
+  if (state->super_version->Unref()) {
     // Job id == 0 means that this is not our background process, but rather
     // user thread
     JobContext job_context(0);
 
-    sv_handle->mu->Lock();
-    sv_handle->super_version->Cleanup();
-    sv_handle->db->FindObsoleteFiles(&job_context, false, true);
-    if (sv_handle->background_purge) {
-      sv_handle->db->ScheduleBgLogWriterClose(&job_context);
-      sv_handle->db->AddSuperVersionsToFreeQueue(sv_handle->super_version);
-      sv_handle->db->SchedulePurge();
+    state->mu->Lock();
+    state->super_version->Cleanup();
+    state->db->FindObsoleteFiles(&job_context, false, true);
+    if (state->background_purge) {
+      state->db->ScheduleBgLogWriterClose(&job_context);
+      state->db->AddSuperVersionsToFreeQueue(state->super_version);
+      state->db->SchedulePurge();
     }
-    sv_handle->mu->Unlock();
+    state->mu->Unlock();
 
-    if (!sv_handle->background_purge) {
-      delete sv_handle->super_version;
+    if (!state->background_purge) {
+      delete state->super_version;
     }
     if (job_context.HaveSomethingToDelete()) {
-      sv_handle->db->PurgeObsoleteFiles(job_context,
-                                        sv_handle->background_purge);
+      state->db->PurgeObsoleteFiles(job_context, state->background_purge);
     }
     job_context.Clean();
   }
 
-  delete sv_handle;
-}
-
-struct GetMergeOperandsState {
-  MergeContext merge_context;
-  PinnedIteratorsManager pinned_iters_mgr;
-  SuperVersionHandle* sv_handle;
-};
-
-static void CleanupGetMergeOperandsState(void* arg1, void* /*arg2*/) {
-  GetMergeOperandsState* state = static_cast<GetMergeOperandsState*>(arg1);
-  CleanupSuperVersionHandle(state->sv_handle /* arg1 */, nullptr /* arg2 */);
   delete state;
 }
-
 }  // namespace
 
-InternalIterator* DBImpl::NewInternalIterator(
-    const ReadOptions& read_options, ColumnFamilyData* cfd,
-    SuperVersion* super_version, Arena* arena, SequenceNumber sequence,
-    bool allow_unprepared_value, ArenaWrappedDBIter* db_iter) {
+InternalIterator* DBImpl::NewInternalIterator(const ReadOptions& read_options,
+                                              ColumnFamilyData* cfd,
+                                              SuperVersion* super_version,
+                                              Arena* arena,
+                                              RangeDelAggregator* range_del_agg,
+                                              SequenceNumber sequence,
+                                              bool allow_unprepared_value) {
   InternalIterator* internal_iter;
   assert(arena != nullptr);
+  assert(range_del_agg != nullptr);
   // Need to create internal iterator from the arena.
   MergeIteratorBuilder merge_iter_builder(
       &cfd->internal_comparator(), arena,
       !read_options.total_order_seek &&
-          super_version->mutable_cf_options.prefix_extractor != nullptr,
-      read_options.iterate_upper_bound);
-  // Collect iterator for mutable memtable
-  auto mem_iter = super_version->mem->NewIterator(read_options, arena);
+          super_version->mutable_cf_options.prefix_extractor != nullptr);
+  // Collect iterator for mutable mem
+  merge_iter_builder.AddIterator(
+      super_version->mem->NewIterator(read_options, arena));
+  std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter;
   Status s;
   if (!read_options.ignore_range_deletions) {
-    TruncatedRangeDelIterator* mem_tombstone_iter = nullptr;
-    auto range_del_iter = super_version->mem->NewRangeTombstoneIterator(
-        read_options, sequence, false /* immutable_memtable */);
-    if (range_del_iter == nullptr || range_del_iter->empty()) {
-      delete range_del_iter;
-    } else {
-      mem_tombstone_iter = new TruncatedRangeDelIterator(
-          std::unique_ptr<FragmentedRangeTombstoneIterator>(range_del_iter),
-          &cfd->ioptions()->internal_comparator, nullptr /* smallest */,
-          nullptr /* largest */);
-    }
-    merge_iter_builder.AddPointAndTombstoneIterator(mem_iter,
-                                                    mem_tombstone_iter);
-  } else {
-    merge_iter_builder.AddIterator(mem_iter);
+    range_del_iter.reset(
+        super_version->mem->NewRangeTombstoneIterator(read_options, sequence));
+    range_del_agg->AddTombstones(std::move(range_del_iter));
   }
-
   // Collect all needed child iterators for immutable memtables
   if (s.ok()) {
-    super_version->imm->AddIterators(read_options, &merge_iter_builder,
-                                     !read_options.ignore_range_deletions);
+    super_version->imm->AddIterators(read_options, &merge_iter_builder);
+    if (!read_options.ignore_range_deletions) {
+      s = super_version->imm->AddRangeTombstoneIterators(read_options, arena,
+                                                         range_del_agg);
+    }
   }
   TEST_SYNC_POINT_CALLBACK("DBImpl::NewInternalIterator:StatusCallback", &s);
   if (s.ok()) {
     // Collect iterators for files in L0 - Ln
     if (read_options.read_tier != kMemtableTier) {
       super_version->current->AddIterators(read_options, file_options_,
-                                           &merge_iter_builder,
+                                           &merge_iter_builder, range_del_agg,
                                            allow_unprepared_value);
     }
-    internal_iter = merge_iter_builder.Finish(
-        read_options.ignore_range_deletions ? nullptr : db_iter);
-    SuperVersionHandle* cleanup = new SuperVersionHandle(
-        this, &mutex_, super_version,
-        read_options.background_purge_on_iterator_cleanup ||
-            immutable_db_options_.avoid_unnecessary_blocking_io);
-    internal_iter->RegisterCleanup(CleanupSuperVersionHandle, cleanup, nullptr);
+    internal_iter = merge_iter_builder.Finish();
+    IterState* cleanup =
+        new IterState(this, &mutex_, super_version,
+                      read_options.background_purge_on_iterator_cleanup ||
+                      immutable_db_options_.avoid_unnecessary_blocking_io);
+    internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, nullptr);
 
     return internal_iter;
   } else {
@@ -1880,61 +1786,10 @@ Status DBImpl::Get(const ReadOptions& read_options,
   return s;
 }
 
-Status DBImpl::GetEntity(const ReadOptions& read_options,
-                         ColumnFamilyHandle* column_family, const Slice& key,
-                         PinnableWideColumns* columns) {
-  if (!column_family) {
-    return Status::InvalidArgument(
-        "Cannot call GetEntity without a column family handle");
-  }
-
-  if (!columns) {
-    return Status::InvalidArgument(
-        "Cannot call GetEntity without a PinnableWideColumns object");
-  }
-
-  columns->Reset();
-
-  GetImplOptions get_impl_options;
-  get_impl_options.column_family = column_family;
-  get_impl_options.columns = columns;
-
-  return GetImpl(read_options, key, get_impl_options);
-}
-
-bool DBImpl::ShouldReferenceSuperVersion(const MergeContext& merge_context) {
-  // If both thresholds are reached, a function returning merge operands as
-  // `PinnableSlice`s should reference the `SuperVersion` to avoid large and/or
-  // numerous `memcpy()`s.
-  //
-  // The below constants enable the optimization conservatively. They are
-  // verified to not regress `GetMergeOperands()` latency in the following
-  // scenarios.
-  //
-  // - CPU: two socket Intel(R) Xeon(R) Gold 6138 CPU @ 2.00GHz
-  // - `GetMergeOperands()` threads: 1 - 32
-  // - Entry size: 32 bytes - 4KB
-  // - Merges per key: 1 - 16K
-  // - LSM component: memtable
-  //
-  // TODO(ajkr): expand measurement to SST files.
-  static const size_t kNumBytesForSvRef = 32768;
-  static const size_t kLog2AvgBytesForSvRef = 8;  // 256 bytes
-
-  size_t num_bytes = 0;
-  for (const Slice& sl : merge_context.GetOperands()) {
-    num_bytes += sl.size();
-  }
-  return num_bytes >= kNumBytesForSvRef &&
-         (num_bytes >> kLog2AvgBytesForSvRef) >=
-             merge_context.GetOperands().size();
-}
-
 Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
                        GetImplOptions& get_impl_options) {
   assert(get_impl_options.value != nullptr ||
-         get_impl_options.merge_operands != nullptr ||
-         get_impl_options.columns != nullptr);
+         get_impl_options.merge_operands != nullptr);
 
   assert(get_impl_options.column_family);
 
@@ -1978,14 +1833,6 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
     }
   }
 
-  if (get_impl_options.get_merge_operands_options != nullptr) {
-    for (int i = 0; i < get_impl_options.get_merge_operands_options
-                            ->expected_max_number_of_operands;
-         ++i) {
-      get_impl_options.merge_operands[i].Reset();
-    }
-  }
-
   // Acquire SuperVersion
   SuperVersion* sv = GetAndRefSuperVersion(cfd);
 
@@ -2061,46 +1908,29 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
   if (!skip_memtable) {
     // Get value associated with key
     if (get_impl_options.get_value) {
-      if (sv->mem->Get(
-              lkey,
-              get_impl_options.value ? get_impl_options.value->GetSelf()
-                                     : nullptr,
-              get_impl_options.columns, timestamp, &s, &merge_context,
-              &max_covering_tombstone_seq, read_options,
-              false /* immutable_memtable */, get_impl_options.callback,
-              get_impl_options.is_blob_index)) {
+      if (sv->mem->Get(lkey, get_impl_options.value->GetSelf(), timestamp, &s,
+                       &merge_context, &max_covering_tombstone_seq,
+                       read_options, get_impl_options.callback,
+                       get_impl_options.is_blob_index)) {
         done = true;
-
-        if (get_impl_options.value) {
-          get_impl_options.value->PinSelf();
-        }
-
+        get_impl_options.value->PinSelf();
         RecordTick(stats_, MEMTABLE_HIT);
       } else if ((s.ok() || s.IsMergeInProgress()) &&
-                 sv->imm->Get(lkey,
-                              get_impl_options.value
-                                  ? get_impl_options.value->GetSelf()
-                                  : nullptr,
-                              get_impl_options.columns, timestamp, &s,
-                              &merge_context, &max_covering_tombstone_seq,
-                              read_options, get_impl_options.callback,
+                 sv->imm->Get(lkey, get_impl_options.value->GetSelf(),
+                              timestamp, &s, &merge_context,
+                              &max_covering_tombstone_seq, read_options,
+                              get_impl_options.callback,
                               get_impl_options.is_blob_index)) {
         done = true;
-
-        if (get_impl_options.value) {
-          get_impl_options.value->PinSelf();
-        }
-
+        get_impl_options.value->PinSelf();
         RecordTick(stats_, MEMTABLE_HIT);
       }
     } else {
       // Get Merge Operands associated with key, Merge Operands should not be
       // merged and raw values should be returned to the user.
-      if (sv->mem->Get(lkey, /*value=*/nullptr, /*columns=*/nullptr,
-                       /*timestamp=*/nullptr, &s, &merge_context,
-                       &max_covering_tombstone_seq, read_options,
-                       false /* immutable_memtable */, nullptr, nullptr,
-                       false)) {
+      if (sv->mem->Get(lkey, /*value*/ nullptr, /*timestamp=*/nullptr, &s,
+                       &merge_context, &max_covering_tombstone_seq,
+                       read_options, nullptr, nullptr, false)) {
         done = true;
         RecordTick(stats_, MEMTABLE_HIT);
       } else if ((s.ok() || s.IsMergeInProgress()) &&
@@ -2122,9 +1952,8 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
   if (!done) {
     PERF_TIMER_GUARD(get_from_output_files_time);
     sv->current->Get(
-        read_options, lkey, get_impl_options.value, get_impl_options.columns,
-        timestamp, &s, &merge_context, &max_covering_tombstone_seq,
-        &pinned_iters_mgr,
+        read_options, lkey, get_impl_options.value, timestamp, &s,
+        &merge_context, &max_covering_tombstone_seq, &pinned_iters_mgr,
         get_impl_options.get_value ? get_impl_options.value_found : nullptr,
         nullptr, nullptr,
         get_impl_options.get_value ? get_impl_options.callback : nullptr,
@@ -2140,11 +1969,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
     size_t size = 0;
     if (s.ok()) {
       if (get_impl_options.get_value) {
-        if (get_impl_options.value) {
-          size = get_impl_options.value->size();
-        } else if (get_impl_options.columns) {
-          size = get_impl_options.columns->serialized_size();
-        }
+        size = get_impl_options.value->size();
       } else {
         // Return all merge operands for get_impl_options.key
         *get_impl_options.number_of_operands =
@@ -2155,68 +1980,19 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
           s = Status::Incomplete(
               Status::SubCode::KMergeOperandsInsufficientCapacity);
         } else {
-          // Each operand depends on one of the following resources: `sv`,
-          // `pinned_iters_mgr`, or `merge_context`. It would be crazy expensive
-          // to reference `sv` for each operand relying on it because `sv` is
-          // (un)ref'd in all threads using the DB. Furthermore, we do not track
-          // on which resource each operand depends.
-          //
-          // To solve this, we bundle the resources in a `GetMergeOperandsState`
-          // and manage them with a `SharedCleanablePtr` shared among the
-          // `PinnableSlice`s we return. This bundle includes one `sv` reference
-          // and ownership of the `merge_context` and `pinned_iters_mgr`
-          // objects.
-          bool ref_sv = ShouldReferenceSuperVersion(merge_context);
-          if (ref_sv) {
-            assert(!merge_context.GetOperands().empty());
-            SharedCleanablePtr shared_cleanable;
-            GetMergeOperandsState* state = nullptr;
-            state = new GetMergeOperandsState();
-            state->merge_context = std::move(merge_context);
-            state->pinned_iters_mgr = std::move(pinned_iters_mgr);
-
-            sv->Ref();
-
-            state->sv_handle = new SuperVersionHandle(
-                this, &mutex_, sv,
-                immutable_db_options_.avoid_unnecessary_blocking_io);
-
-            shared_cleanable.Allocate();
-            shared_cleanable->RegisterCleanup(CleanupGetMergeOperandsState,
-                                              state /* arg1 */,
-                                              nullptr /* arg2 */);
-            for (size_t i = 0; i < state->merge_context.GetOperands().size();
-                 ++i) {
-              const Slice& sl = state->merge_context.GetOperands()[i];
-              size += sl.size();
-
-              get_impl_options.merge_operands->PinSlice(
-                  sl, nullptr /* cleanable */);
-              if (i == state->merge_context.GetOperands().size() - 1) {
-                shared_cleanable.MoveAsCleanupTo(
-                    get_impl_options.merge_operands);
-              } else {
-                shared_cleanable.RegisterCopyWith(
-                    get_impl_options.merge_operands);
-              }
-              get_impl_options.merge_operands++;
-            }
-          } else {
-            for (const Slice& sl : merge_context.GetOperands()) {
-              size += sl.size();
-              get_impl_options.merge_operands->PinSelf(sl);
-              get_impl_options.merge_operands++;
-            }
+          for (const Slice& sl : merge_context.GetOperands()) {
+            size += sl.size();
+            get_impl_options.merge_operands->PinSelf(sl);
+            get_impl_options.merge_operands++;
           }
         }
       }
       RecordTick(stats_, BYTES_READ, size);
       PERF_COUNTER_ADD(get_read_bytes, size);
     }
+    RecordInHistogram(stats_, BYTES_PER_READ, size);
 
     ReturnAndCleanupSuperVersion(cfd, sv);
-
-    RecordInHistogram(stats_, BYTES_PER_READ, size);
   }
   return s;
 }
@@ -2353,14 +2129,13 @@ std::vector<Status> DBImpl::MultiGet(
          has_unpersisted_data_.load(std::memory_order_relaxed));
     bool done = false;
     if (!skip_memtable) {
-      if (super_version->mem->Get(
-              lkey, value, /*columns=*/nullptr, timestamp, &s, &merge_context,
-              &max_covering_tombstone_seq, read_options,
-              false /* immutable_memtable */, read_callback)) {
+      if (super_version->mem->Get(lkey, value, timestamp, &s, &merge_context,
+                                  &max_covering_tombstone_seq, read_options,
+                                  read_callback)) {
         done = true;
         RecordTick(stats_, MEMTABLE_HIT);
-      } else if (super_version->imm->Get(lkey, value, /*columns=*/nullptr,
-                                         timestamp, &s, &merge_context,
+      } else if (super_version->imm->Get(lkey, value, timestamp, &s,
+                                         &merge_context,
                                          &max_covering_tombstone_seq,
                                          read_options, read_callback)) {
         done = true;
@@ -2371,9 +2146,9 @@ std::vector<Status> DBImpl::MultiGet(
       PinnableSlice pinnable_val;
       PERF_TIMER_GUARD(get_from_output_files_time);
       PinnedIteratorsManager pinned_iters_mgr;
-      super_version->current->Get(read_options, lkey, &pinnable_val,
-                                  /*columns=*/nullptr, timestamp, &s,
-                                  &merge_context, &max_covering_tombstone_seq,
+      super_version->current->Get(read_options, lkey, &pinnable_val, timestamp,
+                                  &s, &merge_context,
+                                  &max_covering_tombstone_seq,
                                   &pinned_iters_mgr, /*value_found=*/nullptr,
                                   /*key_exists=*/nullptr,
                                   /*seq=*/nullptr, read_callback);
@@ -2892,8 +2667,7 @@ Status DBImpl::MultiGetImpl(
         (read_options.read_tier == kPersistedTier &&
          has_unpersisted_data_.load(std::memory_order_relaxed));
     if (!skip_memtable) {
-      super_version->mem->MultiGet(read_options, &range, callback,
-                                   false /* immutable_memtable */);
+      super_version->mem->MultiGet(read_options, &range, callback);
       if (!range.empty()) {
         super_version->imm->MultiGet(read_options, &range, callback);
       }
@@ -3093,7 +2867,12 @@ Status DBImpl::CreateColumnFamilyImpl(const ColumnFamilyOptions& cf_options,
   }  // InstrumentedMutexLock l(&mutex_)
 
   if (cf_options.preclude_last_level_data_seconds > 0) {
-    s = RegisterRecordSeqnoTimeWorker();
+    // TODO(zjay): Fix the timer issue and re-enable this.
+    ROCKS_LOG_ERROR(
+        immutable_db_options_.info_log,
+        "Creating column family with `preclude_last_level_data_seconds` needs "
+        "to restart DB to take effect");
+    //    s = RegisterRecordSeqnoTimeWorker();
   }
   sv_context.Clean();
   // this is outside the mutex
@@ -3159,7 +2938,7 @@ Status DBImpl::DropColumnFamilyImpl(ColumnFamilyHandle* column_family) {
       WriteThread::Writer w;
       write_thread_.EnterUnbatched(&w, &mutex_);
       s = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(), &edit,
-                                 &mutex_, directories_.GetDbDir());
+                                 &mutex_);
       write_thread_.ExitUnbatched(&w);
     }
     if (s.ok()) {
@@ -3364,8 +3143,9 @@ ArenaWrappedDBIter* DBImpl::NewIteratorImpl(const ReadOptions& read_options,
       read_options.snapshot != nullptr ? false : allow_refresh);
 
   InternalIterator* internal_iter = NewInternalIterator(
-      db_iter->GetReadOptions(), cfd, sv, db_iter->GetArena(), snapshot,
-      /* allow_unprepared_value */ true, db_iter);
+      db_iter->GetReadOptions(), cfd, sv, db_iter->GetArena(),
+      db_iter->GetRangeDelAggregator(), snapshot,
+      /* allow_unprepared_value */ true);
   db_iter->SetIterUnderDBIter(internal_iter);
 
   return db_iter;
@@ -3663,16 +3443,14 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
     if (oldest_snapshot > bottommost_files_mark_threshold_) {
       CfdList cf_scheduled;
       for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        if (!cfd->ioptions()->allow_ingest_behind) {
-          cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
-          if (!cfd->current()
-                   ->storage_info()
-                   ->BottommostFilesMarkedForCompaction()
-                   .empty()) {
-            SchedulePendingCompaction(cfd);
-            MaybeScheduleFlushOrCompaction();
-            cf_scheduled.push_back(cfd);
-          }
+        cfd->current()->storage_info()->UpdateOldestSnapshot(oldest_snapshot);
+        if (!cfd->current()
+                 ->storage_info()
+                 ->BottommostFilesMarkedForCompaction()
+                 .empty()) {
+          SchedulePendingCompaction(cfd);
+          MaybeScheduleFlushOrCompaction();
+          cf_scheduled.push_back(cfd);
         }
       }
 
@@ -3681,8 +3459,7 @@ void DBImpl::ReleaseSnapshot(const Snapshot* s) {
       // mutex might be unlocked during the loop, making the result inaccurate.
       SequenceNumber new_bottommost_files_mark_threshold = kMaxSequenceNumber;
       for (auto* cfd : *versions_->GetColumnFamilySet()) {
-        if (CfdListContains(cf_scheduled, cfd) ||
-            cfd->ioptions()->allow_ingest_behind) {
+        if (CfdListContains(cf_scheduled, cfd)) {
           continue;
         }
         new_bottommost_files_mark_threshold = std::min(
@@ -4959,10 +4736,9 @@ Status DBImpl::GetLatestSequenceForKey(
   *found_record_for_key = false;
 
   // Check if there is a record for this key in the latest memtable
-  sv->mem->Get(lkey, /*value=*/nullptr, /*columns=*/nullptr, timestamp, &s,
-               &merge_context, &max_covering_tombstone_seq, seq, read_options,
-               false /* immutable_memtable */, nullptr /*read_callback*/,
-               is_blob_index);
+  sv->mem->Get(lkey, /*value=*/nullptr, timestamp, &s, &merge_context,
+               &max_covering_tombstone_seq, seq, read_options,
+               nullptr /*read_callback*/, is_blob_index);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
     // unexpected error reading memtable.
@@ -4993,8 +4769,8 @@ Status DBImpl::GetLatestSequenceForKey(
   }
 
   // Check if there is a record for this key in the immutable memtables
-  sv->imm->Get(lkey, /*value=*/nullptr, /*columns=*/nullptr, timestamp, &s,
-               &merge_context, &max_covering_tombstone_seq, seq, read_options,
+  sv->imm->Get(lkey, /*value=*/nullptr, timestamp, &s, &merge_context,
+               &max_covering_tombstone_seq, seq, read_options,
                nullptr /*read_callback*/, is_blob_index);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
@@ -5025,10 +4801,9 @@ Status DBImpl::GetLatestSequenceForKey(
   }
 
   // Check if there is a record for this key in the immutable memtables
-  sv->imm->GetFromHistory(lkey, /*value=*/nullptr, /*columns=*/nullptr,
-                          timestamp, &s, &merge_context,
-                          &max_covering_tombstone_seq, seq, read_options,
-                          is_blob_index);
+  sv->imm->GetFromHistory(lkey, /*value=*/nullptr, timestamp, &s,
+                          &merge_context, &max_covering_tombstone_seq, seq,
+                          read_options, is_blob_index);
 
   if (!(s.ok() || s.IsNotFound() || s.IsMergeInProgress())) {
     // unexpected error reading memtable.
@@ -5061,8 +4836,8 @@ Status DBImpl::GetLatestSequenceForKey(
   if (!cache_only) {
     // Check tables
     PinnedIteratorsManager pinned_iters_mgr;
-    sv->current->Get(read_options, lkey, /*value=*/nullptr, /*columns=*/nullptr,
-                     timestamp, &s, &merge_context, &max_covering_tombstone_seq,
+    sv->current->Get(read_options, lkey, /*value=*/nullptr, timestamp, &s,
+                     &merge_context, &max_covering_tombstone_seq,
                      &pinned_iters_mgr, nullptr /* value_found */,
                      found_record_for_key, seq, nullptr /*read_callback*/,
                      is_blob_index);

db/db_impl/db_impl.h

@@ -32,7 +32,6 @@
 #include "db/log_writer.h"
 #include "db/logs_with_prep_tracker.h"
 #include "db/memtable_list.h"
-#include "db/periodic_task_scheduler.h"
 #include "db/post_memtable_callback.h"
 #include "db/pre_release_callback.h"
 #include "db/range_del_aggregator.h"
@@ -76,6 +75,10 @@ class ArenaWrappedDBIter;
 class InMemoryStatsHistoryIterator;
 class MemTable;
 class PersistentStatsHistoryIterator;
+class PeriodicWorkScheduler;
+#ifndef NDEBUG
+class PeriodicWorkTestScheduler;
+#endif  // !NDEBUG
 class TableCache;
 class TaskLimiterToken;
 class Version;
@@ -235,11 +238,6 @@ class DBImpl : public DB {
                      ColumnFamilyHandle* column_family, const Slice& key,
                      PinnableSlice* value, std::string* timestamp) override;
 
-  using DB::GetEntity;
-  Status GetEntity(const ReadOptions& options,
-                   ColumnFamilyHandle* column_family, const Slice& key,
-                   PinnableWideColumns* columns) override;
-
   using DB::GetMergeOperands;
   Status GetMergeOperands(const ReadOptions& options,
                           ColumnFamilyHandle* column_family, const Slice& key,
@@ -594,7 +592,6 @@ class DBImpl : public DB {
   struct GetImplOptions {
     ColumnFamilyHandle* column_family = nullptr;
     PinnableSlice* value = nullptr;
-    PinnableWideColumns* columns = nullptr;
     std::string* timestamp = nullptr;
     bool* value_found = nullptr;
     ReadCallback* callback = nullptr;
@@ -739,29 +736,13 @@ class DBImpl : public DB {
   // the value and so will require PrepareValue() to be called before value();
   // allow_unprepared_value = false is convenient when this optimization is not
   // useful, e.g. when reading the whole column family.
-  //
-  // read_options.ignore_range_deletions determines whether range tombstones are
-  // processed in the returned interator internally, i.e., whether range
-  // tombstone covered keys are in this iterator's output.
   // @param read_options Must outlive the returned iterator.
   InternalIterator* NewInternalIterator(
-      const ReadOptions& read_options, Arena* arena, SequenceNumber sequence,
+      const ReadOptions& read_options, Arena* arena,
+      RangeDelAggregator* range_del_agg, SequenceNumber sequence,
       ColumnFamilyHandle* column_family = nullptr,
       bool allow_unprepared_value = false);
 
-  // Note: to support DB iterator refresh, memtable range tombstones in the
-  // underlying merging iterator needs to be refreshed. If db_iter is not
-  // nullptr, db_iter->SetMemtableRangetombstoneIter() is called with the
-  // memtable range tombstone iterator used by the underlying merging iterator.
-  // This range tombstone iterator can be refreshed later by db_iter.
-  // @param read_options Must outlive the returned iterator.
-  InternalIterator* NewInternalIterator(const ReadOptions& read_options,
-                                        ColumnFamilyData* cfd,
-                                        SuperVersion* super_version,
-                                        Arena* arena, SequenceNumber sequence,
-                                        bool allow_unprepared_value,
-                                        ArenaWrappedDBIter* db_iter = nullptr);
-
   LogsWithPrepTracker* logs_with_prep_tracker() {
     return &logs_with_prep_tracker_;
   }
@@ -884,6 +865,15 @@ class DBImpl : public DB {
 
   const WriteController& write_controller() { return write_controller_; }
 
+  // @param read_options Must outlive the returned iterator.
+  InternalIterator* NewInternalIterator(const ReadOptions& read_options,
+                                        ColumnFamilyData* cfd,
+                                        SuperVersion* super_version,
+                                        Arena* arena,
+                                        RangeDelAggregator* range_del_agg,
+                                        SequenceNumber sequence,
+                                        bool allow_unprepared_value);
+
   // hollow transactions shell used for recovery.
   // these will then be passed to TransactionDB so that
   // locks can be reacquired before writing can resume.
@@ -989,7 +979,6 @@ class DBImpl : public DB {
   }
 
   void AddToLogsToFreeQueue(log::Writer* log_writer) {
-    mutex_.AssertHeld();
     logs_to_free_queue_.push_back(log_writer);
   }
 
@@ -1151,7 +1140,7 @@ class DBImpl : public DB {
   int TEST_BGCompactionsAllowed() const;
   int TEST_BGFlushesAllowed() const;
   size_t TEST_GetWalPreallocateBlockSize(uint64_t write_buffer_size) const;
-  void TEST_WaitForPeridicTaskRun(std::function<void()> callback) const;
+  void TEST_WaitForPeridicWorkerRun(std::function<void()> callback) const;
   SeqnoToTimeMapping TEST_GetSeqnoToTimeMapping() const;
   size_t TEST_EstimateInMemoryStatsHistorySize() const;
 
@@ -1166,7 +1155,7 @@ class DBImpl : public DB {
   }
 
 #ifndef ROCKSDB_LITE
-  const PeriodicTaskScheduler& TEST_GetPeriodicTaskScheduler() const;
+  PeriodicWorkTestScheduler* TEST_GetPeriodicWorkScheduler() const;
 #endif  // !ROCKSDB_LITE
 
 #endif  // NDEBUG
@@ -1290,7 +1279,7 @@ class DBImpl : public DB {
 
   // only used for dynamically adjusting max_total_wal_size. it is a sum of
   // [write_buffer_size * max_write_buffer_number] over all column families
-  std::atomic<uint64_t> max_total_in_memory_state_;
+  uint64_t max_total_in_memory_state_;
 
   // The options to access storage files
   const FileOptions file_options_;
@@ -1394,7 +1383,7 @@ class DBImpl : public DB {
   void NotifyOnExternalFileIngested(
       ColumnFamilyData* cfd, const ExternalSstFileIngestionJob& ingestion_job);
 
-  virtual Status FlushForGetLiveFiles();
+  Status FlushForGetLiveFiles();
 #endif  // !ROCKSDB_LITE
 
   void NewThreadStatusCfInfo(ColumnFamilyData* cfd) const;
@@ -1640,15 +1629,6 @@ class DBImpl : public DB {
     uint64_t pre_sync_size = 0;
   };
 
-  struct LogContext {
-    explicit LogContext(bool need_sync = false)
-        : need_log_sync(need_sync), need_log_dir_sync(need_sync) {}
-    bool need_log_sync = false;
-    bool need_log_dir_sync = false;
-    log::Writer* writer = nullptr;
-    LogFileNumberSize* log_file_number_size = nullptr;
-  };
-
   // PurgeFileInfo is a structure to hold information of files to be deleted in
   // purge_files_
   struct PurgeFileInfo {
@@ -1802,7 +1782,7 @@ class DBImpl : public DB {
   void ReleaseFileNumberFromPendingOutputs(
       std::unique_ptr<std::list<uint64_t>::iterator>& v);
 
-  IOStatus SyncClosedLogs(JobContext* job_context, VersionEdit* synced_wals);
+  IOStatus SyncClosedLogs(JobContext* job_context);
 
   // Flush the in-memory write buffer to storage.  Switches to a new
   // log-file/memtable and writes a new descriptor iff successful. Then
@@ -1962,8 +1942,8 @@ class DBImpl : public DB {
   Status HandleWriteBufferManagerFlush(WriteContext* write_context);
 
   // REQUIRES: mutex locked
-  Status PreprocessWrite(const WriteOptions& write_options,
-                         LogContext* log_context, WriteContext* write_context);
+  Status PreprocessWrite(const WriteOptions& write_options, bool* need_log_sync,
+                         WriteContext* write_context);
 
   // Merge write batches in the write group into merged_batch.
   // Returns OK if merge is successful.
@@ -2073,7 +2053,7 @@ class DBImpl : public DB {
                               LogBuffer* log_buffer);
 
   // Schedule background tasks
-  Status StartPeriodicTaskScheduler();
+  Status StartPeriodicWorkScheduler();
 
   Status RegisterRecordSeqnoTimeWorker();
 
@@ -2102,8 +2082,7 @@ class DBImpl : public DB {
       std::unique_ptr<TaskLimiterToken>* token, LogBuffer* log_buffer);
 
   // helper function to call after some of the logs_ were synced
-  void MarkLogsSynced(uint64_t up_to, bool synced_dir, VersionEdit* edit);
-  Status ApplyWALToManifest(VersionEdit* edit);
+  Status MarkLogsSynced(uint64_t up_to, bool synced_dir);
   // WALs with log number up to up_to are not synced successfully.
   void MarkLogsNotSynced(uint64_t up_to);
 
@@ -2179,6 +2158,11 @@ class DBImpl : public DB {
   IOStatus CreateWAL(uint64_t log_file_num, uint64_t recycle_log_number,
                      size_t preallocate_block_size, log::Writer** new_log);
 
+  // Verify SST file unique id between Manifest and table properties to make
+  // sure they're the same. Currently only used during DB open when
+  // `verify_sst_unique_id_in_manifest = true`.
+  Status VerifySstUniqueIdInManifest();
+
   // Validate self-consistency of DB options
   static Status ValidateOptions(const DBOptions& db_options);
   // Validate self-consistency of DB options and its consistency with cf options
@@ -2265,8 +2249,6 @@ class DBImpl : public DB {
   Status IncreaseFullHistoryTsLowImpl(ColumnFamilyData* cfd,
                                       std::string ts_low);
 
-  bool ShouldReferenceSuperVersion(const MergeContext& merge_context);
-
   // Lock over the persistent DB state.  Non-nullptr iff successfully acquired.
   FileLock* db_lock_;
 
@@ -2306,9 +2288,8 @@ class DBImpl : public DB {
   // logfile_number_ is currently updated only in write_thread_, it can be read
   // from the same write_thread_ without any locks.
   uint64_t logfile_number_;
-  // Log files that we can recycle. Must be protected by db mutex_.
-  std::deque<uint64_t> log_recycle_files_;
-  // Protected by log_write_mutex_.
+  std::deque<uint64_t>
+      log_recycle_files_;  // a list of log files that we can recycle
   bool log_dir_synced_;
   // Without two_write_queues, read and writes to log_empty_ are protected by
   // mutex_. Since it is currently updated/read only in write_thread_, it can be
@@ -2322,93 +2303,26 @@ class DBImpl : public DB {
 
   bool persistent_stats_cfd_exists_ = true;
 
-  // alive_log_files_ is protected by mutex_ and log_write_mutex_ with details
-  // as follows:
-  // 1. read by FindObsoleteFiles() which can be called in either application
-  //    thread or RocksDB bg threads, both mutex_ and log_write_mutex_ are
-  //    held.
-  // 2. pop_front() by FindObsoleteFiles(), both mutex_ and log_write_mutex_
-  //    are held.
-  // 3. push_back() by DBImpl::Open() and DBImpl::RestoreAliveLogFiles()
-  //    (actually called by Open()), only mutex_ is held because at this point,
-  //    the DB::Open() call has not returned success to application, and the
-  //    only other thread(s) that can conflict are bg threads calling
-  //    FindObsoleteFiles() which ensure that both mutex_ and log_write_mutex_
-  //    are held when accessing alive_log_files_.
-  // 4. read by DBImpl::Open() is protected by mutex_.
-  // 5. push_back() by SwitchMemtable(). Both mutex_ and log_write_mutex_ are
-  //    held. This is done by the write group leader. Note that in the case of
-  //    two-write-queues, another WAL-only write thread can be writing to the
-  //    WAL concurrently. See 9.
-  // 6. read by SwitchWAL() with both mutex_ and log_write_mutex_ held. This is
-  //    done by write group leader.
-  // 7. read by ConcurrentWriteToWAL() by the write group leader in the case of
-  //    two-write-queues. Only log_write_mutex_ is held to protect concurrent
-  //    pop_front() by FindObsoleteFiles().
-  // 8. read by PreprocessWrite() by the write group leader. log_write_mutex_
-  //    is held to protect the data structure from concurrent pop_front() by
-  //    FindObsoleteFiles().
-  // 9. read by ConcurrentWriteToWAL() by a WAL-only write thread in the case
-  //    of two-write-queues. Only log_write_mutex_ is held. This suffices to
-  //    protect the data structure from concurrent push_back() by current
-  //    write group leader as well as pop_front() by FindObsoleteFiles().
+  // Without two_write_queues, read and writes to alive_log_files_ are
+  // protected by mutex_. With two_write_queues_, writes
+  // are protected by locking both mutex_ and log_write_mutex_, and reads must
+  // be under either mutex_ or log_write_mutex_.
   std::deque<LogFileNumberSize> alive_log_files_;
 
   // Log files that aren't fully synced, and the current log file.
   // Synchronization:
-  // 1. read by FindObsoleteFiles() which can be called either in application
-  //    thread or RocksDB bg threads. log_write_mutex_ is always held, while
-  //    some reads are performed without mutex_.
-  // 2. pop_front() by FindObsoleteFiles() with only log_write_mutex_ held.
-  // 3. read by DBImpl::Open() with both mutex_ and log_write_mutex_.
-  // 4. emplace_back() by DBImpl::Open() with both mutex_ and log_write_mutex.
-  //    Note that at this point, DB::Open() has not returned success to
-  //    application, thus the only other thread(s) that can conflict are bg
-  //    threads calling FindObsoleteFiles(). See 1.
-  // 5. iteration and clear() from CloseHelper() always hold log_write_mutex
-  //    and mutex_.
-  // 6. back() called by APIs FlushWAL() and LockWAL() are protected by only
-  //    log_write_mutex_. These two can be called by application threads after
-  //    DB::Open() returns success to applications.
-  // 7. read by SyncWAL(), another API, protected by only log_write_mutex_.
-  // 8. read by MarkLogsNotSynced() and MarkLogsSynced() are protected by
-  //    log_write_mutex_.
-  // 9. erase() by MarkLogsSynced() protected by log_write_mutex_.
-  // 10. read by SyncClosedLogs() protected by only log_write_mutex_. This can
-  //     happen in bg flush threads after DB::Open() returns success to
-  //     applications.
-  // 11. reads, e.g. front(), iteration, and back() called by PreprocessWrite()
-  //     holds only the log_write_mutex_. This is done by the write group
-  //     leader. A bg thread calling FindObsoleteFiles() or MarkLogsSynced()
-  //     can happen concurrently. This is fine because log_write_mutex_ is used
-  //     by all parties. See 2, 5, 9.
-  // 12. reads, empty(), back() called by SwitchMemtable() hold both mutex_ and
-  //     log_write_mutex_. This happens in the write group leader.
-  // 13. emplace_back() by SwitchMemtable() hold both mutex_ and
-  //     log_write_mutex_. This happens in the write group leader. Can conflict
-  //     with bg threads calling FindObsoleteFiles(), MarkLogsSynced(),
-  //     SyncClosedLogs(), etc. as well as application threads calling
-  //     FlushWAL(), SyncWAL(), LockWAL(). This is fine because all parties
-  //     require at least log_write_mutex_.
-  // 14. iteration called in WriteToWAL(write_group) protected by
-  //     log_write_mutex_. This is done by write group leader when
-  //     two-write-queues is disabled and write needs to sync logs.
-  // 15. back() called in ConcurrentWriteToWAL() protected by log_write_mutex_.
-  //     This can be done by the write group leader if two-write-queues is
-  //     enabled. It can also be done by another WAL-only write thread.
-  //
-  // Other observations:
+  //  - push_back() is done from write_thread_ with locked mutex_ and
+  //  log_write_mutex_
+  //  - pop_front() is done from any thread with locked mutex_ and
+  //  log_write_mutex_
+  //  - reads are done with either locked mutex_ or log_write_mutex_
   //  - back() and items with getting_synced=true are not popped,
   //  - The same thread that sets getting_synced=true will reset it.
   //  - it follows that the object referred by back() can be safely read from
-  //  the write_thread_ without using mutex. Note that calling back() without
-  //  mutex may be unsafe because different implementations of deque::back() may
-  //  access other member variables of deque, causing undefined behaviors.
-  //  Generally, do not access stl containers without proper synchronization.
+  //  the write_thread_ without using mutex
   //  - it follows that the items with getting_synced=true can be safely read
   //  from the same thread that has set getting_synced=true
   std::deque<LogWriterNumber> logs_;
-
   // Signaled when getting_synced becomes false for some of the logs_.
   InstrumentedCondVar log_sync_cv_;
   // This is the app-level state that is written to the WAL but will be used
@@ -2423,7 +2337,7 @@ class DBImpl : public DB {
   std::atomic<uint64_t> total_log_size_;
 
   // If this is non-empty, we need to delete these log files in background
-  // threads. Protected by log_write_mutex_.
+  // threads. Protected by db mutex.
   autovector<log::Writer*> logs_to_free_;
 
   bool is_snapshot_supported_;
@@ -2503,13 +2417,10 @@ class DBImpl : public DB {
   // JobContext. Current implementation tracks table and blob files only.
   std::unordered_set<uint64_t> files_grabbed_for_purge_;
 
-  // A queue to store log writers to close. Protected by db mutex_.
+  // A queue to store log writers to close
   std::deque<log::Writer*> logs_to_free_queue_;
-
   std::deque<SuperVersion*> superversions_to_free_queue_;
-
   int unscheduled_flushes_;
-
   int unscheduled_compactions_;
 
   // count how many background compactions are running or have been scheduled in
@@ -2610,11 +2521,14 @@ class DBImpl : public DB {
 
 #ifndef ROCKSDB_LITE
   // Scheduler to run DumpStats(), PersistStats(), and FlushInfoLog().
-  // Currently, internally it has a global timer instance for running the tasks.
-  PeriodicTaskScheduler periodic_task_scheduler_;
+  // Currently, it always use a global instance from
+  // PeriodicWorkScheduler::Default(). Only in unittest, it can be overrided by
+  // PeriodicWorkTestScheduler.
+  PeriodicWorkScheduler* periodic_work_scheduler_;
 
-  // It contains the implementations for each periodic task.
-  std::map<PeriodicTaskType, const PeriodicTaskFunc> periodic_task_functions_;
+  // Current cadence of the periodic worker for recording sequence number to
+  // time.
+  uint64_t record_seqno_time_cadence_ = 0;
 #endif
 
   // When set, we use a separate queue for writes that don't write to memtable.
@@ -2659,7 +2573,6 @@ class DBImpl : public DB {
   InstrumentedCondVar atomic_flush_install_cv_;
 
   bool wal_in_db_path_;
-  std::atomic<uint64_t> max_total_wal_size_;
 
   BlobFileCompletionCallback blob_callback_;
 

db/db_impl/db_impl_compaction_flush.cc

@@ -82,10 +82,9 @@ bool DBImpl::RequestCompactionToken(ColumnFamilyData* cfd, bool force,
   return false;
 }
 
-IOStatus DBImpl::SyncClosedLogs(JobContext* job_context,
-                                VersionEdit* synced_wals) {
+IOStatus DBImpl::SyncClosedLogs(JobContext* job_context) {
   TEST_SYNC_POINT("DBImpl::SyncClosedLogs:Start");
-  InstrumentedMutexLock l(&log_write_mutex_);
+  mutex_.AssertHeld();
   autovector<log::Writer*, 1> logs_to_sync;
   uint64_t current_log_number = logfile_number_;
   while (logs_.front().number < current_log_number &&
@@ -101,7 +100,7 @@ IOStatus DBImpl::SyncClosedLogs(JobContext* job_context,
 
   IOStatus io_s;
   if (!logs_to_sync.empty()) {
-    log_write_mutex_.Unlock();
+    mutex_.Unlock();
 
     assert(job_context);
 
@@ -109,18 +108,12 @@ IOStatus DBImpl::SyncClosedLogs(JobContext* job_context,
       ROCKS_LOG_INFO(immutable_db_options_.info_log,
                      "[JOB %d] Syncing log #%" PRIu64, job_context->job_id,
                      log->get_log_number());
-      if (error_handler_.IsRecoveryInProgress()) {
-        log->file()->reset_seen_error();
-      }
       io_s = log->file()->Sync(immutable_db_options_.use_fsync);
       if (!io_s.ok()) {
         break;
       }
 
       if (immutable_db_options_.recycle_log_file_num > 0) {
-        if (error_handler_.IsRecoveryInProgress()) {
-          log->file()->reset_seen_error();
-        }
         io_s = log->Close();
         if (!io_s.ok()) {
           break;
@@ -135,12 +128,12 @@ IOStatus DBImpl::SyncClosedLogs(JobContext* job_context,
 
     TEST_SYNC_POINT_CALLBACK("DBImpl::SyncClosedLogs:BeforeReLock",
                              /*arg=*/nullptr);
-    log_write_mutex_.Lock();
+    mutex_.Lock();
 
     // "number <= current_log_number - 1" is equivalent to
     // "number < current_log_number".
     if (io_s.ok()) {
-      MarkLogsSynced(current_log_number - 1, true, synced_wals);
+      io_s = status_to_io_status(MarkLogsSynced(current_log_number - 1, true));
     } else {
       MarkLogsNotSynced(current_log_number - 1);
     }
@@ -227,18 +220,8 @@ Status DBImpl::FlushMemTableToOutputFile(
   bool need_cancel = false;
   IOStatus log_io_s = IOStatus::OK();
   if (needs_to_sync_closed_wals) {
-    // SyncClosedLogs() may unlock and re-lock the log_write_mutex multiple
-    // times.
-    VersionEdit synced_wals;
-    mutex_.Unlock();
-    log_io_s = SyncClosedLogs(job_context, &synced_wals);
-    mutex_.Lock();
-    if (log_io_s.ok() && synced_wals.IsWalAddition()) {
-      log_io_s = status_to_io_status(ApplyWALToManifest(&synced_wals));
-      TEST_SYNC_POINT_CALLBACK("DBImpl::FlushMemTableToOutputFile:CommitWal:1",
-                               nullptr);
-    }
-
+    // SyncClosedLogs() may unlock and re-lock the db_mutex.
+    log_io_s = SyncClosedLogs(job_context);
     if (!log_io_s.ok() && !log_io_s.IsShutdownInProgress() &&
         !log_io_s.IsColumnFamilyDropped()) {
       error_handler_.SetBGError(log_io_s, BackgroundErrorReason::kFlush);
@@ -491,14 +474,7 @@ Status DBImpl::AtomicFlushMemTablesToOutputFiles(
   if (logfile_number_ > 0) {
     // TODO (yanqin) investigate whether we should sync the closed logs for
     // single column family case.
-    VersionEdit synced_wals;
-    mutex_.Unlock();
-    log_io_s = SyncClosedLogs(job_context, &synced_wals);
-    mutex_.Lock();
-    if (log_io_s.ok() && synced_wals.IsWalAddition()) {
-      log_io_s = status_to_io_status(ApplyWALToManifest(&synced_wals));
-    }
-
+    log_io_s = SyncClosedLogs(job_context);
     if (!log_io_s.ok() && !log_io_s.IsShutdownInProgress() &&
         !log_io_s.IsColumnFamilyDropped()) {
       if (total_log_size_ > 0) {
@@ -988,7 +964,7 @@ Status DBImpl::IncreaseFullHistoryTsLowImpl(ColumnFamilyData* cfd,
   }
 
   Status s = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
-                                    &edit, &mutex_, directories_.GetDbDir());
+                                    &edit, &mutex_);
   if (!s.ok()) {
     return s;
   }
@@ -1416,8 +1392,7 @@ Status DBImpl::CompactFilesImpl(
       &compaction_job_stats, Env::Priority::USER, io_tracer_,
       kManualCompactionCanceledFalse_, db_id_, db_session_id_,
       c->column_family_data()->GetFullHistoryTsLow(), c->trim_ts(),
-      &blob_callback_, &bg_compaction_scheduled_,
-      &bg_bottom_compaction_scheduled_);
+      &blob_callback_);
 
   // Creating a compaction influences the compaction score because the score
   // takes running compactions into account (by skipping files that are already
@@ -1694,7 +1669,8 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
           f->smallest, f->largest, f->fd.smallest_seqno, f->fd.largest_seqno,
           f->marked_for_compaction, f->temperature, f->oldest_blob_file_number,
           f->oldest_ancester_time, f->file_creation_time, f->file_checksum,
-          f->file_checksum_func_name, f->unique_id);
+          f->file_checksum_func_name, f->min_timestamp, f->max_timestamp,
+          f->unique_id);
     }
     ROCKS_LOG_DEBUG(immutable_db_options_.info_log,
                     "[%s] Apply version edit:\n%s", cfd->GetName().c_str(),
@@ -1860,7 +1836,8 @@ Status DBImpl::RunManualCompaction(
   // jobs drops to zero. This used to be needed to ensure that this manual
   // compaction can compact any range of keys/files. Now it is optional
   // (see `CompactRangeOptions::exclusive_manual_compaction`). The use case for
-  // `exclusive_manual_compaction=true` is unclear beyond not trusting the code.
+  // `exclusive_manual_compaction=true` (the default) is unclear beyond not
+  // trusting the new code.
   //
   // HasPendingManualCompaction() is true when at least one thread is inside
   // RunManualCompaction(), i.e. during that time no other compaction will
@@ -3320,7 +3297,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
             f->fd.largest_seqno, f->marked_for_compaction, f->temperature,
             f->oldest_blob_file_number, f->oldest_ancester_time,
             f->file_creation_time, f->file_checksum, f->file_checksum_func_name,
-            f->unique_id);
+            f->min_timestamp, f->max_timestamp, f->unique_id);
 
         ROCKS_LOG_BUFFER(
             log_buffer,
@@ -3337,8 +3314,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
       if (start_level > 0) {
         auto vstorage = c->input_version()->storage_info();
         c->edit()->AddCompactCursor(
-            start_level,
-            vstorage->GetNextCompactCursor(start_level, c->num_input_files(0)));
+            start_level, vstorage->GetNextCompactCursor(start_level));
       }
     }
     status = versions_->LogAndApply(c->column_family_data(),
@@ -3423,8 +3399,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
         is_manual ? manual_compaction->canceled
                   : kManualCompactionCanceledFalse_,
         db_id_, db_session_id_, c->column_family_data()->GetFullHistoryTsLow(),
-        c->trim_ts(), &blob_callback_, &bg_compaction_scheduled_,
-        &bg_bottom_compaction_scheduled_);
+        c->trim_ts(), &blob_callback_);
     compaction_job.Prepare();
 
     NotifyOnCompactionBegin(c->column_family_data(), c.get(), status,
@@ -3756,11 +3731,9 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
   // triggered soon anyway.
   bottommost_files_mark_threshold_ = kMaxSequenceNumber;
   for (auto* my_cfd : *versions_->GetColumnFamilySet()) {
-    if (!my_cfd->ioptions()->allow_ingest_behind) {
-      bottommost_files_mark_threshold_ = std::min(
-          bottommost_files_mark_threshold_,
-          my_cfd->current()->storage_info()->bottommost_files_mark_threshold());
-    }
+    bottommost_files_mark_threshold_ = std::min(
+        bottommost_files_mark_threshold_,
+        my_cfd->current()->storage_info()->bottommost_files_mark_threshold());
   }
 
   // Whenever we install new SuperVersion, we might need to issue new flushes or

db/db_impl/db_impl_debug.cc

@@ -12,7 +12,7 @@
 #include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
-#include "db/periodic_task_scheduler.h"
+#include "db/periodic_work_scheduler.h"
 #include "monitoring/thread_status_updater.h"
 #include "util/cast_util.h"
 
@@ -223,7 +223,7 @@ void DBImpl::TEST_EndWrite(void* w) {
 }
 
 size_t DBImpl::TEST_LogsToFreeSize() {
-  InstrumentedMutexLock l(&log_write_mutex_);
+  InstrumentedMutexLock l(&mutex_);
   return logs_to_free_.size();
 }
 
@@ -302,12 +302,16 @@ size_t DBImpl::TEST_GetWalPreallocateBlockSize(
 }
 
 #ifndef ROCKSDB_LITE
-void DBImpl::TEST_WaitForPeridicTaskRun(std::function<void()> callback) const {
-  periodic_task_scheduler_.TEST_WaitForRun(callback);
+void DBImpl::TEST_WaitForPeridicWorkerRun(
+    std::function<void()> callback) const {
+  if (periodic_work_scheduler_ != nullptr) {
+    static_cast<PeriodicWorkTestScheduler*>(periodic_work_scheduler_)
+        ->TEST_WaitForRun(callback);
+  }
 }
 
-const PeriodicTaskScheduler& DBImpl::TEST_GetPeriodicTaskScheduler() const {
-  return periodic_task_scheduler_;
+PeriodicWorkTestScheduler* DBImpl::TEST_GetPeriodicWorkScheduler() const {
+  return static_cast<PeriodicWorkTestScheduler*>(periodic_work_scheduler_);
 }
 
 SeqnoToTimeMapping DBImpl::TEST_GetSeqnoToTimeMapping() const {

db/db_impl/db_impl_experimental.cc

@@ -131,13 +131,13 @@ Status DBImpl::PromoteL0(ColumnFamilyHandle* column_family, int target_level) {
     edit.SetColumnFamily(cfd->GetID());
     for (const auto& f : l0_files) {
       edit.DeleteFile(0, f->fd.GetNumber());
-      edit.AddFile(target_level, f->fd.GetNumber(), f->fd.GetPathId(),
-                   f->fd.GetFileSize(), f->smallest, f->largest,
-                   f->fd.smallest_seqno, f->fd.largest_seqno,
-                   f->marked_for_compaction, f->temperature,
-                   f->oldest_blob_file_number, f->oldest_ancester_time,
-                   f->file_creation_time, f->file_checksum,
-                   f->file_checksum_func_name, f->unique_id);
+      edit.AddFile(
+          target_level, f->fd.GetNumber(), f->fd.GetPathId(),
+          f->fd.GetFileSize(), f->smallest, f->largest, f->fd.smallest_seqno,
+          f->fd.largest_seqno, f->marked_for_compaction, f->temperature,
+          f->oldest_blob_file_number, f->oldest_ancester_time,
+          f->file_creation_time, f->file_checksum, f->file_checksum_func_name,
+          f->min_timestamp, f->max_timestamp, f->unique_id);
     }
 
     status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),

db/db_impl/db_impl_files.cc

@@ -271,15 +271,6 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
 
   // logs_ is empty when called during recovery, in which case there can't yet
   // be any tracked obsolete logs
-  log_write_mutex_.Lock();
-
-  if (alive_log_files_.empty() || logs_.empty()) {
-    mutex_.AssertHeld();
-    // We may reach here if the db is DBImplSecondary
-    log_write_mutex_.Unlock();
-    return;
-  }
-
   if (!alive_log_files_.empty() && !logs_.empty()) {
     uint64_t min_log_number = job_context->log_number;
     size_t num_alive_log_files = alive_log_files_.size();
@@ -301,15 +292,17 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
       }
       job_context->size_log_to_delete += earliest.size;
       total_log_size_ -= earliest.size;
+      if (two_write_queues_) {
+        log_write_mutex_.Lock();
+      }
       alive_log_files_.pop_front();
-
+      if (two_write_queues_) {
+        log_write_mutex_.Unlock();
+      }
       // Current log should always stay alive since it can't have
       // number < MinLogNumber().
       assert(alive_log_files_.size());
     }
-    log_write_mutex_.Unlock();
-    mutex_.Unlock();
-    log_write_mutex_.Lock();
     while (!logs_.empty() && logs_.front().number < min_log_number) {
       auto& log = logs_.front();
       if (log.IsSyncing()) {
@@ -318,7 +311,10 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
         continue;
       }
       logs_to_free_.push_back(log.ReleaseWriter());
-      logs_.pop_front();
+      {
+        InstrumentedMutexLock wl(&log_write_mutex_);
+        logs_.pop_front();
+      }
     }
     // Current log cannot be obsolete.
     assert(!logs_.empty());
@@ -327,14 +323,24 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
   // We're just cleaning up for DB::Write().
   assert(job_context->logs_to_free.empty());
   job_context->logs_to_free = logs_to_free_;
-
-  logs_to_free_.clear();
-  log_write_mutex_.Unlock();
-  mutex_.Lock();
   job_context->log_recycle_files.assign(log_recycle_files_.begin(),
                                         log_recycle_files_.end());
+  logs_to_free_.clear();
 }
 
+namespace {
+bool CompareCandidateFile(const JobContext::CandidateFileInfo& first,
+                          const JobContext::CandidateFileInfo& second) {
+  if (first.file_name > second.file_name) {
+    return true;
+  } else if (first.file_name < second.file_name) {
+    return false;
+  } else {
+    return (first.file_path > second.file_path);
+  }
+}
+}  // namespace
+
 // Delete obsolete files and log status and information of file deletion
 void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
                                     const std::string& path_to_sync,
@@ -439,16 +445,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
   // dedup state.candidate_files so we don't try to delete the same
   // file twice
   std::sort(candidate_files.begin(), candidate_files.end(),
-            [](const JobContext::CandidateFileInfo& lhs,
-               const JobContext::CandidateFileInfo& rhs) {
-              if (lhs.file_name > rhs.file_name) {
-                return true;
-              } else if (lhs.file_name < rhs.file_name) {
-                return false;
-              } else {
-                return (lhs.file_path > rhs.file_path);
-              }
-            });
+            CompareCandidateFile);
   candidate_files.erase(
       std::unique(candidate_files.begin(), candidate_files.end()),
       candidate_files.end());

db/db_impl/db_impl_open.cc

@@ -11,7 +11,7 @@
 #include "db/builder.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
-#include "db/periodic_task_scheduler.h"
+#include "db/periodic_work_scheduler.h"
 #include "env/composite_env_wrapper.h"
 #include "file/filename.h"
 #include "file/read_write_util.h"
@@ -441,14 +441,11 @@ Status DBImpl::Recover(
         uint64_t number = 0;
         FileType type = kWalFile;  // initialize
         if (ParseFileName(file, &number, &type) && type == kDescriptorFile) {
-          uint64_t bytes;
-          s = env_->GetFileSize(DescriptorFileName(dbname_, number), &bytes);
-          if (s.ok() && bytes != 0) {
-            // Found non-empty MANIFEST (descriptor log), thus best-efforts
-            // recovery does not have to treat the db as empty.
-            manifest_path = dbname_ + "/" + file;
-            break;
-          }
+          // Found MANIFEST (descriptor log), thus best-efforts recovery does
+          // not have to treat the db as empty.
+          s = Status::OK();
+          manifest_path = dbname_ + "/" + file;
+          break;
         }
       }
     }
@@ -525,6 +522,12 @@ Status DBImpl::Recover(
   if (!s.ok()) {
     return s;
   }
+  if (immutable_db_options_.verify_sst_unique_id_in_manifest) {
+    s = VerifySstUniqueIdInManifest();
+    if (!s.ok()) {
+      return s;
+    }
+  }
   s = SetupDBId(read_only, recovery_ctx);
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "DB ID: %s\n", db_id_.c_str());
   if (s.ok() && !read_only) {
@@ -702,6 +705,31 @@ Status DBImpl::Recover(
   return s;
 }
 
+Status DBImpl::VerifySstUniqueIdInManifest() {
+  mutex_.AssertHeld();
+  ROCKS_LOG_INFO(
+      immutable_db_options_.info_log,
+      "Verifying SST unique id between MANIFEST and SST file table properties");
+  Status status;
+  for (auto cfd : *versions_->GetColumnFamilySet()) {
+    if (!cfd->IsDropped()) {
+      auto version = cfd->current();
+      version->Ref();
+      mutex_.Unlock();
+      status = version->VerifySstUniqueIds();
+      mutex_.Lock();
+      version->Unref();
+      if (!status.ok()) {
+        ROCKS_LOG_WARN(immutable_db_options_.info_log,
+                       "SST unique id mismatch in column family \"%s\": %s",
+                       cfd->GetName().c_str(), status.ToString().c_str());
+        return status;
+      }
+    }
+  }
+  return status;
+}
+
 Status DBImpl::PersistentStatsProcessFormatVersion() {
   mutex_.AssertHeld();
   Status s;
@@ -1432,6 +1460,9 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
   Status s;
   mutex_.AssertHeld();
   assert(immutable_db_options_.avoid_flush_during_recovery);
+  if (two_write_queues_) {
+    log_write_mutex_.Lock();
+  }
   // Mark these as alive so they'll be considered for deletion later by
   // FindObsoleteFiles()
   total_log_size_ = 0;
@@ -1456,6 +1487,9 @@ Status DBImpl::RestoreAliveLogFiles(const std::vector<uint64_t>& wal_numbers) {
     total_log_size_ += log.size;
     alive_log_files_.push_back(log);
   }
+  if (two_write_queues_) {
+    log_write_mutex_.Unlock();
+  }
   return s;
 }
 
@@ -1515,11 +1549,7 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
       std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
           range_del_iters;
       auto range_del_iter =
-          // This is called during recovery, where a live memtable is flushed
-          // directly. In this case, no fragmented tombstone list is cached in
-          // this memtable yet.
-          mem->NewRangeTombstoneIterator(ro, kMaxSequenceNumber,
-                                         false /* immutable_memtable */);
+          mem->NewRangeTombstoneIterator(ro, kMaxSequenceNumber);
       if (range_del_iter != nullptr) {
         range_del_iters.emplace_back(range_del_iter);
       }
@@ -1574,7 +1604,8 @@ Status DBImpl::WriteLevel0TableForRecovery(int job_id, ColumnFamilyData* cfd,
                   meta.marked_for_compaction, meta.temperature,
                   meta.oldest_blob_file_number, meta.oldest_ancester_time,
                   meta.file_creation_time, meta.file_checksum,
-                  meta.file_checksum_func_name, meta.unique_id);
+                  meta.file_checksum_func_name, meta.min_timestamp,
+                  meta.max_timestamp, meta.unique_id);
 
     for (const auto& blob : blob_file_additions) {
       edit->AddBlobFile(blob);
@@ -1841,8 +1872,16 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
     }
 
     if (s.ok()) {
+      if (impl->two_write_queues_) {
+        impl->log_write_mutex_.Lock();
+      }
       impl->alive_log_files_.push_back(
           DBImpl::LogFileNumberSize(impl->logfile_number_));
+      if (impl->two_write_queues_) {
+        impl->log_write_mutex_.Unlock();
+      }
+    }
+    if (s.ok()) {
       // In WritePrepared there could be gap in sequence numbers. This breaks
       // the trick we use in kPointInTimeRecovery which assumes the first seq in
       // the log right after the corrupted log is one larger than the last seq
@@ -2074,7 +2113,7 @@ Status DBImpl::Open(const DBOptions& db_options, const std::string& dbname,
                    "DB::Open() failed: %s", s.ToString().c_str());
   }
   if (s.ok()) {
-    s = impl->StartPeriodicTaskScheduler();
+    s = impl->StartPeriodicWorkScheduler();
   }
 
   if (s.ok()) {

db/db_impl/db_impl_readonly.cc

@@ -85,18 +85,17 @@ Status DBImplReadOnly::Get(const ReadOptions& read_options,
   SequenceNumber max_covering_tombstone_seq = 0;
   LookupKey lkey(key, snapshot, read_options.timestamp);
   PERF_TIMER_STOP(get_snapshot_time);
-  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(),
-                              /*columns=*/nullptr, ts, &s, &merge_context,
-                              &max_covering_tombstone_seq, read_options,
-                              false /* immutable_memtable */, &read_cb)) {
+  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(), ts, &s,
+                              &merge_context, &max_covering_tombstone_seq,
+                              read_options, &read_cb)) {
     pinnable_val->PinSelf();
     RecordTick(stats_, MEMTABLE_HIT);
   } else {
     PERF_TIMER_GUARD(get_from_output_files_time);
     PinnedIteratorsManager pinned_iters_mgr;
     super_version->current->Get(
-        read_options, lkey, pinnable_val, /*columns=*/nullptr, ts, &s,
-        &merge_context, &max_covering_tombstone_seq, &pinned_iters_mgr,
+        read_options, lkey, pinnable_val, ts, &s, &merge_context,
+        &max_covering_tombstone_seq, &pinned_iters_mgr,
         /*value_found*/ nullptr,
         /*key_exists*/ nullptr, /*seq*/ nullptr, &read_cb,
         /*is_blob*/ nullptr,
@@ -143,7 +142,8 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& read_options,
       super_version->version_number, read_callback);
   auto internal_iter = NewInternalIterator(
       db_iter->GetReadOptions(), cfd, super_version, db_iter->GetArena(),
-      read_seq, /* allow_unprepared_value */ true, db_iter);
+      db_iter->GetRangeDelAggregator(), read_seq,
+      /* allow_unprepared_value */ true);
   db_iter->SetIterUnderDBIter(internal_iter);
   return db_iter;
 }
@@ -193,8 +193,9 @@ Status DBImplReadOnly::NewIterators(
         sv->mutable_cf_options.max_sequential_skip_in_iterations,
         sv->version_number, read_callback);
     auto* internal_iter = NewInternalIterator(
-        db_iter->GetReadOptions(), cfd, sv, db_iter->GetArena(), read_seq,
-        /* allow_unprepared_value */ true, db_iter);
+        db_iter->GetReadOptions(), cfd, sv, db_iter->GetArena(),
+        db_iter->GetRangeDelAggregator(), read_seq,
+        /* allow_unprepared_value */ true);
     db_iter->SetIterUnderDBIter(internal_iter);
     iterators->push_back(db_iter);
   }

db/db_impl/db_impl_readonly.h

@@ -13,7 +13,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-// TODO: Share common structure with CompactedDBImpl and DBImplSecondary
 class DBImplReadOnly : public DBImpl {
  public:
   DBImplReadOnly(const DBOptions& options, const std::string& dbname);
@@ -142,16 +141,6 @@ class DBImplReadOnly : public DBImpl {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 
-  // FIXME: some missing overrides for more "write" functions
-
- protected:
-#ifndef ROCKSDB_LITE
-  Status FlushForGetLiveFiles() override {
-    // No-op for read-only DB
-    return Status::OK();
-  }
-#endif  // !ROCKSDB_LITE
-
  private:
   // A "helper" function for DB::OpenForReadOnly without column families
   // to reduce unnecessary I/O

db/db_impl/db_impl_secondary.cc

@@ -261,7 +261,6 @@ Status DBImplSecondary::RecoverLogFiles(
             MemTable* new_mem =
                 cfd->ConstructNewMemtable(mutable_cf_options, seq_of_batch);
             cfd->mem()->SetNextLogNumber(log_number);
-            cfd->mem()->ConstructFragmentedRangeTombstones();
             cfd->imm()->Add(cfd->mem(), &job_context->memtables_to_free);
             new_mem->Ref();
             cfd->SetMemtable(new_mem);
@@ -390,18 +389,16 @@ Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
   const Comparator* ucmp = column_family->GetComparator();
   assert(ucmp);
   std::string* ts = ucmp->timestamp_size() > 0 ? timestamp : nullptr;
-  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(),
-                              /*columns=*/nullptr, ts, &s, &merge_context,
-                              &max_covering_tombstone_seq, read_options,
-                              false /* immutable_memtable */, &read_cb)) {
+  if (super_version->mem->Get(lkey, pinnable_val->GetSelf(), ts, &s,
+                              &merge_context, &max_covering_tombstone_seq,
+                              read_options, &read_cb)) {
     done = true;
     pinnable_val->PinSelf();
     RecordTick(stats_, MEMTABLE_HIT);
   } else if ((s.ok() || s.IsMergeInProgress()) &&
              super_version->imm->Get(
-                 lkey, pinnable_val->GetSelf(), /*columns=*/nullptr, ts, &s,
-                 &merge_context, &max_covering_tombstone_seq, read_options,
-                 &read_cb)) {
+                 lkey, pinnable_val->GetSelf(), ts, &s, &merge_context,
+                 &max_covering_tombstone_seq, read_options, &read_cb)) {
     done = true;
     pinnable_val->PinSelf();
     RecordTick(stats_, MEMTABLE_HIT);
@@ -414,9 +411,8 @@ Status DBImplSecondary::GetImpl(const ReadOptions& read_options,
     PERF_TIMER_GUARD(get_from_output_files_time);
     PinnedIteratorsManager pinned_iters_mgr;
     super_version->current->Get(
-        read_options, lkey, pinnable_val, /*columns=*/nullptr, ts, &s,
-        &merge_context, &max_covering_tombstone_seq, &pinned_iters_mgr,
-        /*value_found*/ nullptr,
+        read_options, lkey, pinnable_val, ts, &s, &merge_context,
+        &max_covering_tombstone_seq, &pinned_iters_mgr, /*value_found*/ nullptr,
         /*key_exists*/ nullptr, /*seq*/ nullptr, &read_cb, /*is_blob*/ nullptr,
         /*do_merge*/ true);
     RecordTick(stats_, MEMTABLE_MISS);
@@ -493,7 +489,8 @@ ArenaWrappedDBIter* DBImplSecondary::NewIteratorImpl(
       expose_blob_index, read_options.snapshot ? false : allow_refresh);
   auto internal_iter = NewInternalIterator(
       db_iter->GetReadOptions(), cfd, super_version, db_iter->GetArena(),
-      snapshot, /* allow_unprepared_value */ true, db_iter);
+      db_iter->GetRangeDelAggregator(), snapshot,
+      /* allow_unprepared_value */ true);
   db_iter->SetIterUnderDBIter(internal_iter);
   return db_iter;
 }

db/db_impl/db_impl_secondary.h

@@ -71,7 +71,6 @@ class LogReaderContainer {
 // The secondary instance can be opened using `DB::OpenAsSecondary`. After
 // that, it can call `DBImplSecondary::TryCatchUpWithPrimary` to make best
 // effort attempts to catch up with the primary.
-// TODO: Share common structure with CompactedDBImpl and DBImplReadOnly
 class DBImplSecondary : public DBImpl {
  public:
   DBImplSecondary(const DBOptions& options, const std::string& dbname,
@@ -269,13 +268,6 @@ class DBImplSecondary : public DBImpl {
 #endif  // NDEBUG
 
  protected:
-#ifndef ROCKSDB_LITE
-  Status FlushForGetLiveFiles() override {
-    // No-op for read-only DB
-    return Status::OK();
-  }
-#endif  // !ROCKSDB_LITE
-
   // ColumnFamilyCollector is a write batch handler which does nothing
   // except recording unique column family IDs
   class ColumnFamilyCollector : public WriteBatch::Handler {

db/db_impl/db_impl_write.cc

@@ -349,11 +349,14 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   // when it finds suitable, and finish them in the same write batch.
   // This is how a write job could be done by the other writer.
   WriteContext write_context;
-  LogContext log_context(write_options.sync);
   WriteThread::WriteGroup write_group;
   bool in_parallel_group = false;
   uint64_t last_sequence = kMaxSequenceNumber;
 
+  mutex_.Lock();
+
+  bool need_log_sync = write_options.sync;
+  bool need_log_dir_sync = need_log_sync && !log_dir_synced_;
   assert(!two_write_queues_ || !disable_memtable);
   {
     // With concurrent writes we do preprocess only in the write thread that
@@ -363,7 +366,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     // PreprocessWrite does its own perf timing.
     PERF_TIMER_STOP(write_pre_and_post_process_time);
 
-    status = PreprocessWrite(write_options, &log_context, &write_context);
+    status = PreprocessWrite(write_options, &need_log_sync, &write_context);
     if (!two_write_queues_) {
       // Assign it after ::PreprocessWrite since the sequence might advance
       // inside it by WriteRecoverableState
@@ -373,6 +376,13 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     PERF_TIMER_START(write_pre_and_post_process_time);
   }
 
+  log::Writer* log_writer = logs_.back().writer;
+  LogFileNumberSize& log_file_number_size = alive_log_files_.back();
+
+  assert(log_writer->get_log_number() == log_file_number_size.number);
+
+  mutex_.Unlock();
+
   // Add to log and apply to memtable.  We can release the lock
   // during this phase since &w is currently responsible for logging
   // and protects against concurrent loggers and concurrent writes
@@ -467,14 +477,10 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
 
     if (!two_write_queues_) {
       if (status.ok() && !write_options.disableWAL) {
-        assert(log_context.log_file_number_size);
-        LogFileNumberSize& log_file_number_size =
-            *(log_context.log_file_number_size);
         PERF_TIMER_GUARD(write_wal_time);
-        io_s =
-            WriteToWAL(write_group, log_context.writer, log_used,
-                       log_context.need_log_sync, log_context.need_log_dir_sync,
-                       last_sequence + 1, log_file_number_size);
+        io_s = WriteToWAL(write_group, log_writer, log_used, need_log_sync,
+                          need_log_dir_sync, last_sequence + 1,
+                          log_file_number_size);
       }
     } else {
       if (status.ok() && !write_options.disableWAL) {
@@ -576,21 +582,14 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
     assert(pre_release_cb_status.ok());
   }
 
-  if (log_context.need_log_sync) {
-    VersionEdit synced_wals;
-    log_write_mutex_.Lock();
+  if (need_log_sync) {
+    mutex_.Lock();
     if (status.ok()) {
-      MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
-                     &synced_wals);
+      status = MarkLogsSynced(logfile_number_, need_log_dir_sync);
     } else {
       MarkLogsNotSynced(logfile_number_);
     }
-    log_write_mutex_.Unlock();
-    if (status.ok() && synced_wals.IsWalAddition()) {
-      InstrumentedMutexLock l(&mutex_);
-      status = ApplyWALToManifest(&synced_wals);
-    }
-
+    mutex_.Unlock();
     // Requesting sync with two_write_queues_ is expected to be very rare. We
     // hence provide a simple implementation that is not necessarily efficient.
     if (two_write_queues_) {
@@ -653,11 +652,19 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
     if (w.callback && !w.callback->AllowWriteBatching()) {
       write_thread_.WaitForMemTableWriters();
     }
-    LogContext log_context(!write_options.disableWAL && write_options.sync);
+    mutex_.Lock();
+    bool need_log_sync = !write_options.disableWAL && write_options.sync;
+    bool need_log_dir_sync = need_log_sync && !log_dir_synced_;
     // PreprocessWrite does its own perf timing.
     PERF_TIMER_STOP(write_pre_and_post_process_time);
-    w.status = PreprocessWrite(write_options, &log_context, &write_context);
+    w.status = PreprocessWrite(write_options, &need_log_sync, &write_context);
     PERF_TIMER_START(write_pre_and_post_process_time);
+    log::Writer* log_writer = logs_.back().writer;
+    LogFileNumberSize& log_file_number_size = alive_log_files_.back();
+
+    assert(log_writer->get_log_number() == log_file_number_size.number);
+
+    mutex_.Unlock();
 
     // This can set non-OK status if callback fail.
     last_batch_group_size_ =
@@ -720,13 +727,9 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
                           wal_write_group.size - 1);
         RecordTick(stats_, WRITE_DONE_BY_OTHER, wal_write_group.size - 1);
       }
-      assert(log_context.log_file_number_size);
-      LogFileNumberSize& log_file_number_size =
-          *(log_context.log_file_number_size);
       io_s =
-          WriteToWAL(wal_write_group, log_context.writer, log_used,
-                     log_context.need_log_sync, log_context.need_log_dir_sync,
-                     current_sequence, log_file_number_size);
+          WriteToWAL(wal_write_group, log_writer, log_used, need_log_sync,
+                     need_log_dir_sync, current_sequence, log_file_number_size);
       w.status = io_s;
     }
 
@@ -737,20 +740,16 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
       WriteStatusCheck(w.status);
     }
 
-    VersionEdit synced_wals;
-    if (log_context.need_log_sync) {
-      InstrumentedMutexLock l(&log_write_mutex_);
+    if (need_log_sync) {
+      mutex_.Lock();
       if (w.status.ok()) {
-        MarkLogsSynced(logfile_number_, log_context.need_log_dir_sync,
-                       &synced_wals);
+        w.status = MarkLogsSynced(logfile_number_, need_log_dir_sync);
       } else {
         MarkLogsNotSynced(logfile_number_);
       }
+      mutex_.Unlock();
     }
-    if (w.status.ok() && synced_wals.IsWalAddition()) {
-      InstrumentedMutexLock l(&mutex_);
-      w.status = ApplyWALToManifest(&synced_wals);
-    }
+
     write_thread_.ExitAsBatchGroupLeader(wal_write_group, w.status);
   }
 
@@ -894,8 +893,9 @@ Status DBImpl::WriteImplWALOnly(
     // TODO(myabandeh): Make preliminary checks thread-safe so we could do them
     // without paying the cost of obtaining the mutex.
     if (status.ok()) {
-      LogContext log_context;
-      status = PreprocessWrite(write_options, &log_context, &write_context);
+      InstrumentedMutexLock l(&mutex_);
+      bool need_log_sync = false;
+      status = PreprocessWrite(write_options, &need_log_sync, &write_context);
       WriteStatusCheckOnLocked(status);
     }
     if (!status.ok()) {
@@ -1057,8 +1057,9 @@ Status DBImpl::WriteImplWALOnly(
 void DBImpl::WriteStatusCheckOnLocked(const Status& status) {
   // Is setting bg_error_ enough here?  This will at least stop
   // compaction and fail any further writes.
-  InstrumentedMutexLock l(&mutex_);
+  // Caller must hold mutex_.
   assert(!status.IsIOFenced() || !error_handler_.GetBGError().ok());
+  mutex_.AssertHeld();
   if (immutable_db_options_.paranoid_checks && !status.ok() &&
       !status.IsBusy() && !status.IsIncomplete()) {
     // Maybe change the return status to void?
@@ -1089,9 +1090,6 @@ void DBImpl::IOStatusCheck(const IOStatus& io_status) {
     // Maybe change the return status to void?
     error_handler_.SetBGError(io_status, BackgroundErrorReason::kWriteCallback);
     mutex_.Unlock();
-  } else {
-    // Force writable file to be continue writable.
-    logs_.back().writer->file()->reset_seen_error();
   }
 }
 
@@ -1112,13 +1110,13 @@ void DBImpl::MemTableInsertStatusCheck(const Status& status) {
 }
 
 Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
-                               LogContext* log_context,
+                               bool* need_log_sync,
                                WriteContext* write_context) {
-  assert(write_context != nullptr && log_context != nullptr);
+  mutex_.AssertHeld();
+  assert(write_context != nullptr && need_log_sync != nullptr);
   Status status;
 
   if (error_handler_.IsDBStopped()) {
-    InstrumentedMutexLock l(&mutex_);
     status = error_handler_.GetBGError();
   }
 
@@ -1126,11 +1124,11 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
 
   if (UNLIKELY(status.ok() && total_log_size_ > GetMaxTotalWalSize())) {
     assert(versions_);
-    InstrumentedMutexLock l(&mutex_);
     const ColumnFamilySet* const column_families =
         versions_->GetColumnFamilySet();
     assert(column_families);
     size_t num_cfs = column_families->NumberOfColumnFamilies();
+
     assert(num_cfs >= 1);
     if (num_cfs > 1) {
       WaitForPendingWrites();
@@ -1144,18 +1142,15 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
     // thread is writing to another DB with the same write buffer, they may also
     // be flushed. We may end up with flushing much more DBs than needed. It's
     // suboptimal but still correct.
-    InstrumentedMutexLock l(&mutex_);
     WaitForPendingWrites();
     status = HandleWriteBufferManagerFlush(write_context);
   }
 
   if (UNLIKELY(status.ok() && !trim_history_scheduler_.Empty())) {
-    InstrumentedMutexLock l(&mutex_);
     status = TrimMemtableHistory(write_context);
   }
 
   if (UNLIKELY(status.ok() && !flush_scheduler_.Empty())) {
-    InstrumentedMutexLock l(&mutex_);
     WaitForPendingWrites();
     status = ScheduleFlushes(write_context);
   }
@@ -1171,7 +1166,6 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
     // for previous one. It might create a fairness issue that expiration
     // might happen for smaller writes but larger writes can go through.
     // Can optimize it if it is an issue.
-    InstrumentedMutexLock l(&mutex_);
     status = DelayWrite(last_batch_group_size_, write_options);
     PERF_TIMER_START(write_pre_and_post_process_time);
   }
@@ -1186,12 +1180,11 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
     if (write_options.no_slowdown) {
       status = Status::Incomplete("Write stall");
     } else {
-      InstrumentedMutexLock l(&mutex_);
       WriteBufferManagerStallWrites();
     }
   }
-  InstrumentedMutexLock l(&log_write_mutex_);
-  if (status.ok() && log_context->need_log_sync) {
+
+  if (status.ok() && *need_log_sync) {
     // Wait until the parallel syncs are finished. Any sync process has to sync
     // the front log too so it is enough to check the status of front()
     // We do a while loop since log_sync_cv_ is signalled when any sync is
@@ -1211,12 +1204,8 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
       log.PrepareForSync();
     }
   } else {
-    log_context->need_log_sync = false;
+    *need_log_sync = false;
   }
-  log_context->writer = logs_.back().writer;
-  log_context->need_log_dir_sync =
-      log_context->need_log_dir_sync && !log_dir_synced_;
-  log_context->log_file_number_size = std::addressof(alive_log_files_.back());
 
   return status;
 }
@@ -1648,6 +1637,12 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
   // thread is writing to another DB with the same write buffer, they may also
   // be flushed. We may end up with flushing much more DBs than needed. It's
   // suboptimal but still correct.
+  ROCKS_LOG_INFO(
+      immutable_db_options_.info_log,
+      "Flushing column family with oldest memtable entry. Write buffers are "
+      "using %" ROCKSDB_PRIszt " bytes out of a total of %" ROCKSDB_PRIszt ".",
+      write_buffer_manager_->memory_usage(),
+      write_buffer_manager_->buffer_size());
   // no need to refcount because drop is happening in write thread, so can't
   // happen while we're in the write thread
   autovector<ColumnFamilyData*> cfds;
@@ -1661,11 +1656,9 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
       if (cfd->IsDropped()) {
         continue;
       }
-      if (!cfd->mem()->IsEmpty() && !cfd->imm()->IsFlushPendingOrRunning()) {
-        // We only consider flush on CFs with bytes in the mutable memtable,
-        // and no immutable memtables for which flush has yet to finish. If
-        // we triggered flush on CFs already trying to flush, we would risk
-        // creating too many immutable memtables leading to write stalls.
+      if (!cfd->mem()->IsEmpty()) {
+        // We only consider active mem table, hoping immutable memtable is
+        // already in the process of flushing.
         uint64_t seq = cfd->mem()->GetCreationSeq();
         if (cfd_picked == nullptr || seq < seq_num_for_cf_picked) {
           cfd_picked = cfd;
@@ -1678,15 +1671,6 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
     }
     MaybeFlushStatsCF(&cfds);
   }
-  if (!cfds.empty()) {
-    ROCKS_LOG_INFO(
-        immutable_db_options_.info_log,
-        "Flushing triggered to alleviate write buffer memory usage. Write "
-        "buffer is using %" ROCKSDB_PRIszt
-        " bytes out of a total of %" ROCKSDB_PRIszt ".",
-        write_buffer_manager_->memory_usage(),
-        write_buffer_manager_->buffer_size());
-  }
 
   WriteThread::Writer nonmem_w;
   if (two_write_queues_) {
@@ -1730,12 +1714,10 @@ Status DBImpl::HandleWriteBufferManagerFlush(WriteContext* write_context) {
 }
 
 uint64_t DBImpl::GetMaxTotalWalSize() const {
-  uint64_t max_total_wal_size =
-      max_total_wal_size_.load(std::memory_order_acquire);
-  if (max_total_wal_size > 0) {
-    return max_total_wal_size;
-  }
-  return 4 * max_total_in_memory_state_.load(std::memory_order_acquire);
+  mutex_.AssertHeld();
+  return mutable_db_options_.max_total_wal_size == 0
+             ? 4 * max_total_in_memory_state_
+             : mutable_db_options_.max_total_wal_size;
 }
 
 // REQUIRES: mutex_ is held
@@ -2073,10 +2055,6 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
                  "[%s] New memtable created with log file: #%" PRIu64
                  ". Immutable memtables: %d.\n",
                  cfd->GetName().c_str(), new_log_number, num_imm_unflushed);
-  // There should be no concurrent write as the thread is at the front of
-  // writer queue
-  cfd->mem()->ConstructFragmentedRangeTombstones();
-
   mutex_.Lock();
   if (recycle_log_number != 0) {
     // Since renaming the file is done outside DB mutex, we need to ensure
@@ -2087,15 +2065,11 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
     log_recycle_files_.pop_front();
   }
   if (s.ok() && creating_new_log) {
-    InstrumentedMutexLock l(&log_write_mutex_);
+    log_write_mutex_.Lock();
     assert(new_log != nullptr);
     if (!logs_.empty()) {
       // Alway flush the buffer of the last log before switching to a new one
       log::Writer* cur_log_writer = logs_.back().writer;
-      if (error_handler_.IsRecoveryInProgress()) {
-        // In recovery path, we force another try of writing WAL buffer.
-        cur_log_writer->file()->reset_seen_error();
-      }
       io_s = cur_log_writer->WriteBuffer();
       if (s.ok()) {
         s = io_s;
@@ -2115,6 +2089,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
       logs_.emplace_back(logfile_number_, new_log);
       alive_log_files_.push_back(LogFileNumberSize(logfile_number_));
     }
+    log_write_mutex_.Unlock();
   }
 
   if (!s.ok()) {
@@ -2163,8 +2138,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
 
       VersionEdit wal_deletion;
       wal_deletion.DeleteWalsBefore(min_wal_number_to_keep);
-      s = versions_->LogAndApplyToDefaultColumnFamily(&wal_deletion, &mutex_,
-                                                      directories_.GetDbDir());
+      s = versions_->LogAndApplyToDefaultColumnFamily(&wal_deletion, &mutex_);
       if (!s.ok() && versions_->io_status().IsIOError()) {
         s = error_handler_.SetBGError(versions_->io_status(),
                                       BackgroundErrorReason::kManifestWrite);