Update HISTORY.md for #11136

Clean up InvokeFilterIfNeeded a bit (#11174 )
Summary: The patch makes some code quality enhancements in `CompactionIterator::InvokeFilterIfNeeded` including the renaming of `filter` (which is most likely a remnant of the days before the `FilterV2` API when the compaction filter used to return a boolean) to `decision`, the removal of some outdated comments, the elimination of an `error` flag which was only used in one failure case out of many, as well as some small stylistic improvements. (Some the above will also come in handy when adding compaction filter support for wide-column entities.) Pull Request resolved: https://github.com/facebook/rocksdb/pull/11174 Test Plan: `make check` Reviewed By: akankshamahajan15 Differential Revision: D42901408 Pulled By: ltamasi fbshipit-source-id: ab382d59a4990c5dfe1cee219d49e1d80902b666
2026-11-06 11:02:36 -05:00 · 2023-02-01 17:12:45 -08:00 · 2023-02-01 10:03:07 -08:00 · 2023-01-31 16:57:49 -08:00 · 2023-01-31 10:17:48 -08:00 · 2023-01-31 09:59:25 -08:00
907 changed files with 25152 additions and 23510 deletions
@@ -1,7 +1,7 @@
 version: 2.1

 orbs:
-  win: circleci/windows@2.4.0
+  win: circleci/windows@5.0.0

 commands:
  install-cmake-on-macos:
@@ -45,6 +45,38 @@ commands:
            echo "export LZ4_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/lz4" >> $BASH_ENV
            echo "export ZSTD_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zstd" >> $BASH_ENV

+  windows-build-steps:
+    steps:
+      - checkout
+      - run:
+          name: "Install thirdparty dependencies"
+          command: |
+            echo "Installing CMake..."
+            choco install cmake --installargs 'ADD_CMAKE_TO_PATH=System' -y
+            mkdir $Env:THIRDPARTY_HOME
+            cd $Env:THIRDPARTY_HOME
+            echo "Building Snappy dependency..."
+            curl https://github.com/google/snappy/archive/refs/tags/1.1.8.zip -O snappy-1.1.8.zip
+            unzip -q snappy-1.1.8.zip
+            cd snappy-1.1.8
+            mkdir build
+            cd build
+            & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" ..
+            msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
+      - run:
+          name: "Build RocksDB"
+          command: |
+            mkdir build
+            cd build
+            & $Env:CMAKE_BIN -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE=1 -DSNAPPY=1 -DJNI=1 ..
+            cd ..
+            echo "Building with VS version: $Env:CMAKE_GENERATOR"
+            msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
+      - run:
+          name: "Test RocksDB"
+          shell: powershell.exe
+          command: |
+            build_tools\run_ci_db_test.ps1 -SuiteRun arena_test,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
  pre-steps-macos:
      steps:
        - pre-steps
@@ -154,11 +186,6 @@ commands:
            true

 executors:
-  windows-2xlarge:
-    machine:
-      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
@@ -275,27 +302,6 @@ jobs:
      - 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

-  build-linux-lite:
-    executor: linux-docker
-    resource_class: large
-    steps:
-      - pre-steps
-      - run: LITE=1 make V=1 J=8 -j8 check
-      - post-steps
-
-  build-linux-lite-release:
-    executor: linux-docker
-    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
-      - post-steps
-
  build-linux-clang-no_test_run:
    executor: linux-docker
    resource_class: xlarge
@@ -518,73 +524,35 @@ jobs:
          no_output_timeout: 100m
      - post-steps

-  build-windows:
-    executor: windows-2xlarge
-    parameters:
-      extra_cmake_opt:
-        default: ""
-        type: string
-      vs_year:
-        default: "2019"
-        type: string
-      cmake_generator:
-        default: "Visual Studio 16 2019"
-        type: string
+  build-windows-vs2022:
+    executor:
+      name: win/server-2022
+      size: 2xlarge
    environment:
      THIRDPARTY_HOME: C:/Users/circleci/thirdparty
-      CMAKE_HOME: C:/Users/circleci/thirdparty/cmake-3.16.4-win64-x64
-      CMAKE_BIN: C:/Users/circleci/thirdparty/cmake-3.16.4-win64-x64/bin/cmake.exe
-      SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.7
-      SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.7;C:/Users/circleci/thirdparty/snappy-1.1.7/build
-      SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.7/build/Debug/snappy.lib
-      VS_YEAR: <<parameters.vs_year>>
-      CMAKE_GENERATOR: <<parameters.cmake_generator>>
+      CMAKE_HOME: C:/Program Files/CMake
+      CMAKE_BIN: C:/Program Files/CMake/bin/cmake.exe
+      SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8
+      SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build
+      SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib
+      CMAKE_GENERATOR: Visual Studio 17 2022
    steps:
-      - checkout
-      - run:
-          name: "Setup VS"
-          command: |
-            if [[ "${VS_YEAR}" == "2019" ]]; then
-              echo "VS2019 already present."
-            elif [[ "${VS_YEAR}" == "2017" ]]; then
-              echo "Installing VS2017..."
-              powershell .circleci/vs2017_install.ps1
-            elif [[ "${VS_YEAR}" == "2015" ]]; then
-              echo "Installing VS2015..."
-              powershell .circleci/vs2015_install.ps1
-            fi
-      - store_artifacts:
-          path: \Users\circleci\AppData\Local\Temp\vslogs.zip
-      - run:
-          name: "Install thirdparty dependencies"
-          command: |
-            mkdir ${THIRDPARTY_HOME}
-            cd ${THIRDPARTY_HOME}
-            echo "Installing CMake..."
-            curl --fail --silent --show-error --output cmake-3.16.4-win64-x64.zip --location https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-win64-x64.zip
-            unzip -q cmake-3.16.4-win64-x64.zip
-            echo "Building Snappy dependency..."
-            curl --fail --silent --show-error --output snappy-1.1.7.zip --location https://github.com/google/snappy/archive/1.1.7.zip
-            unzip -q snappy-1.1.7.zip
-            cd snappy-1.1.7
-            mkdir build
-            cd build
-            ${CMAKE_BIN} -G "${CMAKE_GENERATOR}" ..
-            msbuild.exe Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
-      - run:
-          name: "Build RocksDB"
-          command: |
-            mkdir build
-            cd build
-            ${CMAKE_BIN} -G "${CMAKE_GENERATOR}" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE=1 -DSNAPPY=1 -DJNI=1 << parameters.extra_cmake_opt >> ..
-            cd ..
-            echo "Building with VS version: ${CMAKE_GENERATOR}"
-            msbuild.exe build/rocksdb.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
-      - run:
-          name: "Test RocksDB"
-          shell: powershell.exe
-          command: |
-            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
+      - windows-build-steps
+
+  build-windows-vs2019:
+    executor:
+      name: win/server-2019
+      size: 2xlarge
+    environment:
+      THIRDPARTY_HOME: C:/Users/circleci/thirdparty
+      CMAKE_HOME: C:/Program Files/CMake
+      CMAKE_BIN: C:/Program Files/CMake/bin/cmake.exe
+      SNAPPY_HOME: C:/Users/circleci/thirdparty/snappy-1.1.8
+      SNAPPY_INCLUDE: C:/Users/circleci/thirdparty/snappy-1.1.8;C:/Users/circleci/thirdparty/snappy-1.1.8/build
+      SNAPPY_LIB_DEBUG: C:/Users/circleci/thirdparty/snappy-1.1.8/build/Debug/snappy.lib
+      CMAKE_GENERATOR: Visual Studio 16 2019
+    steps:
+      - windows-build-steps

  build-linux-java:
    executor: linux-docker
@@ -832,7 +800,6 @@ workflows:
      - build-linux-cmake-with-folly-coroutines
      - build-linux-cmake-with-benchmark
      - build-linux-encrypted_env-no_compression
-      - build-linux-lite
  jobs-linux-run-tests-san:
    jobs:
      - build-linux-clang10-asan
@@ -843,7 +810,6 @@ workflows:
    jobs:
      - build-linux-release
      - build-linux-release-rtti
-      - build-linux-lite-release
      - build-examples
      - build-fuzzers
      - build-linux-clang-no_test_run
@@ -859,15 +825,8 @@ workflows:
      - build-linux-mini-crashtest
  jobs-windows:
    jobs:
-      - build-windows:
-          name: "build-windows-vs2019"
-      - build-windows:
-          name: "build-windows-vs2019-cxx20"
-          extra_cmake_opt: -DCMAKE_CXX_STANDARD=20
-      - build-windows:
-          name: "build-windows-vs2017"
-          vs_year: "2017"
-          cmake_generator: "Visual Studio 15 Win64"
+      - build-windows-vs2022
+      - build-windows-vs2019
      - build-cmake-mingw
  jobs-java:
    jobs:
@@ -1,24 +0,0 @@
-$VS_DOWNLOAD_LINK = "https://go.microsoft.com/fwlink/?LinkId=691126"
-$COLLECT_DOWNLOAD_LINK = "https://aka.ms/vscollect.exe"
-curl.exe --retry 3 -kL $VS_DOWNLOAD_LINK --output vs_installer.exe
-if ($LASTEXITCODE -ne 0) {
-    echo "Download of the VS 2015 installer failed"
-    exit 1
-}
-$VS_INSTALL_ARGS = @("/Quiet", "/NoRestart")
-$process = Start-Process "${PWD}\vs_installer.exe" -ArgumentList $VS_INSTALL_ARGS -NoNewWindow -Wait -PassThru
-Remove-Item -Path vs_installer.exe -Force
-$exitCode = $process.ExitCode
-if (($exitCode -ne 0) -and ($exitCode -ne 3010)) {
-    echo "VS 2015 installer exited with code $exitCode, which should be one of [0, 3010]."
-    curl.exe --retry 3 -kL $COLLECT_DOWNLOAD_LINK --output Collect.exe
-    if ($LASTEXITCODE -ne 0) {
-        echo "Download of the VS Collect tool failed."
-        exit 1
-    }
-    Start-Process "${PWD}\Collect.exe" -NoNewWindow -Wait -PassThru
-    New-Item -Path "C:\w\build-results" -ItemType "directory" -Force
-    Copy-Item -Path "C:\Users\circleci\AppData\Local\Temp\vslogs.zip" -Destination "C:\w\build-results\"
-    exit 1
-}
-echo "VS 2015 installed."
@@ -1,35 +0,0 @@
-$VS_DOWNLOAD_LINK = "https://aka.ms/vs/15/release/vs_buildtools.exe"
-$COLLECT_DOWNLOAD_LINK = "https://aka.ms/vscollect.exe"
-$VS_INSTALL_ARGS = @("--nocache","--quiet","--wait", "--add Microsoft.VisualStudio.Workload.VCTools",
-                                                     "--add Microsoft.VisualStudio.Component.VC.Tools.14.13",
-                                                     "--add Microsoft.Component.MSBuild",
-                                                     "--add Microsoft.VisualStudio.Component.Roslyn.Compiler",
-                                                     "--add Microsoft.VisualStudio.Component.TextTemplating",
-                                                     "--add Microsoft.VisualStudio.Component.VC.CoreIde",
-                                                     "--add Microsoft.VisualStudio.Component.VC.Redist.14.Latest",
-                                                     "--add Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Core",
-                                                     "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
-                                                     "--add Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Win81")
-
-curl.exe --retry 3 -kL $VS_DOWNLOAD_LINK --output vs_installer.exe
-if ($LASTEXITCODE -ne 0) {
-    echo "Download of the VS 2017 installer failed"
-    exit 1
-}
-
-$process = Start-Process "${PWD}\vs_installer.exe" -ArgumentList $VS_INSTALL_ARGS -NoNewWindow -Wait -PassThru
-Remove-Item -Path vs_installer.exe -Force
-$exitCode = $process.ExitCode
-if (($exitCode -ne 0) -and ($exitCode -ne 3010)) {
-    echo "VS 2017 installer exited with code $exitCode, which should be one of [0, 3010]."
-    curl.exe --retry 3 -kL $COLLECT_DOWNLOAD_LINK --output Collect.exe
-    if ($LASTEXITCODE -ne 0) {
-        echo "Download of the VS Collect tool failed."
-        exit 1
-    }
-    Start-Process "${PWD}\Collect.exe" -NoNewWindow -Wait -PassThru
-    New-Item -Path "C:\w\build-results" -ItemType "directory" -Force
-    Copy-Item -Path "C:\Users\circleci\AppData\Local\Temp\vslogs.zip" -Destination "C:\w\build-results\"
-    exit 1
-}
-echo "VS 2017 installed."
@@ -245,11 +245,21 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "s390x")
  endif(HAS_S390X_MARCH_NATIVE)
 endif(CMAKE_SYSTEM_PROCESSOR MATCHES "s390x")

+if(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
+  CHECK_C_COMPILER_FLAG("-march=loongarch64" HAS_LOONGARCH64)
+  if(HAS_LOONGARCH64)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mcpu=loongarch64 -mtune=loongarch64")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=loongarch64 -mtune=loongarch64")
+  endif(HAS_LOONGARCH64)
+endif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
+
 option(PORTABLE "build a portable binary" OFF)
 option(FORCE_SSE42 "force building with SSE4.2, even when PORTABLE=ON" OFF)
 option(FORCE_AVX "force building with AVX, even when PORTABLE=ON" OFF)
 option(FORCE_AVX2 "force building with AVX2, even when PORTABLE=ON" OFF)
 if(PORTABLE)
+  add_definitions(-DROCKSDB_PORTABLE)
+
  # MSVC does not need a separate compiler flag to enable SSE4.2; if nmmintrin.h
  # is available, it is available by default.
  if(FORCE_SSE42 AND NOT MSVC)
@@ -273,6 +283,9 @@ if(PORTABLE)
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^s390x")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=z196")
    endif()
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^loongarch64")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=loongarch64")
+    endif()
  endif()
 else()
  if(MSVC)
@@ -292,8 +305,7 @@ if(NOT MSVC)
  set(CMAKE_REQUIRED_FLAGS "-msse4.2 -mpclmul")
 endif()

-if (NOT PORTABLE OR FORCE_SSE42)
-  CHECK_CXX_SOURCE_COMPILES("
+CHECK_CXX_SOURCE_COMPILES("
 #include <cstdint>
 #include <nmmintrin.h>
 #include <wmmintrin.h>
@@ -305,12 +317,11 @@ int main() {
  auto d = _mm_cvtsi128_si64(c);
 }
 " HAVE_SSE42)
-  if(HAVE_SSE42)
-    add_definitions(-DHAVE_SSE42)
-    add_definitions(-DHAVE_PCLMUL)
-  elseif(FORCE_SSE42)
-    message(FATAL_ERROR "FORCE_SSE42=ON but unable to compile with SSE4.2 enabled")
-  endif()
+if(HAVE_SSE42)
+  add_definitions(-DHAVE_SSE42)
+  add_definitions(-DHAVE_PCLMUL)
+elseif(FORCE_SSE42)
+  message(FATAL_ERROR "FORCE_SSE42=ON but unable to compile with SSE4.2 enabled")
 endif()

 # Check if -latomic is required or not
@@ -485,12 +496,6 @@ if(CMAKE_COMPILER_IS_GNUCXX)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-memcmp")
 endif()

-option(ROCKSDB_LITE "Build RocksDBLite version" OFF)
-if(ROCKSDB_LITE)
-  add_definitions(-DROCKSDB_LITE)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -Os")
-endif()
-
 if(CMAKE_SYSTEM_NAME MATCHES "Cygwin")
  add_definitions(-fno-builtin-memcmp -DCYGWIN)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
@@ -649,12 +654,13 @@ set(SOURCES
        cache/cache.cc
        cache/cache_entry_roles.cc
        cache/cache_key.cc
+        cache/cache_helpers.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/secondary_cache.cc
        cache/sharded_cache.cc
        db/arena_wrapped_db_iter.cc
        db/blob/blob_contents.cc
@@ -796,6 +802,7 @@ set(SOURCES
        options/options.cc
        options/options_helper.cc
        options/options_parser.cc
+        port/mmap.cc
        port/stack_trace.cc
        table/adaptive/adaptive_table_factory.cc
        table/block_based/binary_search_index_reader.cc
@@ -805,6 +812,7 @@ set(SOURCES
        table/block_based/block_based_table_iterator.cc
        table/block_based/block_based_table_reader.cc
        table/block_based/block_builder.cc
+        table/block_based/block_cache.cc
        table/block_based/block_prefetcher.cc
        table/block_based/block_prefix_index.cc
        table/block_based/data_block_hash_index.cc
@@ -978,6 +986,12 @@ if ( ROCKSDB_PLUGINS )
        plugin/${plugin}/${src}
        PROPERTIES COMPILE_FLAGS "${${plugin}_COMPILE_FLAGS}")
    endforeach()
+    foreach (test ${${plugin}_TESTS})
+      list(APPEND PLUGIN_TESTS plugin/${plugin}/${test})
+      set_source_files_properties(
+        plugin/${plugin}/${test}
+        PROPERTIES COMPILE_FLAGS "${${plugin}_COMPILE_FLAGS}")
+    endforeach()
    foreach (path ${${plugin}_INCLUDE_PATHS})
      include_directories(${path})
    endforeach()
@@ -1469,6 +1483,7 @@ if(WITH_TESTS)
        utilities/ttl/ttl_test.cc
        utilities/util_merge_operators_test.cc
        utilities/write_batch_with_index/write_batch_with_index_test.cc
+	${PLUGIN_TESTS}
    )
  endif()

@@ -1572,9 +1587,9 @@ endif()

 option(WITH_TRACE_TOOLS "build with trace tools" ON)
 if(WITH_TRACE_TOOLS)
-  add_executable(block_cache_trace_analyzer_tool${ARTIFACT_SUFFIX}
+  add_executable(block_cache_trace_analyzer${ARTIFACT_SUFFIX}
    tools/block_cache_analyzer/block_cache_trace_analyzer_tool.cc)
-  target_link_libraries(block_cache_trace_analyzer_tool${ARTIFACT_SUFFIX}
+  target_link_libraries(block_cache_trace_analyzer${ARTIFACT_SUFFIX}
    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})

  add_executable(trace_analyzer${ARTIFACT_SUFFIX}
@@ -1,20 +1,79 @@
 # Rocksdb Change Log
-## 7.8.3 (11/29/2022)
-* Revert an internal change in 7.8.0 associated with some memory usage churn.
+## Unreleased

-## 7.8.2 (11/27/2022)
+### Behavior changes
+* `ReadOptions::verify_checksums=false` disables checksum verification for more reads of non-`CacheEntryRole::kDataBlock` blocks.
+
+### Bug Fixes
+* Fixed a data race on `ColumnFamilyData::flush_reason` caused by concurrent flushes.
+* Fixed an issue in `Get` and `MultiGet` when user-defined timestamps is enabled in combination with BlobDB.
+* Fixed some atypical behaviors for `LockWAL()` such as allowing concurrent/recursive use and not expecting `UnlockWAL()` after non-OK result. See API comments.
+* Fixed a feature interaction bug where for blobs `GetEntity` would expose the blob reference instead of the blob value.
+* Fixed `DisableManualCompaction()` and `CompactRangeOptions::canceled` to cancel compactions even when they are waiting on conflicting compactions to finish
+* Fixed a bug in which a successful `GetMergeOperands()` could transiently return `Status::MergeInProgress()`
+
+### Feature Removal
+* Remove RocksDB Lite.
+* The feature block_cache_compressed is removed. Statistics related to it are removed too.
+* Remove deprecated Env::LoadEnv(). Use Env::CreateFromString() instead.
+* Remove deprecated FileSystem::Load(). Use FileSystem::CreateFromString() instead.
+* Removed the deprecated version of these utility functions and the corresponding Java bindings: `LoadOptionsFromFile`, `LoadLatestOptions`, `CheckOptionsCompatibility`.
+
+### Public API Changes
+* Completely removed the following deprecated/obsolete statistics: the tickers `BLOCK_CACHE_INDEX_BYTES_EVICT`, `BLOCK_CACHE_FILTER_BYTES_EVICT`, `BLOOM_FILTER_MICROS`, `NO_FILE_CLOSES`, `STALL_L0_SLOWDOWN_MICROS`, `STALL_MEMTABLE_COMPACTION_MICROS`, `STALL_L0_NUM_FILES_MICROS`, `RATE_LIMIT_DELAY_MILLIS`, `NO_ITERATORS`, `NUMBER_FILTERED_DELETES`, `WRITE_TIMEDOUT`, `BLOB_DB_GC_NUM_KEYS_OVERWRITTEN`, `BLOB_DB_GC_NUM_KEYS_EXPIRED`, `BLOB_DB_GC_BYTES_OVERWRITTEN`, `BLOB_DB_GC_BYTES_EXPIRED`, `BLOCK_CACHE_COMPRESSION_DICT_BYTES_EVICT` as well as the histograms `STALL_L0_SLOWDOWN_COUNT`, `STALL_MEMTABLE_COMPACTION_COUNT`, `STALL_L0_NUM_FILES_COUNT`, `HARD_RATE_LIMIT_DELAY_COUNT`, `SOFT_RATE_LIMIT_DELAY_COUNT`, `BLOB_DB_GC_MICROS`, and `NUM_DATA_BLOCKS_READ_PER_LEVEL`. Note that as a result, the C++ enum values of the still supported statistics have changed. Developers are advised to not rely on the actual numeric values.
+
+## 7.10.0 (01/23/2023)
 ### Behavior changes
 * Make best-efforts recovery verify SST unique ID before Version construction (#10962)
-* 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.
+* Introduce `epoch_number` and sort L0 files by `epoch_number` instead of `largest_seqno`. `epoch_number` represents the order of a file being flushed or ingested/imported. Compaction output file will be assigned with the minimum `epoch_number` among input files'. For L0, larger `epoch_number` indicates newer L0 file.

 ### Bug Fixes
-* Fixed a regression in scan for async_io. During seek, valid buffers were getting cleared causing a regression.
-* Fixed a performance regression in iterator where range tombstones after `iterate_upper_bound` is processed.
+* Fixed a regression in iterator where range tombstones after `iterate_upper_bound` is processed.
+* Fixed a memory leak in MultiGet with async_io read option, caused by IO errors during table file open
+* Fixed a bug that multi-level FIFO compaction deletes one file in non-L0 even when `CompactionOptionsFIFO::max_table_files_size` is no exceeded since #10348 or 7.8.0.
+* Fixed a bug caused by `DB::SyncWAL()` affecting `track_and_verify_wals_in_manifest`. Without the fix, application may see "open error: Corruption: Missing WAL with log number" while trying to open the db. The corruption is a false alarm but prevents DB open (#10892).
+* Fixed a BackupEngine bug in which RestoreDBFromLatestBackup would fail if the latest backup was deleted and there is another valid backup available.
+* Fix L0 file misorder corruption caused by ingesting files of overlapping seqnos with memtable entries' through introducing `epoch_number`. Before the fix, `force_consistency_checks=true` may catch the corruption before it's exposed to readers, in which case writes returning `Status::Corruption` would be expected. Also replace the previous incomplete fix (#5958) to the same corruption with this new and more complete fix.
+* Fixed a bug in LockWAL() leading to re-locking mutex (#11020).
+* Fixed a heap use after free bug in async scan prefetching when the scan thread and another thread try to read and load the same seek block into cache.
+* Fixed a heap use after free in async scan prefetching if dictionary compression is enabled, in which case sync read of the compression dictionary gets mixed with async prefetching
+* Fixed a data race bug of `CompactRange()` under `change_level=true` acts on overlapping range with an ongoing file ingestion for level compaction. This will either result in overlapping file ranges corruption at a certain level caught by `force_consistency_checks=true` or protentially two same keys both with seqno 0 in two different levels (i.e, new data ends up in lower/older level). The latter will be caught by assertion in debug build but go silently and result in read returning wrong result in release build. This fix is general so it also replaced previous fixes to a similar problem for `CompactFiles()` (#4665), general `CompactRange()` and auto compaction (commit 5c64fb6 and 87dfc1d).
+* Fixed a bug in compaction output cutting where small output files were produced due to TTL file cutting states were not being updated (#11075).
+
+### New Features
+* When an SstPartitionerFactory is configured, CompactRange() now automatically selects for compaction any files overlapping a partition boundary that is in the compaction range, even if no actual entries are in the requested compaction range. With this feature, manual compaction can be used to (re-)establish SST partition points when SstPartitioner changes, without a full compaction.
+* Add BackupEngine feature to exclude files from backup that are known to be backed up elsewhere, using `CreateBackupOptions::exclude_files_callback`. To restore the DB, the excluded files must be provided in alternative backup directories using `RestoreOptions::alternate_dirs`.
+
+### Public API Changes
+* Substantial changes have been made to the Cache class to support internal development goals. Direct use of Cache class members is discouraged and further breaking modifications are expected in the future. SecondaryCache has some related changes and implementations will need to be updated. (Unlike Cache, SecondaryCache is still intended to support user implementations, and disruptive changes will be avoided.) (#10975)
+* Add `MergeOperationOutput::op_failure_scope` for merge operator users to control the blast radius of merge operator failures. Existing merge operator users do not need to make any change to preserve the old behavior
+
+### Performance Improvements
+* Updated xxHash source code, which should improve kXXH3 checksum speed, at least on ARM (#11098).
+* Improved CPU efficiency of DB reads, from block cache access improvements (#10975).
+
+## 7.9.0 (11/21/2022)
+### Performance Improvements
+* Fixed an iterator performance regression for delete range users when scanning through a consecutive sequence of range tombstones (#10877).

-## 7.8.1 (11/2/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.
+* 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`).
+* Fixed an issue where the `READ_NUM_MERGE_OPERANDS` ticker was not updated when the base key-value or tombstone was read from an SST file.
+* Fixed a memory safety bug when using a SecondaryCache with `block_cache_compressed`. `block_cache_compressed` no longer attempts to use SecondaryCache features.
+* Fixed a regression in scan for async_io. During seek, valid buffers were getting cleared causing a regression.
+* Tiered Storage: fixed excessive keys written to penultimate level in non-debug builds.
+
+### New Features
+* Add basic support for user-defined timestamp to Merge (#10819).
+* Add stats for ReadAsync time spent and async read errors.
+* Basic support for the wide-column data model is now available. Wide-column entities can be stored using the `PutEntity` API, and retrieved using `GetEntity` and the new `columns` API of iterator. For compatibility, the classic APIs `Get` and `MultiGet`, as well as iterator's `value` API return the value of the anonymous default column of wide-column entities; also, `GetEntity` and iterator's `columns` return any plain key-values in the form of an entity which only has the anonymous default column. `Merge` (and `GetMergeOperands`) currently also apply to the default column; any other columns of entities are unaffected by `Merge` operations. Note that some features like compaction filters, transactions, user-defined timestamps, and the SST file writer do not yet support wide-column entities; also, there is currently no `MultiGet`-like API to retrieve multiple entities at once. We plan to gradually close the above gaps and also implement new features like column-level operations (e.g. updating or querying only certain columns of an entity).
+* Marked HyperClockCache as a production-ready alternative to LRUCache for the block cache. HyperClockCache greatly improves hot-path CPU efficiency under high parallel load or high contention, with some documented caveats and limitations. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load.
+* Add periodic diagnostics to info_log (LOG file) for HyperClockCache block cache if performance is degraded by bad `estimated_entry_charge` option.
+
+### Public API Changes
+* Marked `block_cache_compressed` as a deprecated feature. Use SecondaryCache instead.
+* Added a `SecondaryCache::InsertSaved()` API, with default implementation depending on `Insert()`. Some implementations might need to add a custom implementation of `InsertSaved()`. (Details in API comments.)

 ## 7.8.0 (10/22/2022)
 ### New Features
@@ -45,10 +104,11 @@
 * Try to align the compaction output file boundaries to the next level ones, which can reduce more than 10% compaction load for the default level compaction. The feature is enabled by default, to disable, set `AdvancedColumnFamilyOptions.level_compaction_dynamic_file_size` to false. As a side effect, it can create SSTs larger than the target_file_size (capped at 2x target_file_size) or smaller files.
 * Improve RoundRobin TTL compaction, which is going to be the same as normal RoundRobin compaction to move the compaction cursor.
 * Fix a small CPU regression caused by a change that UserComparatorWrapper was made Customizable, because Customizable itself has small CPU overhead for initialization.
-* Fixed an iterator performance regression for delete range users when scanning through a consecutive sequence of range tombstones (#10877).

 ### 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).
+* With periodic stat dumper waits up every options.stats_dump_period_sec seconds, it won't dump stats for a CF if it has no change in the period, unless 7 periods have been skipped.
+* Only periodic stats dumper triggered by options.stats_dump_period_sec will update stats interval. Ones triggered by DB::GetProperty() will not update stats interval and will report based on an interval since the last time stats dump period.

 ### Public API changes
 * Make kXXH3 checksum the new default, because it is faster on common hardware, especially with kCRC32c affected by a performance bug in some versions of clang (https://github.com/facebook/rocksdb/issues/9891). DBs written with this new setting can be read by RocksDB 6.27 and newer.
@@ -178,7 +178,7 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
        gmake rocksdbjava

 * **iOS**:
-  * Run: `TARGET_OS=IOS make static_lib`. When building the project which uses rocksdb iOS library, make sure to define two important pre-processing macros: `ROCKSDB_LITE` and `IOS_CROSS_COMPILE`.
+  * Run: `TARGET_OS=IOS make static_lib`. When building the project which uses rocksdb iOS library, make sure to define an important pre-processing macros: `IOS_CROSS_COMPILE`.

 * **Windows** (Visual Studio 2017 to up):
  * Read and follow the instructions at CMakeLists.txt
@@ -83,27 +83,9 @@ endif

 $(info $$DEBUG_LEVEL is ${DEBUG_LEVEL})

-# Lite build flag.
-LITE ?= 0
-ifeq ($(LITE), 0)
-ifneq ($(filter -DROCKSDB_LITE,$(OPT)),)
-  # Be backward compatible and support older format where OPT=-DROCKSDB_LITE is
-  # specified instead of LITE=1 on the command line.
-  LITE=1
-endif
-else ifeq ($(LITE), 1)
-ifeq ($(filter -DROCKSDB_LITE,$(OPT)),)
-	OPT += -DROCKSDB_LITE
-endif
-endif
-
 # Figure out optimize level.
 ifneq ($(DEBUG_LEVEL), 2)
-ifeq ($(LITE), 0)
 	OPTIMIZE_LEVEL ?= -O2
-else
-	OPTIMIZE_LEVEL ?= -Os
-endif
 endif
 # `OPTIMIZE_LEVEL` is empty when the user does not set it and `DEBUG_LEVEL=2`.
 # In that case, the compiler default (`-O0` for gcc and clang) will be used.
@@ -266,6 +248,7 @@ ROCKSDB_PLUGIN_EXTERNS = $(foreach p, $(ROCKSDB_PLUGIN_W_FUNCS), int $($(p)_FUNC
 ROCKSDB_PLUGIN_BUILTINS = $(foreach p, $(ROCKSDB_PLUGIN_W_FUNCS), {\"$(p)\"\, $($(p)_FUNC)}\,)
 ROCKSDB_PLUGIN_LDFLAGS = $(foreach plugin, $(ROCKSDB_PLUGINS), $($(plugin)_LDFLAGS))
 ROCKSDB_PLUGIN_PKGCONFIG_REQUIRES = $(foreach plugin, $(ROCKSDB_PLUGINS), $($(plugin)_PKGCONFIG_REQUIRES))
+ROCKSDB_PLUGIN_TESTS = $(foreach p, $(ROCKSDB_PLUGINS), $(foreach test, $($(p)_TESTS), plugin/$(p)/$(test)))

 CXXFLAGS += $(foreach plugin, $(ROCKSDB_PLUGINS), $($(plugin)_CXXFLAGS))
 PLATFORM_LDFLAGS += $(ROCKSDB_PLUGIN_LDFLAGS)
@@ -336,13 +319,6 @@ endif
 ifeq ($(PLATFORM), OS_SOLARIS)
 	PLATFORM_CXXFLAGS += -D _GLIBCXX_USE_C99
 endif
-ifneq ($(filter -DROCKSDB_LITE,$(OPT)),)
-	# found
-	CFLAGS += -fno-exceptions
-	CXXFLAGS += -fno-exceptions
-	# LUA is not supported under ROCKSDB_LITE
-	LUA_PATH =
-endif

 ifeq ($(LIB_MODE),shared)
 # So that binaries are executable from build location, in addition to install location
@@ -647,10 +623,12 @@ STRESS_OBJECTS =  $(patsubst %.cc, $(OBJ_DIR)/%.o, $(STRESS_LIB_SOURCES))
 ALL_SOURCES  = $(filter-out util/build_version.cc, $(LIB_SOURCES)) $(TEST_LIB_SOURCES) $(MOCK_LIB_SOURCES) $(GTEST_DIR)/gtest/gtest-all.cc
 ALL_SOURCES += $(TOOL_LIB_SOURCES) $(BENCH_LIB_SOURCES) $(CACHE_BENCH_LIB_SOURCES) $(ANALYZER_LIB_SOURCES) $(STRESS_LIB_SOURCES)
 ALL_SOURCES += $(TEST_MAIN_SOURCES) $(TOOL_MAIN_SOURCES) $(BENCH_MAIN_SOURCES)
-ALL_SOURCES += $(ROCKSDB_PLUGIN_SOURCES)
+ALL_SOURCES += $(ROCKSDB_PLUGIN_SOURCES) $(ROCKSDB_PLUGIN_TESTS)

+PLUGIN_TESTS = $(patsubst %.cc, %, $(notdir $(ROCKSDB_PLUGIN_TESTS)))
 TESTS = $(patsubst %.cc, %, $(notdir $(TEST_MAIN_SOURCES)))
 TESTS += $(patsubst %.c, %, $(notdir $(TEST_MAIN_SOURCES_C)))
+TESTS += $(PLUGIN_TESTS)

 # `make check-headers` to very that each header file includes its own
 # dependencies
@@ -702,6 +680,7 @@ NON_PARALLEL_TEST = \
 	env_test \
 	deletefile_test \
 	db_bloom_filter_test \
+	$(PLUGIN_TESTS) \

 PARALLEL_TEST = $(filter-out $(NON_PARALLEL_TEST), $(TESTS))

@@ -1078,13 +1057,11 @@ check: all
 	rm -rf $(TEST_TMPDIR)
 ifneq ($(PLATFORM), OS_AIX)
 	$(PYTHON) tools/check_all_python.py
-ifeq ($(filter -DROCKSDB_LITE,$(OPT)),)
 ifndef ASSERT_STATUS_CHECKED # not yet working with these tests
 	$(PYTHON) tools/ldb_test.py
 	sh tools/rocksdb_dump_test.sh
 endif
 endif
-endif
 ifndef SKIP_FORMAT_BUCK_CHECKS
 	$(MAKE) check-format
 	$(MAKE) check-buck-targets
@@ -1355,6 +1332,14 @@ db_sanity_test: $(OBJ_DIR)/tools/db_sanity_test.o $(LIBRARY)
 db_repl_stress: $(OBJ_DIR)/tools/db_repl_stress.o $(LIBRARY)
 	$(AM_LINK)

+define MakeTestRule
+$(notdir $(1:%.cc=%)): $(1:%.cc=$$(OBJ_DIR)/%.o) $$(TEST_LIBRARY) $$(LIBRARY)
+	$$(AM_LINK)
+endef
+
+# For each PLUGIN test, create a rule to generate the test executable
+$(foreach test, $(ROCKSDB_PLUGIN_TESTS), $(eval $(call MakeTestRule, $(test))))
+
 arena_test: $(OBJ_DIR)/memory/arena_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)

@@ -2058,7 +2043,7 @@ JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux
 ifeq ($(PLATFORM), OS_SOLARIS)
 	ARCH := $(shell isainfo -b)
 else ifeq ($(PLATFORM), OS_OPENBSD)
-	ifneq (,$(filter amd64 ppc64 ppc64le s390x arm64 aarch64 sparc64, $(MACHINE)))
+	ifneq (,$(filter amd64 ppc64 ppc64le s390x arm64 aarch64 sparc64 loongarch64, $(MACHINE)))
 		ARCH := 64
 	else
 		ARCH := 32
@@ -2079,7 +2064,7 @@ ifneq ($(origin JNI_LIBC), undefined)
 endif

 ifeq (,$(ROCKSDBJNILIB))
-ifneq (,$(filter ppc% s390x arm64 aarch64 sparc64, $(MACHINE)))
+ifneq (,$(filter ppc% s390x arm64 aarch64 sparc64 loongarch64, $(MACHINE)))
 	ROCKSDBJNILIB = librocksdbjni-linux-$(MACHINE)$(JNI_LIBC_POSTFIX).so
 else
 	ROCKSDBJNILIB = librocksdbjni-linux$(ARCH)$(JNI_LIBC_POSTFIX).so
@@ -2092,8 +2077,8 @@ ROCKSDB_JAVADOCS_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar
 ROCKSDB_SOURCES_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar
 SHA256_CMD = sha256sum

-ZLIB_VER ?= 1.2.12
-ZLIB_SHA256 ?= 91844808532e5ce316b3c010929493c0244f3d37593afd6de04f71821d5136d9
+ZLIB_VER ?= 1.2.13
+ZLIB_SHA256 ?= b3a24de97a8fdbc835b9833169501030b8977031bcb54b3b3ac13740f846ab30
 ZLIB_DOWNLOAD_BASE ?= http://zlib.net
 BZIP2_VER ?= 1.0.8
 BZIP2_SHA256 ?= ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269
@@ -2477,18 +2462,6 @@ build_size:
 	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.shared_lib $$(stat --printf="%s" `readlink -f librocksdb.so`)
 	strip `readlink -f librocksdb.so`
 	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.shared_lib_stripped $$(stat --printf="%s" `readlink -f librocksdb.so`)
-	# === lite build, static ===
-	$(MAKE) clean
-	$(MAKE) LITE=1 static_lib
-	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.static_lib_lite $$(stat --printf="%s" librocksdb.a)
-	strip librocksdb.a
-	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.static_lib_lite_stripped $$(stat --printf="%s" librocksdb.a)
-	# === lite build, shared ===
-	$(MAKE) clean
-	$(MAKE) LITE=1 shared_lib
-	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.shared_lib_lite $$(stat --printf="%s" `readlink -f librocksdb.so`)
-	strip `readlink -f librocksdb.so`
-	$(REPORT_BUILD_STATISTIC) rocksdb.build_size.shared_lib_lite_stripped $$(stat --printf="%s" `readlink -f librocksdb.so`)

 # ---------------------------------------------------------------------------
 #  	Platform-specific compilation
@@ -1,21 +0,0 @@
-# RocksDBLite
-
-RocksDBLite is a project focused on mobile use cases, which don't need a lot of fancy things we've built for server workloads and they are very sensitive to binary size. For that reason, we added a compile flag ROCKSDB_LITE that comments out a lot of the nonessential code and keeps the binary lean.
-
-Some examples of the features disabled by ROCKSDB_LITE:
-* compiled-in support for LDB tool
-* No backup engine
-* No support for replication (which we provide in form of TransactionalIterator)
-* No advanced monitoring tools
-* No special-purpose memtables that are highly optimized for specific use cases
-* No Transactions
-
-When adding a new big feature to RocksDB, please add ROCKSDB_LITE compile guard if:
-* Nobody from mobile really needs your feature,
-* Your feature is adding a lot of weight to the binary.
-
-Don't add ROCKSDB_LITE compile guard if:
-* It would introduce a lot of code complexity. Compile guards make code harder to read. It's a trade-off.
-* Your feature is not adding a lot of weight.
-
-If unsure, ask. :)
@@ -11,13 +11,14 @@ load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrap
 cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "cache/cache.cc",
        "cache/cache_entry_roles.cc",
+        "cache/cache_helpers.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/secondary_cache.cc",
        "cache/sharded_cache.cc",
        "db/arena_wrapped_db_iter.cc",
        "db/blob/blob_contents.cc",
@@ -163,6 +164,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "options/options.cc",
        "options/options_helper.cc",
        "options/options_parser.cc",
+        "port/mmap.cc",
        "port/port_posix.cc",
        "port/stack_trace.cc",
        "port/win/env_default.cc",
@@ -179,6 +181,7 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
        "table/block_based/block_based_table_iterator.cc",
        "table/block_based/block_based_table_reader.cc",
        "table/block_based/block_builder.cc",
+        "table/block_based/block_cache.cc",
        "table/block_based/block_prefetcher.cc",
        "table/block_based/block_prefix_index.cc",
        "table/block_based/data_block_footer.cc",
@@ -350,13 +353,14 @@ cpp_library_wrapper(name="rocksdb_lib", srcs=[
 cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
        "cache/cache.cc",
        "cache/cache_entry_roles.cc",
+        "cache/cache_helpers.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/secondary_cache.cc",
        "cache/sharded_cache.cc",
        "db/arena_wrapped_db_iter.cc",
        "db/blob/blob_contents.cc",
@@ -502,6 +506,7 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
        "options/options.cc",
        "options/options_helper.cc",
        "options/options_parser.cc",
+        "port/mmap.cc",
        "port/port_posix.cc",
        "port/stack_trace.cc",
        "port/win/env_default.cc",
@@ -518,6 +523,7 @@ cpp_library_wrapper(name="rocksdb_whole_archive_lib", srcs=[
        "table/block_based/block_based_table_iterator.cc",
        "table/block_based/block_based_table_reader.cc",
        "table/block_based/block_builder.cc",
+        "table/block_based/block_cache.cc",
        "table/block_based/block_prefetcher.cc",
        "table/block_based/block_prefix_index.cc",
        "table/block_based/data_block_footer.cc",
@@ -79,6 +79,9 @@ quasardb uses a heavily tuned RocksDB as its persistence layer.
 ## TiKV
 [TiKV](https://github.com/pingcap/tikv) is a GEO-replicated, high-performance, distributed, transactional key-value database. TiKV is powered by Rust and Raft. TiKV uses RocksDB as its persistence layer.

+## Apache Spark
+[Spark Structured Streaming](https://docs.databricks.com/structured-streaming/rocksdb-state-store.html) uses RocksDB as the local state store.
+
 ## Apache Flink
 [Apache Flink](https://flink.apache.org/news/2016/03/08/release-1.0.0.html) uses RocksDB to store state locally on a machine.

@@ -26,7 +26,7 @@ from util import ColorString
 # $python3 buckifier/buckify_rocksdb.py \
 #        '{"fake": {
 #                      "extra_deps": [":test_dep", "//fakes/module:mock1"],
-#                      "extra_compiler_flags": ["-DROCKSDB_LITE", "-Os"]
+#                      "extra_compiler_flags": ["-DFOO_BAR", "-Os"]
 #                  }
 #         }'
 # (Generated TARGETS file has test_dep and mock1 as dependencies for RocksDB
@@ -154,7 +154,7 @@ case "$TARGET_OS" in
        ;;
    IOS)
        PLATFORM=IOS
-        COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE"
+        COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE "
        PLATFORM_SHARED_EXT=dylib
        PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
        CROSS_COMPILE=true
@@ -16,7 +16,6 @@
 #include "util/string_util.h"

 namespace ROCKSDB_NAMESPACE {
-#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, OptionTypeInfo>
    lru_cache_options_type_info = {
        {"capacity",
@@ -64,7 +63,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          OptionType::kBoolean, OptionVerificationType::kNormal,
          OptionTypeFlags::kMutable}},
 };
-#endif  // ROCKSDB_LITE

 Status SecondaryCache::CreateFromString(
    const ConfigOptions& config_options, const std::string& value,
@@ -75,7 +73,6 @@ Status SecondaryCache::CreateFromString(
    Status status;
    std::shared_ptr<SecondaryCache> sec_cache;

-#ifndef ROCKSDB_LITE
    CompressedSecondaryCacheOptions sec_cache_opts;
    status = OptionTypeInfo::ParseStruct(config_options, "",
                                         &comp_sec_cache_options_type_info, "",
@@ -84,11 +81,6 @@ Status SecondaryCache::CreateFromString(
      sec_cache = NewCompressedSecondaryCache(sec_cache_opts);
    }

-#else
-    (void)config_options;
-    status = Status::NotSupported(
-        "Cannot load compressed secondary cache in LITE mode ", args);
-#endif  //! ROCKSDB_LITE

    if (status.ok()) {
      result->swap(sec_cache);
@@ -108,7 +100,6 @@ Status Cache::CreateFromString(const ConfigOptions& config_options,
  if (value.find('=') == std::string::npos) {
    cache = NewLRUCache(ParseSizeT(value));
  } else {
-#ifndef ROCKSDB_LITE
    LRUCacheOptions cache_opts;
    status = OptionTypeInfo::ParseStruct(config_options, "",
                                         &lru_cache_options_type_info, "",
@@ -116,10 +107,6 @@ Status Cache::CreateFromString(const ConfigOptions& config_options,
    if (status.ok()) {
      cache = NewLRUCache(cache_opts);
    }
-#else
-    (void)config_options;
-    status = Status::NotSupported("Cannot load cache in LITE mode ", value);
-#endif  //! ROCKSDB_LITE
  }
  if (status.ok()) {
    result->swap(cache);
@@ -13,7 +13,6 @@
 #include <set>
 #include <sstream>

-#include "cache/fast_lru_cache.h"
 #include "db/db_impl/db_impl.h"
 #include "monitoring/histogram.h"
 #include "port/port.h"
@@ -78,11 +77,9 @@ DEFINE_bool(lean, false,
            "If true, no additional computation is performed besides cache "
            "operations.");

-#ifndef ROCKSDB_LITE
 DEFINE_string(secondary_cache_uri, "",
              "Full URI for creating a custom secondary cache object");
 static class std::shared_ptr<ROCKSDB_NAMESPACE::SecondaryCache> secondary_cache;
-#endif  // ROCKSDB_LITE

 DEFINE_string(cache_type, "lru_cache", "Type of block cache.");

@@ -227,7 +224,7 @@ struct KeyGen {
  }
 };

-char* createValue(Random64& rnd) {
+Cache::ObjectPtr createValue(Random64& rnd) {
  char* rv = new char[FLAGS_value_bytes];
  // Fill with some filler data, and take some CPU time
  for (uint32_t i = 0; i < FLAGS_value_bytes; i += 8) {
@@ -237,28 +234,33 @@ char* createValue(Random64& rnd) {
 }

 // Callbacks for secondary cache
-size_t SizeFn(void* /*obj*/) { return FLAGS_value_bytes; }
+size_t SizeFn(Cache::ObjectPtr /*obj*/) { return FLAGS_value_bytes; }

-Status SaveToFn(void* obj, size_t /*offset*/, size_t size, void* out) {
-  memcpy(out, obj, size);
+Status SaveToFn(Cache::ObjectPtr from_obj, size_t /*from_offset*/,
+                size_t length, char* out) {
+  memcpy(out, from_obj, length);
  return Status::OK();
 }

-// Different deleters to simulate using deleter to gather
-// stats on the code origin and kind of cache entries.
-void deleter1(const Slice& /*key*/, void* value) {
-  delete[] static_cast<char*>(value);
-}
-void deleter2(const Slice& /*key*/, void* value) {
-  delete[] static_cast<char*>(value);
-}
-void deleter3(const Slice& /*key*/, void* value) {
+Status CreateFn(const Slice& data, Cache::CreateContext* /*context*/,
+                MemoryAllocator* /*allocator*/, Cache::ObjectPtr* out_obj,
+                size_t* out_charge) {
+  *out_obj = new char[data.size()];
+  memcpy(*out_obj, data.data(), data.size());
+  *out_charge = data.size();
+  return Status::OK();
+};
+
+void DeleteFn(Cache::ObjectPtr value, MemoryAllocator* /*alloc*/) {
  delete[] static_cast<char*>(value);
 }

-Cache::CacheItemHelper helper1(SizeFn, SaveToFn, deleter1);
-Cache::CacheItemHelper helper2(SizeFn, SaveToFn, deleter2);
-Cache::CacheItemHelper helper3(SizeFn, SaveToFn, deleter3);
+Cache::CacheItemHelper helper1(CacheEntryRole::kDataBlock, DeleteFn, SizeFn,
+                               SaveToFn, CreateFn);
+Cache::CacheItemHelper helper2(CacheEntryRole::kIndexBlock, DeleteFn, SizeFn,
+                               SaveToFn, CreateFn);
+Cache::CacheItemHelper helper3(CacheEntryRole::kFilterBlock, DeleteFn, SizeFn,
+                               SaveToFn, CreateFn);
 }  // namespace

 class CacheBench {
@@ -297,15 +299,10 @@ class CacheBench {
      cache_ = HyperClockCacheOptions(FLAGS_cache_size, FLAGS_value_bytes,
                                      FLAGS_num_shard_bits)
                   .MakeSharedCache();
-    } 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 */);
-#ifndef ROCKSDB_LITE
      if (!FLAGS_secondary_cache_uri.empty()) {
        Status s = SecondaryCache::CreateFromString(
            ConfigOptions(), FLAGS_secondary_cache_uri, &secondary_cache);
@@ -318,7 +315,6 @@ class CacheBench {
        }
        opts.secondary_cache = secondary_cache;
      }
-#endif  // ROCKSDB_LITE

      cache_ = NewLRUCache(opts);
    } else {
@@ -441,7 +437,7 @@ class CacheBench {
    uint64_t total_entry_count = 0;
    uint64_t table_occupancy = 0;
    uint64_t table_size = 0;
-    std::set<Cache::DeleterFn> deleters;
+    std::set<const Cache::CacheItemHelper*> helpers;
    StopWatchNano timer(clock);

    for (;;) {
@@ -466,7 +462,7 @@ class CacheBench {
                 << BytesToHumanString(static_cast<uint64_t>(
                        1.0 * total_charge / total_entry_count))
                 << "\n"
-                 << "Unique deleters: " << deleters.size() << "\n";
+                 << "Unique helpers: " << helpers.size() << "\n";
            *stats_report = ostr.str();
            return;
          }
@@ -482,14 +478,14 @@ class CacheBench {
      total_key_size = 0;
      total_charge = 0;
      total_entry_count = 0;
-      deleters.clear();
-      auto fn = [&](const Slice& key, void* /*value*/, size_t charge,
-                    Cache::DeleterFn deleter) {
+      helpers.clear();
+      auto fn = [&](const Slice& key, Cache::ObjectPtr /*value*/, size_t charge,
+                    const Cache::CacheItemHelper* helper) {
        total_key_size += key.size();
        total_charge += charge;
        ++total_entry_count;
-        // Something slightly more expensive as in (future) stats by category
-        deleters.insert(deleter);
+        // Something slightly more expensive as in stats by category
+        helpers.insert(helper);
      };
      timer.Start();
      Cache::ApplyToAllEntriesOptions opts;
@@ -538,14 +534,6 @@ class CacheBench {
    for (uint64_t i = 0; i < FLAGS_ops_per_thread; i++) {
      Slice key = gen.GetRand(thread->rnd, max_key_, max_log_);
      uint64_t random_op = thread->rnd.Next();
-      Cache::CreateCallback create_cb = [](const void* buf, size_t size,
-                                           void** out_obj,
-                                           size_t* charge) -> Status {
-        *out_obj = reinterpret_cast<void*>(new char[size]);
-        memcpy(*out_obj, buf, size);
-        *charge = size;
-        return Status::OK();
-      };

      timer.Start();

@@ -555,8 +543,8 @@ class CacheBench {
          handle = nullptr;
        }
        // do lookup
-        handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
-                                true);
+        handle = cache_->Lookup(key, &helper2, /*context*/ nullptr,
+                                Cache::Priority::LOW, true);
        if (handle) {
          if (!FLAGS_lean) {
            // do something with the data
@@ -584,8 +572,8 @@ class CacheBench {
          handle = nullptr;
        }
        // do lookup
-        handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
-                                true);
+        handle = cache_->Lookup(key, &helper2, /*context*/ nullptr,
+                                Cache::Priority::LOW, true);
        if (handle) {
          if (!FLAGS_lean) {
            // do something with the data
@@ -101,34 +101,4 @@ std::string BlockCacheEntryStatsMapKeys::UsedPercent(CacheEntryRole role) {
  return GetPrefixedCacheEntryRoleName(kPrefix, role);
 }

-namespace {
-
-struct Registry {
-  std::mutex mutex;
-  UnorderedMap<Cache::DeleterFn, CacheEntryRole> role_map;
-  void Register(Cache::DeleterFn fn, CacheEntryRole role) {
-    std::lock_guard<std::mutex> lock(mutex);
-    role_map[fn] = role;
-  }
-  UnorderedMap<Cache::DeleterFn, CacheEntryRole> Copy() {
-    std::lock_guard<std::mutex> lock(mutex);
-    return role_map;
-  }
-};
-
-Registry& GetRegistry() {
-  STATIC_AVOID_DESTRUCTION(Registry, registry);
-  return registry;
-}
-
-}  // namespace
-
-void RegisterCacheDeleterRole(Cache::DeleterFn fn, CacheEntryRole role) {
-  GetRegistry().Register(fn, role);
-}
-
-UnorderedMap<Cache::DeleterFn, CacheEntryRole> CopyCacheDeleterRoleMap() {
-  return GetRegistry().Copy();
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -7,11 +7,8 @@

 #include <array>
 #include <cstdint>
-#include <memory>
-#include <type_traits>

 #include "rocksdb/cache.h"
-#include "util/hash_containers.h"

 namespace ROCKSDB_NAMESPACE {

@@ -20,84 +17,4 @@ extern std::array<std::string, kNumCacheEntryRoles>
 extern std::array<std::string, kNumCacheEntryRoles>
    kCacheEntryRoleToHyphenString;

-// To associate cache entries with their role, we use a hack on the
-// existing Cache interface. Because the deleter of an entry can authenticate
-// the code origin of an entry, we can elaborate the choice of deleter to
-// also encode role information, without inferring false role information
-// from entries not choosing to encode a role.
-//
-// The rest of this file is for handling mappings between deleters and
-// roles.
-
-// To infer a role from a deleter, the deleter must be registered. This
-// can be done "manually" with this function. This function is thread-safe,
-// and the registration mappings go into private but static storage. (Note
-// that DeleterFn is a function pointer, not std::function. Registrations
-// should not be too many.)
-void RegisterCacheDeleterRole(Cache::DeleterFn fn, CacheEntryRole role);
-
-// Gets a copy of the registered deleter -> role mappings. This is the only
-// function for reading the mappings made with RegisterCacheDeleterRole.
-// Why only this interface for reading?
-// * This function has to be thread safe, which could incur substantial
-// overhead. We should not pay this overhead for every deleter look-up.
-// * This is suitable for preparing for batch operations, like with
-// CacheEntryStatsCollector.
-// * The number of mappings should be sufficiently small (dozens).
-UnorderedMap<Cache::DeleterFn, CacheEntryRole> CopyCacheDeleterRoleMap();
-
-// ************************************************************** //
-// An automatic registration infrastructure. This enables code
-// to simply ask for a deleter associated with a particular type
-// and role, and registration is automatic. In a sense, this is
-// a small dependency injection infrastructure, because linking
-// in new deleter instantiations is essentially sufficient for
-// making stats collection (using CopyCacheDeleterRoleMap) aware
-// of them.
-
-namespace cache_entry_roles_detail {
-
-template <typename T, CacheEntryRole R>
-struct RegisteredDeleter {
-  RegisteredDeleter() { RegisterCacheDeleterRole(Delete, R); }
-
-  // These have global linkage to help ensure compiler optimizations do not
-  // break uniqueness for each <T,R>
-  static void Delete(const Slice& /* key */, void* value) {
-    // Supports T == Something[], unlike delete operator
-    std::default_delete<T>()(
-        static_cast<typename std::remove_extent<T>::type*>(value));
-  }
-};
-
-template <CacheEntryRole R>
-struct RegisteredNoopDeleter {
-  RegisteredNoopDeleter() { RegisterCacheDeleterRole(Delete, R); }
-
-  static void Delete(const Slice& /* key */, void* /* value */) {
-    // Here was `assert(value == nullptr);` but we can also put pointers
-    // to static data in Cache, for testing at least.
-  }
-};
-
-}  // namespace cache_entry_roles_detail
-
-// Get an automatically registered deleter for value type T and role R.
-// Based on C++ semantics, registration is invoked exactly once in a
-// thread-safe way on first call to this function, for each <T, R>.
-template <typename T, CacheEntryRole R>
-Cache::DeleterFn GetCacheEntryDeleterForRole() {
-  static cache_entry_roles_detail::RegisteredDeleter<T, R> reg;
-  return reg.Delete;
-}
-
-// Get an automatically registered no-op deleter (value should be nullptr)
-// and associated with role R. This is used for Cache "reservation" entries
-// such as for WriteBufferManager.
-template <CacheEntryRole R>
-Cache::DeleterFn GetNoopDeleterForRole() {
-  static cache_entry_roles_detail::RegisteredNoopDeleter<R> reg;
-  return reg.Delete;
-}
-
 }  // namespace ROCKSDB_NAMESPACE
@@ -10,8 +10,8 @@
 #include <memory>
 #include <mutex>

-#include "cache/cache_helpers.h"
 #include "cache/cache_key.h"
+#include "cache/typed_cache.h"
 #include "port/lang.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/status.h"
@@ -111,11 +111,14 @@ class CacheEntryStatsCollector {
  // Gets or creates a shared instance of CacheEntryStatsCollector in the
  // cache itself, and saves into `ptr`. This shared_ptr will hold the
  // entry in cache until all refs are destroyed.
-  static Status GetShared(Cache *cache, SystemClock *clock,
+  static Status GetShared(Cache *raw_cache, SystemClock *clock,
                          std::shared_ptr<CacheEntryStatsCollector> *ptr) {
-    const Slice &cache_key = GetCacheKey();
+    assert(raw_cache);
+    BasicTypedCacheInterface<CacheEntryStatsCollector, CacheEntryRole::kMisc>
+        cache{raw_cache};

-    Cache::Handle *h = cache->Lookup(cache_key);
+    const Slice &cache_key = GetCacheKey();
+    auto h = cache.Lookup(cache_key);
    if (h == nullptr) {
      // Not yet in cache, but Cache doesn't provide a built-in way to
      // avoid racing insert. So we double-check under a shared mutex,
@@ -123,15 +126,15 @@ class CacheEntryStatsCollector {
      STATIC_AVOID_DESTRUCTION(std::mutex, static_mutex);
      std::lock_guard<std::mutex> lock(static_mutex);

-      h = cache->Lookup(cache_key);
+      h = cache.Lookup(cache_key);
      if (h == nullptr) {
-        auto new_ptr = new CacheEntryStatsCollector(cache, clock);
+        auto new_ptr = new CacheEntryStatsCollector(cache.get(), clock);
        // TODO: non-zero charge causes some tests that count block cache
        // usage to go flaky. Fix the problem somehow so we can use an
        // accurate charge.
        size_t charge = 0;
-        Status s = cache->Insert(cache_key, new_ptr, charge, Deleter, &h,
-                                 Cache::Priority::HIGH);
+        Status s =
+            cache.Insert(cache_key, new_ptr, charge, &h, Cache::Priority::HIGH);
        if (!s.ok()) {
          assert(h == nullptr);
          delete new_ptr;
@@ -140,11 +143,11 @@ class CacheEntryStatsCollector {
      }
    }
    // If we reach here, shared entry is in cache with handle `h`.
-    assert(cache->GetDeleter(h) == Deleter);
+    assert(cache.get()->GetCacheItemHelper(h) == &cache.kBasicHelper);

    // Build an aliasing shared_ptr that keeps `ptr` in cache while there
    // are references.
-    *ptr = MakeSharedCacheHandleGuard<CacheEntryStatsCollector>(cache, h);
+    *ptr = cache.SharedGuard(h);
    return Status::OK();
  }

@@ -157,10 +160,6 @@ class CacheEntryStatsCollector {
        cache_(cache),
        clock_(clock) {}

-  static void Deleter(const Slice &, void *value) {
-    delete static_cast<CacheEntryStatsCollector *>(value);
-  }
-
  static const Slice &GetCacheKey() {
    // For each template instantiation
    static CacheKey ckey = CacheKey::CreateUniqueForProcessLifetime();
@@ -0,0 +1,40 @@
+//  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/cache_helpers.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+void ReleaseCacheHandleCleanup(void* arg1, void* arg2) {
+  Cache* const cache = static_cast<Cache*>(arg1);
+  assert(cache);
+
+  Cache::Handle* const cache_handle = static_cast<Cache::Handle*>(arg2);
+  assert(cache_handle);
+
+  cache->Release(cache_handle);
+}
+
+Status WarmInCache(Cache* cache, const Slice& key, const Slice& saved,
+                   Cache::CreateContext* create_context,
+                   const Cache::CacheItemHelper* helper,
+                   Cache::Priority priority, size_t* out_charge) {
+  assert(helper);
+  assert(helper->create_cb);
+  Cache::ObjectPtr value;
+  size_t charge;
+  Status st = helper->create_cb(saved, create_context,
+                                cache->memory_allocator(), &value, &charge);
+  if (st.ok()) {
+    st =
+        cache->Insert(key, value, helper, charge, /*handle*/ nullptr, priority);
+    if (out_charge) {
+      *out_charge = charge;
+    }
+  }
+  return st;
+}
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -17,22 +17,17 @@ template <typename T>
 T* GetFromCacheHandle(Cache* cache, Cache::Handle* handle) {
  assert(cache);
  assert(handle);
-
  return static_cast<T*>(cache->Value(handle));
 }

-// Simple generic deleter for Cache (to be used with Cache::Insert).
-template <typename T>
-void DeleteCacheEntry(const Slice& /* key */, void* value) {
-  delete static_cast<T*>(value);
-}
-
 // Turns a T* into a Slice so it can be used as a key with Cache.
 template <typename T>
-Slice GetSlice(const T* t) {
+Slice GetSliceForKey(const T* t) {
  return Slice(reinterpret_cast<const char*>(t), sizeof(T));
 }

+void ReleaseCacheHandleCleanup(void* arg1, void* arg2);
+
 // Generic resource management object for cache handles that releases the handle
 // when destroyed. Has unique ownership of the handle, so copying it is not
 // allowed, while moving it transfers ownership.
@@ -88,7 +83,7 @@ class CacheHandleGuard {
    if (cleanable) {
      if (handle_ != nullptr) {
        assert(cache_);
-        cleanable->RegisterCleanup(&ReleaseCacheHandle, cache_, handle_);
+        cleanable->RegisterCleanup(&ReleaseCacheHandleCleanup, cache_, handle_);
      }
    }
    ResetFields();
@@ -115,16 +110,6 @@ class CacheHandleGuard {
    value_ = nullptr;
  }

-  static void ReleaseCacheHandle(void* arg1, void* arg2) {
-    Cache* const cache = static_cast<Cache*>(arg1);
-    assert(cache);
-
-    Cache::Handle* const cache_handle = static_cast<Cache::Handle*>(arg2);
-    assert(cache_handle);
-
-    cache->Release(cache_handle);
-  }
-
 private:
  Cache* cache_ = nullptr;
  Cache::Handle* handle_ = nullptr;
@@ -139,7 +124,16 @@ template <typename T>
 std::shared_ptr<T> MakeSharedCacheHandleGuard(Cache* cache,
                                              Cache::Handle* handle) {
  auto wrapper = std::make_shared<CacheHandleGuard<T>>(cache, handle);
-  return std::shared_ptr<T>(wrapper, static_cast<T*>(cache->Value(handle)));
+  return std::shared_ptr<T>(wrapper, GetFromCacheHandle<T>(cache, handle));
 }

+// Given the persistable data (saved) for a block cache entry, parse that
+// into a cache entry object and insert it into the given cache. The charge
+// of the new entry can be returned to the caller through `out_charge`.
+Status WarmInCache(Cache* cache, const Slice& key, const Slice& saved,
+                   Cache::CreateContext* create_context,
+                   const Cache::CacheItemHelper* helper,
+                   Cache::Priority priority = Cache::Priority::LOW,
+                   size_t* out_charge = nullptr);
+
 }  // namespace ROCKSDB_NAMESPACE
@@ -13,7 +13,6 @@
 #include <cstring>
 #include <memory>

-#include "cache/cache_entry_roles.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
@@ -41,17 +40,17 @@ CacheReservationManagerImpl<
 template <CacheEntryRole R>
 CacheReservationManagerImpl<R>::CacheReservationManagerImpl(
    std::shared_ptr<Cache> cache, bool delayed_decrease)
-    : delayed_decrease_(delayed_decrease),
+    : cache_(cache),
+      delayed_decrease_(delayed_decrease),
      cache_allocated_size_(0),
      memory_used_(0) {
  assert(cache != nullptr);
-  cache_ = cache;
 }

 template <CacheEntryRole R>
 CacheReservationManagerImpl<R>::~CacheReservationManagerImpl() {
  for (auto* handle : dummy_handles_) {
-    cache_->Release(handle, true);
+    cache_.ReleaseAndEraseIfLastRef(handle);
  }
 }

@@ -115,8 +114,7 @@ Status CacheReservationManagerImpl<R>::IncreaseCacheReservation(
  Status return_status = Status::OK();
  while (new_mem_used > cache_allocated_size_.load(std::memory_order_relaxed)) {
    Cache::Handle* handle = nullptr;
-    return_status = cache_->Insert(GetNextCacheKey(), nullptr, kSizeDummyEntry,
-                                   GetNoopDeleterForRole<R>(), &handle);
+    return_status = cache_.Insert(GetNextCacheKey(), kSizeDummyEntry, &handle);

    if (return_status != Status::OK()) {
      return return_status;
@@ -141,7 +139,7 @@ Status CacheReservationManagerImpl<R>::DecreaseCacheReservation(
         cache_allocated_size_.load(std::memory_order_relaxed)) {
    assert(!dummy_handles_.empty());
    auto* handle = dummy_handles_.back();
-    cache_->Release(handle, true);
+    cache_.ReleaseAndEraseIfLastRef(handle);
    dummy_handles_.pop_back();
    cache_allocated_size_ -= kSizeDummyEntry;
  }
@@ -169,8 +167,9 @@ Slice CacheReservationManagerImpl<R>::GetNextCacheKey() {
 }

 template <CacheEntryRole R>
-Cache::DeleterFn CacheReservationManagerImpl<R>::TEST_GetNoopDeleterForRole() {
-  return GetNoopDeleterForRole<R>();
+const Cache::CacheItemHelper*
+CacheReservationManagerImpl<R>::TEST_GetCacheItemHelperForRole() {
+  return &CacheInterface::kHelper;
 }

 template class CacheReservationManagerImpl<
@@ -18,7 +18,7 @@

 #include "cache/cache_entry_roles.h"
 #include "cache/cache_key.h"
-#include "rocksdb/cache.h"
+#include "cache/typed_cache.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
 #include "util/coding.h"
@@ -197,10 +197,10 @@ class CacheReservationManagerImpl

  static constexpr std::size_t GetDummyEntrySize() { return kSizeDummyEntry; }

-  // For testing only - it is to help ensure the NoopDeleterForRole<R>
+  // For testing only - it is to help ensure the CacheItemHelperForRole<R>
  // accessed from CacheReservationManagerImpl and the one accessed from the
  // test are from the same translation units
-  static Cache::DeleterFn TEST_GetNoopDeleterForRole();
+  static const Cache::CacheItemHelper *TEST_GetCacheItemHelperForRole();

 private:
  static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
@@ -211,7 +211,8 @@ class CacheReservationManagerImpl
  Status IncreaseCacheReservation(std::size_t new_mem_used);
  Status DecreaseCacheReservation(std::size_t new_mem_used);

-  std::shared_ptr<Cache> cache_;
+  using CacheInterface = PlaceholderSharedCacheInterface<R>;
+  CacheInterface cache_;
  bool delayed_decrease_;
  std::atomic<std::size_t> cache_allocated_size_;
  std::size_t memory_used_;
@@ -15,15 +15,15 @@
 #include <string>
 #include <vector>

-#include "cache/fast_lru_cache.h"
 #include "cache/lru_cache.h"
+#include "cache/typed_cache.h"
 #include "port/stack_trace.h"
 #include "test_util/testharness.h"
 #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.
+// HyperClockCache only supports 16-byte keys, so some of the tests
+// originally written 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.

@@ -56,27 +56,34 @@ int DecodeKey32Bits(const Slice& k) {
  return DecodeFixed32(k.data());
 }

-void* EncodeValue(uintptr_t v) { return reinterpret_cast<void*>(v); }
+Cache::ObjectPtr EncodeValue(uintptr_t v) {
+  return reinterpret_cast<Cache::ObjectPtr>(v);
+}

 int DecodeValue(void* v) {
  return static_cast<int>(reinterpret_cast<uintptr_t>(v));
 }

-void DumbDeleter(const Slice& /*key*/, void* /*value*/) {}
+const Cache::CacheItemHelper kDumbHelper{
+    CacheEntryRole::kMisc,
+    [](Cache::ObjectPtr /*value*/, MemoryAllocator* /*alloc*/) {}};

-void EraseDeleter1(const Slice& /*key*/, void* value) {
-  Cache* cache = reinterpret_cast<Cache*>(value);
-  cache->Erase("foo");
-}
+const Cache::CacheItemHelper kEraseOnDeleteHelper1{
+    CacheEntryRole::kMisc,
+    [](Cache::ObjectPtr value, MemoryAllocator* /*alloc*/) {
+      Cache* cache = static_cast<Cache*>(value);
+      cache->Erase("foo");
+    }};

-void EraseDeleter2(const Slice& /*key*/, void* value) {
-  Cache* cache = reinterpret_cast<Cache*>(value);
-  cache->Erase(EncodeKey16Bytes(1234));
-}
+const Cache::CacheItemHelper kEraseOnDeleteHelper2{
+    CacheEntryRole::kMisc,
+    [](Cache::ObjectPtr value, MemoryAllocator* /*alloc*/) {
+      Cache* cache = static_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

@@ -85,14 +92,11 @@ class CacheTest : public testing::TestWithParam<std::string> {
  static CacheTest* current_;
  static std::string type_;

-  static void Deleter(const Slice& key, void* v) {
-    if (type_ == kFast || type_ == kHyperClock) {
-      current_->deleted_keys_.push_back(DecodeKey16Bytes(key));
-    } else {
-      current_->deleted_keys_.push_back(DecodeKey32Bits(key));
-    }
+  static void Deleter(Cache::ObjectPtr v, MemoryAllocator*) {
    current_->deleted_values_.push_back(DecodeValue(v));
  }
+  static constexpr Cache::CacheItemHelper kHelper{CacheEntryRole::kMisc,
+                                                  &Deleter};

  static const int kCacheSize = 1000;
  static const int kNumShardBits = 4;
@@ -100,7 +104,6 @@ class CacheTest : public testing::TestWithParam<std::string> {
  static const int kCacheSize2 = 100;
  static const int kNumShardBits2 = 2;

-  std::vector<int> deleted_keys_;
  std::vector<int> deleted_values_;
  std::shared_ptr<Cache> cache_;
  std::shared_ptr<Cache> cache2_;
@@ -126,11 +129,6 @@ class CacheTest : public testing::TestWithParam<std::string> {
                 capacity, estimated_value_size_ /*estimated_value_size*/)
          .MakeSharedCache();
    }
-    if (type == kFast) {
-      return NewFastLRUCache(
-          capacity, estimated_value_size_, -1 /*num_shard_bits*/,
-          false /*strict_capacity_limit*/, kDefaultCacheMetadataChargePolicy);
-    }
    return nullptr;
  }

@@ -153,11 +151,6 @@ class CacheTest : public testing::TestWithParam<std::string> {
                                    nullptr /*allocator*/, charge_policy)
          .MakeSharedCache();
    }
-    if (type == kFast) {
-      return NewFastLRUCache(capacity, 1 /*estimated_value_size*/,
-                             num_shard_bits, strict_capacity_limit,
-                             charge_policy);
-    }
    return nullptr;
  }

@@ -167,7 +160,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
  // LRUCache doesn't, so the encoding depends on the cache type.
  std::string EncodeKey(int k) {
    auto type = GetParam();
-    if (type == kFast || type == kHyperClock) {
+    if (type == kHyperClock) {
      return EncodeKey16Bytes(k);
    } else {
      return EncodeKey32Bits(k);
@@ -176,7 +169,7 @@ class CacheTest : public testing::TestWithParam<std::string> {

  int DecodeKey(const Slice& k) {
    auto type = GetParam();
-    if (type == kFast || type == kHyperClock) {
+    if (type == kHyperClock) {
      return DecodeKey16Bytes(k);
    } else {
      return DecodeKey32Bits(k);
@@ -194,37 +187,29 @@ class CacheTest : public testing::TestWithParam<std::string> {

  void Insert(std::shared_ptr<Cache> cache, int key, int value,
              int charge = 1) {
-    EXPECT_OK(cache->Insert(EncodeKey(key), EncodeValue(value), charge,
-                            &CacheTest::Deleter));
+    EXPECT_OK(
+        cache->Insert(EncodeKey(key), EncodeValue(value), &kHelper, charge));
  }

  void Erase(std::shared_ptr<Cache> cache, int key) {
    cache->Erase(EncodeKey(key));
  }

-  int Lookup(int key) {
-    return Lookup(cache_, key);
-  }
+  int Lookup(int key) { return Lookup(cache_, key); }

  void Insert(int key, int value, int charge = 1) {
    Insert(cache_, key, value, charge);
  }

-  void Erase(int key) {
-    Erase(cache_, key);
-  }
+  void Erase(int key) { Erase(cache_, key); }

-  int Lookup2(int key) {
-    return Lookup(cache2_, key);
-  }
+  int Lookup2(int key) { return Lookup(cache2_, key); }

  void Insert2(int key, int value, int charge = 1) {
    Insert(cache2_, key, value, charge);
  }

-  void Erase2(int key) {
-    Erase(cache2_, key);
-  }
+  void Erase2(int key) { Erase(cache2_, key); }
 };

 CacheTest* CacheTest::current_;
@@ -256,10 +241,8 @@ TEST_P(CacheTest, UsageTest) {
      key = EncodeKey(i);
    }
    auto kv_size = key.size() + 5;
-    ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), kv_size,
-                            DumbDeleter));
-    ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    kv_size, DumbDeleter));
+    ASSERT_OK(cache->Insert(key, value, &kDumbHelper, kv_size));
+    ASSERT_OK(precise_cache->Insert(key, value, &kDumbHelper, kv_size));
    usage += kv_size;
    ASSERT_EQ(usage, cache->GetUsage());
    if (type == kHyperClock) {
@@ -282,10 +265,8 @@ TEST_P(CacheTest, UsageTest) {
    } else {
      key = EncodeKey(static_cast<int>(1000 + i));
    }
-    ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                            DumbDeleter));
-    ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    key.size() + 5, DumbDeleter));
+    ASSERT_OK(cache->Insert(key, value, &kDumbHelper, key.size() + 5));
+    ASSERT_OK(precise_cache->Insert(key, value, &kDumbHelper, key.size() + 5));
  }

  // the usage should be close to the capacity
@@ -340,11 +321,9 @@ TEST_P(CacheTest, PinnedUsageTest) {
    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));
+    ASSERT_OK(cache->Insert(key, value, &kDumbHelper, kv_size, &handle));
    assert(handle);
-    ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    kv_size, DumbDeleter,
+    ASSERT_OK(precise_cache->Insert(key, value, &kDumbHelper, kv_size,
                                    &handle_in_precise_cache));
    assert(handle_in_precise_cache);
    pinned_usage += kv_size;
@@ -385,10 +364,8 @@ TEST_P(CacheTest, PinnedUsageTest) {
    } else {
      key = EncodeKey(static_cast<int>(1000 + i));
    }
-    ASSERT_OK(cache->Insert(key, reinterpret_cast<void*>(value), key.size() + 5,
-                            DumbDeleter));
-    ASSERT_OK(precise_cache->Insert(key, reinterpret_cast<void*>(value),
-                                    key.size() + 5, DumbDeleter));
+    ASSERT_OK(cache->Insert(key, value, &kDumbHelper, key.size() + 5));
+    ASSERT_OK(precise_cache->Insert(key, value, &kDumbHelper, key.size() + 5));
  }
  ASSERT_EQ(pinned_usage, cache->GetPinnedUsage());
  ASSERT_EQ(precise_cache_pinned_usage, precise_cache->GetPinnedUsage());
@@ -418,13 +395,13 @@ TEST_P(CacheTest, HitAndMiss) {

  Insert(100, 101);
  ASSERT_EQ(101, Lookup(100));
-  ASSERT_EQ(-1,  Lookup(200));
-  ASSERT_EQ(-1,  Lookup(300));
+  ASSERT_EQ(-1, Lookup(200));
+  ASSERT_EQ(-1, Lookup(300));

  Insert(200, 201);
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
-  ASSERT_EQ(-1,  Lookup(300));
+  ASSERT_EQ(-1, Lookup(300));

  Insert(100, 102);
  if (GetParam() == kHyperClock) {
@@ -434,10 +411,9 @@ TEST_P(CacheTest, HitAndMiss) {
    ASSERT_EQ(102, Lookup(100));
  }
  ASSERT_EQ(201, Lookup(200));
-  ASSERT_EQ(-1,  Lookup(300));
+  ASSERT_EQ(-1, Lookup(300));

-  ASSERT_EQ(1U, deleted_keys_.size());
-  ASSERT_EQ(100, deleted_keys_[0]);
+  ASSERT_EQ(1U, deleted_values_.size());
  if (GetParam() == kHyperClock) {
    ASSERT_EQ(102, deleted_values_[0]);
  } else {
@@ -458,21 +434,20 @@ TEST_P(CacheTest, InsertSameKey) {

 TEST_P(CacheTest, Erase) {
  Erase(200);
-  ASSERT_EQ(0U, deleted_keys_.size());
+  ASSERT_EQ(0U, deleted_values_.size());

  Insert(100, 101);
  Insert(200, 201);
  Erase(100);
-  ASSERT_EQ(-1,  Lookup(100));
+  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
-  ASSERT_EQ(1U, deleted_keys_.size());
-  ASSERT_EQ(100, deleted_keys_[0]);
+  ASSERT_EQ(1U, deleted_values_.size());
  ASSERT_EQ(101, deleted_values_[0]);

  Erase(100);
-  ASSERT_EQ(-1,  Lookup(100));
+  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
-  ASSERT_EQ(1U, deleted_keys_.size());
+  ASSERT_EQ(1U, deleted_values_.size());
 }

 TEST_P(CacheTest, EntriesArePinned) {
@@ -489,23 +464,21 @@ TEST_P(CacheTest, EntriesArePinned) {
  Insert(100, 102);
  Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
  ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
-  ASSERT_EQ(0U, deleted_keys_.size());
+  ASSERT_EQ(0U, deleted_values_.size());
  ASSERT_EQ(2U, cache_->GetUsage());

  cache_->Release(h1);
-  ASSERT_EQ(1U, deleted_keys_.size());
-  ASSERT_EQ(100, deleted_keys_[0]);
+  ASSERT_EQ(1U, deleted_values_.size());
  ASSERT_EQ(101, deleted_values_[0]);
  ASSERT_EQ(1U, cache_->GetUsage());

  Erase(100);
  ASSERT_EQ(-1, Lookup(100));
-  ASSERT_EQ(1U, deleted_keys_.size());
+  ASSERT_EQ(1U, deleted_values_.size());
  ASSERT_EQ(1U, cache_->GetUsage());

  cache_->Release(h2);
-  ASSERT_EQ(2U, deleted_keys_.size());
-  ASSERT_EQ(100, deleted_keys_[1]);
+  ASSERT_EQ(2U, deleted_values_.size());
  ASSERT_EQ(102, deleted_values_[1]);
  ASSERT_EQ(0U, cache_->GetUsage());
 }
@@ -515,7 +488,7 @@ TEST_P(CacheTest, EvictionPolicy) {
  Insert(200, 201);
  // Frequently used entry must be kept around
  for (int i = 0; i < 2 * kCacheSize; i++) {
-    Insert(1000+i, 2000+i);
+    Insert(1000 + i, 2000 + i);
    ASSERT_EQ(101, Lookup(100));
  }
  ASSERT_EQ(101, Lookup(100));
@@ -608,9 +581,9 @@ TEST_P(CacheTest, EvictEmptyCache) {
  // 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));
+    ASSERT_OK(cache->Insert("foo", nullptr, &kDumbHelper, 10));
  } else {
-    ASSERT_OK(cache->Insert(EncodeKey(1000), nullptr, 10, DumbDeleter));
+    ASSERT_OK(cache->Insert(EncodeKey(1000), nullptr, &kDumbHelper, 10));
  }
 }

@@ -621,19 +594,19 @@ TEST_P(CacheTest, EraseFromDeleter) {
  // the cache at that point.
  std::shared_ptr<Cache> cache = NewCache(10, 0, false);
  std::string foo, bar;
-  Cache::DeleterFn erase_deleter;
+  const Cache::CacheItemHelper* erase_helper;
  if (type == kLRU) {
    foo = "foo";
    bar = "bar";
-    erase_deleter = EraseDeleter1;
+    erase_helper = &kEraseOnDeleteHelper1;
  } else {
    foo = EncodeKey(1234);
    bar = EncodeKey(5678);
-    erase_deleter = EraseDeleter2;
+    erase_helper = &kEraseOnDeleteHelper2;
  }

-  ASSERT_OK(cache->Insert(foo, nullptr, 1, DumbDeleter));
-  ASSERT_OK(cache->Insert(bar, cache.get(), 1, erase_deleter));
+  ASSERT_OK(cache->Insert(foo, nullptr, &kDumbHelper, 1));
+  ASSERT_OK(cache->Insert(bar, cache.get(), erase_helper, 1));

  cache->Erase(bar);
  ASSERT_EQ(nullptr, cache->Lookup(foo));
@@ -686,7 +659,7 @@ TEST_P(CacheTest, HeavyEntries) {
      ASSERT_EQ(1000 + i, r);
    }
  }
-  ASSERT_LE(cached_weight, kCacheSize + kCacheSize/10);
+  ASSERT_LE(cached_weight, kCacheSize + kCacheSize / 10);
 }

 TEST_P(CacheTest, NewId) {
@@ -695,53 +668,54 @@ TEST_P(CacheTest, NewId) {
  ASSERT_NE(a, b);
 }

-class Value {
- public:
-  explicit Value(int v) : v_(v) {}
-
-  int v_;
-};
-
-namespace {
-void deleter(const Slice& /*key*/, void* value) {
-  delete static_cast<Value *>(value);
-}
-}  // namespace
-
 TEST_P(CacheTest, ReleaseAndErase) {
  std::shared_ptr<Cache> cache = NewCache(5, 0, false);
  Cache::Handle* handle;
-  Status s = cache->Insert(EncodeKey(100), EncodeValue(100), 1,
-                           &CacheTest::Deleter, &handle);
+  Status s =
+      cache->Insert(EncodeKey(100), EncodeValue(100), &kHelper, 1, &handle);
  ASSERT_TRUE(s.ok());
  ASSERT_EQ(5U, cache->GetCapacity());
  ASSERT_EQ(1U, cache->GetUsage());
-  ASSERT_EQ(0U, deleted_keys_.size());
+  ASSERT_EQ(0U, deleted_values_.size());
  auto erased = cache->Release(handle, true);
  ASSERT_TRUE(erased);
  // This tests that deleter has been called
-  ASSERT_EQ(1U, deleted_keys_.size());
+  ASSERT_EQ(1U, deleted_values_.size());
 }

 TEST_P(CacheTest, ReleaseWithoutErase) {
  std::shared_ptr<Cache> cache = NewCache(5, 0, false);
  Cache::Handle* handle;
-  Status s = cache->Insert(EncodeKey(100), EncodeValue(100), 1,
-                           &CacheTest::Deleter, &handle);
+  Status s =
+      cache->Insert(EncodeKey(100), EncodeValue(100), &kHelper, 1, &handle);
  ASSERT_TRUE(s.ok());
  ASSERT_EQ(5U, cache->GetCapacity());
  ASSERT_EQ(1U, cache->GetUsage());
-  ASSERT_EQ(0U, deleted_keys_.size());
+  ASSERT_EQ(0U, deleted_values_.size());
  auto erased = cache->Release(handle);
  ASSERT_FALSE(erased);
  // This tests that deleter is not called. When cache has free capacity it is
  // not expected to immediately erase the released items.
-  ASSERT_EQ(0U, deleted_keys_.size());
+  ASSERT_EQ(0U, deleted_values_.size());
 }

+namespace {
+class Value {
+ public:
+  explicit Value(int v) : v_(v) {}
+
+  int v_;
+
+  static constexpr auto kCacheEntryRole = CacheEntryRole::kMisc;
+};
+
+using SharedCache = BasicTypedSharedCacheInterface<Value>;
+using TypedHandle = SharedCache::TypedHandle;
+}  // namespace
+
 TEST_P(CacheTest, SetCapacity) {
  auto type = GetParam();
-  if (type == kFast || type == kHyperClock) {
+  if (type == kHyperClock) {
    ROCKSDB_GTEST_BYPASS(
        "FastLRUCache and HyperClockCache don't support arbitrary capacity "
        "adjustments.");
@@ -751,19 +725,19 @@ TEST_P(CacheTest, SetCapacity) {
  // lets create a cache with capacity 5,
  // then, insert 5 elements, then increase capacity
  // to 10, returned capacity should be 10, usage=5
-  std::shared_ptr<Cache> cache = NewCache(5, 0, false);
-  std::vector<Cache::Handle*> handles(10);
+  SharedCache cache{NewCache(5, 0, false)};
+  std::vector<TypedHandle*> handles(10);
  // Insert 5 entries, but not releasing.
  for (int i = 0; i < 5; i++) {
    std::string key = EncodeKey(i + 1);
-    Status s = cache->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
+    Status s = cache.Insert(key, new Value(i + 1), 1, &handles[i]);
    ASSERT_TRUE(s.ok());
  }
-  ASSERT_EQ(5U, cache->GetCapacity());
-  ASSERT_EQ(5U, cache->GetUsage());
-  cache->SetCapacity(10);
-  ASSERT_EQ(10U, cache->GetCapacity());
-  ASSERT_EQ(5U, cache->GetUsage());
+  ASSERT_EQ(5U, cache.get()->GetCapacity());
+  ASSERT_EQ(5U, cache.get()->GetUsage());
+  cache.get()->SetCapacity(10);
+  ASSERT_EQ(10U, cache.get()->GetCapacity());
+  ASSERT_EQ(5U, cache.get()->GetUsage());

  // test2: decrease capacity
  // insert 5 more elements to cache, then release 5,
@@ -771,85 +745,77 @@ TEST_P(CacheTest, SetCapacity) {
  // and usage should be 7
  for (int i = 5; i < 10; i++) {
    std::string key = EncodeKey(i + 1);
-    Status s = cache->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
+    Status s = cache.Insert(key, new Value(i + 1), 1, &handles[i]);
    ASSERT_TRUE(s.ok());
  }
-  ASSERT_EQ(10U, cache->GetCapacity());
-  ASSERT_EQ(10U, cache->GetUsage());
+  ASSERT_EQ(10U, cache.get()->GetCapacity());
+  ASSERT_EQ(10U, cache.get()->GetUsage());
  for (int i = 0; i < 5; i++) {
-    cache->Release(handles[i]);
+    cache.Release(handles[i]);
  }
-  ASSERT_EQ(10U, cache->GetCapacity());
-  ASSERT_EQ(10U, cache->GetUsage());
-  cache->SetCapacity(7);
-  ASSERT_EQ(7, cache->GetCapacity());
-  ASSERT_EQ(7, cache->GetUsage());
+  ASSERT_EQ(10U, cache.get()->GetCapacity());
+  ASSERT_EQ(10U, cache.get()->GetUsage());
+  cache.get()->SetCapacity(7);
+  ASSERT_EQ(7, cache.get()->GetCapacity());
+  ASSERT_EQ(7, cache.get()->GetUsage());

  // release remaining 5 to keep valgrind happy
  for (int i = 5; i < 10; i++) {
-    cache->Release(handles[i]);
+    cache.Release(handles[i]);
  }

  // Make sure this doesn't crash or upset ASAN/valgrind
-  cache->DisownData();
+  cache.get()->DisownData();
 }

 TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
-  auto type = GetParam();
-  if (type == kFast) {
-    ROCKSDB_GTEST_BYPASS(
-        "FastLRUCache only supports a limited number of "
-        "inserts beyond "
-        "capacity.");
-    return;
-  }
  // test1: set the flag to false. Insert more keys than capacity. See if they
  // all go through.
-  std::shared_ptr<Cache> cache = NewCache(5, 0, false);
-  std::vector<Cache::Handle*> handles(10);
+  SharedCache cache{NewCache(5, 0, false)};
+  std::vector<TypedHandle*> handles(10);
  Status s;
  for (int i = 0; i < 10; i++) {
    std::string key = EncodeKey(i + 1);
-    s = cache->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
+    s = cache.Insert(key, new Value(i + 1), 1, &handles[i]);
    ASSERT_OK(s);
    ASSERT_NE(nullptr, handles[i]);
  }
-  ASSERT_EQ(10, cache->GetUsage());
+  ASSERT_EQ(10, cache.get()->GetUsage());

  // test2: set the flag to true. Insert and check if it fails.
  std::string extra_key = EncodeKey(100);
  Value* extra_value = new Value(0);
-  cache->SetStrictCapacityLimit(true);
-  Cache::Handle* handle;
-  s = cache->Insert(extra_key, extra_value, 1, &deleter, &handle);
+  cache.get()->SetStrictCapacityLimit(true);
+  TypedHandle* handle;
+  s = cache.Insert(extra_key, extra_value, 1, &handle);
  ASSERT_TRUE(s.IsMemoryLimit());
  ASSERT_EQ(nullptr, handle);
-  ASSERT_EQ(10, cache->GetUsage());
+  ASSERT_EQ(10, cache.get()->GetUsage());

  for (int i = 0; i < 10; i++) {
-    cache->Release(handles[i]);
+    cache.Release(handles[i]);
  }

  // test3: init with flag being true.
-  std::shared_ptr<Cache> cache2 = NewCache(5, 0, true);
+  SharedCache cache2{NewCache(5, 0, true)};
  for (int i = 0; i < 5; i++) {
    std::string key = EncodeKey(i + 1);
-    s = cache2->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
+    s = cache2.Insert(key, new Value(i + 1), 1, &handles[i]);
    ASSERT_OK(s);
    ASSERT_NE(nullptr, handles[i]);
  }
-  s = cache2->Insert(extra_key, extra_value, 1, &deleter, &handle);
+  s = cache2.Insert(extra_key, extra_value, 1, &handle);
  ASSERT_TRUE(s.IsMemoryLimit());
  ASSERT_EQ(nullptr, handle);
  // test insert without handle
-  s = cache2->Insert(extra_key, extra_value, 1, &deleter);
+  s = cache2.Insert(extra_key, extra_value, 1);
  // AS if the key have been inserted into cache but get evicted immediately.
  ASSERT_OK(s);
-  ASSERT_EQ(5, cache2->GetUsage());
-  ASSERT_EQ(nullptr, cache2->Lookup(extra_key));
+  ASSERT_EQ(5, cache2.get()->GetUsage());
+  ASSERT_EQ(nullptr, cache2.Lookup(extra_key));

  for (int i = 0; i < 5; i++) {
-    cache2->Release(handles[i]);
+    cache2.Release(handles[i]);
  }
 }

@@ -857,55 +823,54 @@ TEST_P(CacheTest, OverCapacity) {
  size_t n = 10;

  // a LRUCache with n entries and one shard only
-  std::shared_ptr<Cache> cache = NewCache(n, 0, false);
-
-  std::vector<Cache::Handle*> handles(n+1);
+  SharedCache cache{NewCache(n, 0, false)};
+  std::vector<TypedHandle*> handles(n + 1);

  // Insert n+1 entries, but not releasing.
  for (int i = 0; i < static_cast<int>(n + 1); i++) {
    std::string key = EncodeKey(i + 1);
-    Status s = cache->Insert(key, new Value(i + 1), 1, &deleter, &handles[i]);
+    Status s = cache.Insert(key, new Value(i + 1), 1, &handles[i]);
    ASSERT_TRUE(s.ok());
  }

  // Guess what's in the cache now?
  for (int i = 0; i < static_cast<int>(n + 1); i++) {
    std::string key = EncodeKey(i + 1);
-    auto h = cache->Lookup(key);
+    auto h = cache.Lookup(key);
    ASSERT_TRUE(h != nullptr);
-    if (h) cache->Release(h);
+    if (h) cache.Release(h);
  }

  // the cache is over capacity since nothing could be evicted
-  ASSERT_EQ(n + 1U, cache->GetUsage());
+  ASSERT_EQ(n + 1U, cache.get()->GetUsage());
  for (int i = 0; i < static_cast<int>(n + 1); i++) {
-    cache->Release(handles[i]);
+    cache.Release(handles[i]);
  }

  if (GetParam() == kHyperClock) {
    // Make sure eviction is triggered.
-    ASSERT_OK(cache->Insert(EncodeKey(-1), nullptr, 1, &deleter, &handles[0]));
+    ASSERT_OK(cache.Insert(EncodeKey(-1), nullptr, 1, &handles[0]));

    // cache is under capacity now since elements were released
-    ASSERT_GE(n, cache->GetUsage());
+    ASSERT_GE(n, cache.get()->GetUsage());

    // clean up
-    cache->Release(handles[0]);
+    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());
+    ASSERT_EQ(n, cache.get()->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);
+      auto h = cache.Lookup(key);
      if (h) {
        ASSERT_NE(static_cast<size_t>(i), 0U);
-        cache->Release(h);
+        cache.Release(h);
      } else {
        ASSERT_EQ(static_cast<size_t>(i), 0U);
      }
@@ -913,40 +878,15 @@ TEST_P(CacheTest, OverCapacity) {
  }
 }

-namespace {
-std::vector<std::pair<int, int>> legacy_callback_state;
-void legacy_callback(void* value, size_t charge) {
-  legacy_callback_state.push_back(
-      {DecodeValue(value), static_cast<int>(charge)});
-}
-};
-
-TEST_P(CacheTest, ApplyToAllCacheEntriesTest) {
-  std::vector<std::pair<int, int>> inserted;
-  legacy_callback_state.clear();
-
-  for (int i = 0; i < 10; ++i) {
-    Insert(i, i * 2, i + 1);
-    inserted.push_back({i * 2, i + 1});
-  }
-  cache_->ApplyToAllCacheEntries(legacy_callback, true);
-
-  std::sort(inserted.begin(), inserted.end());
-  std::sort(legacy_callback_state.begin(), legacy_callback_state.end());
-  ASSERT_EQ(inserted.size(), legacy_callback_state.size());
-  for (int i = 0; i < static_cast<int>(inserted.size()); ++i) {
-    EXPECT_EQ(inserted[i], legacy_callback_state[i]);
-  }
-}
-
 TEST_P(CacheTest, ApplyToAllEntriesTest) {
  std::vector<std::string> callback_state;
-  const auto callback = [&](const Slice& key, void* value, size_t charge,
-                            Cache::DeleterFn deleter) {
+  const auto callback = [&](const Slice& key, Cache::ObjectPtr value,
+                            size_t charge,
+                            const Cache::CacheItemHelper* helper) {
    callback_state.push_back(std::to_string(DecodeKey(key)) + "," +
                             std::to_string(DecodeValue(value)) + "," +
                             std::to_string(charge));
-    assert(deleter == &CacheTest::Deleter);
+    assert(helper == &CacheTest::kHelper);
  };

  std::vector<std::string> inserted;
@@ -985,8 +925,8 @@ TEST_P(CacheTest, ApplyToAllEntriesDuringResize) {

  // For callback
  int special_count = 0;
-  const auto callback = [&](const Slice&, void*, size_t charge,
-                            Cache::DeleterFn) {
+  const auto callback = [&](const Slice&, Cache::ObjectPtr, size_t charge,
+                            const Cache::CacheItemHelper*) {
    if (charge == static_cast<size_t>(kSpecialCharge)) {
      ++special_count;
    }
@@ -1048,14 +988,13 @@ TEST_P(CacheTest, GetChargeAndDeleter) {
  Cache::Handle* h1 = cache_->Lookup(EncodeKey(1));
  ASSERT_EQ(2, DecodeValue(cache_->Value(h1)));
  ASSERT_EQ(1, cache_->GetCharge(h1));
-  ASSERT_EQ(&CacheTest::Deleter, cache_->GetDeleter(h1));
+  ASSERT_EQ(&CacheTest::kHelper, cache_->GetCacheItemHelper(h1));
  cache_->Release(h1);
 }

 INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
-                        testing::Values(kLRU, kHyperClock, kFast));
-INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest,
-                        testing::Values(kLRU, kFast));
+                        testing::Values(kLRU, kHyperClock));
+INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest, testing::Values(kLRU));

 }  // namespace ROCKSDB_NAMESPACE

@@ -17,25 +17,10 @@ ChargedCache::ChargedCache(std::shared_ptr<Cache> cache,
              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,
+Status ChargedCache::Insert(const Slice& key, ObjectPtr obj,
                            const CacheItemHelper* helper, size_t charge,
                            Handle** handle, Priority priority) {
-  Status s = cache_->Insert(key, value, helper, charge, handle, priority);
+  Status s = cache_->Insert(key, obj, 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
@@ -47,22 +32,21 @@ Status ChargedCache::Insert(const Slice& key, void* value,
  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,
+                                    CreateContext* create_context,
                                    Priority priority, bool wait,
                                    Statistics* stats) {
-  auto handle = cache_->Lookup(key, helper, create_cb, priority, wait, stats);
+  auto handle =
+      cache_->Lookup(key, helper, create_context, 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();
+  if (helper && helper->create_cb) {
+    assert(cache_res_mgr_);
+    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+        .PermitUncheckedError();
+  }
  return handle;
 }

@@ -23,16 +23,14 @@ class ChargedCache : public 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,
+  Status Insert(const Slice& key, ObjectPtr obj, 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;
+                        CreateContext* create_context,
+                        Priority priority = Priority::LOW, bool wait = true,
+                        Statistics* stats = nullptr) override;

  bool Release(Cache::Handle* handle, bool useful,
               bool erase_if_last_ref = false) override;
@@ -56,7 +54,9 @@ class ChargedCache : public Cache {
    return cache_->HasStrictCapacityLimit();
  }

-  void* Value(Cache::Handle* handle) override { return cache_->Value(handle); }
+  ObjectPtr Value(Cache::Handle* handle) override {
+    return cache_->Value(handle);
+  }

  bool IsReady(Cache::Handle* handle) override {
    return cache_->IsReady(handle);
@@ -84,22 +84,17 @@ class ChargedCache : public Cache {
    return cache_->GetCharge(handle);
  }

-  Cache::DeleterFn GetDeleter(Cache::Handle* handle) const override {
-    return cache_->GetDeleter(handle);
+  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override {
+    return cache_->GetCacheItemHelper(handle);
  }

  void ApplyToAllEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               Cache::DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, ObjectPtr value, size_t charge,
+                               const CacheItemHelper* helper)>& 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();
  }
@@ -27,12 +27,13 @@

 namespace ROCKSDB_NAMESPACE {

-namespace hyper_clock_cache {
+namespace clock_cache {

 // Forward declaration of friend class.
 class ClockCacheTest;

-// HyperClockCache is an experimental alternative to LRUCache.
+// HyperClockCache is an alternative to LRUCache specifically tailored for
+// use as BlockBasedTableOptions::block_cache
 //
 // Benefits
 // --------
@@ -304,23 +305,29 @@ constexpr double kLoadFactor = 0.7;
 constexpr double kStrictLoadFactor = 0.84;

 struct ClockHandleBasicData {
-  void* value = nullptr;
-  Cache::DeleterFn deleter = nullptr;
+  Cache::ObjectPtr value = nullptr;
+  const Cache::CacheItemHelper* helper = nullptr;
  // A lossless, reversible hash of the fixed-size (16 byte) cache key. This
  // eliminates the need to store a hash separately.
  UniqueId64x2 hashed_key = kNullUniqueId64x2;
  size_t total_charge = 0;

+  // For total_charge_and_flags
+  // "Detached" means the handle is allocated separately from hash table.
+  static constexpr uint64_t kFlagDetached = uint64_t{1} << 63;
+  // Extract just the total charge
+  static constexpr uint64_t kTotalChargeMask = kFlagDetached - 1;
+
+  inline size_t GetTotalCharge() const { return total_charge; }
+
  // Calls deleter (if non-null) on cache key and value
-  void FreeData() const;
+  void FreeData(MemoryAllocator* allocator) const;

  // Required by concept HandleImpl
  const UniqueId64x2& GetHash() const { return hashed_key; }
 };

-// Target size to be exactly a common cache line size (see static_assert in
-// clock_cache.cc)
-struct ALIGN_AS(64U) ClockHandle : public ClockHandleBasicData {
+struct ClockHandle : public ClockHandleBasicData {
  // Constants for handling the atomic `meta` word, which tracks most of the
  // state of the handle. The meta word looks like this:
  // low bits                                                     high bits
@@ -372,32 +379,54 @@ struct ALIGN_AS(64U) ClockHandle : public ClockHandleBasicData {

  // See above
  std::atomic<uint64_t> meta{};
-  // The number of elements that hash to this slot or a lower one, but wind
-  // up in this slot or a higher one.
-  std::atomic<uint32_t> displacements{};

-  // True iff the handle is allocated separately from hash table.
-  bool detached = false;
+  // Anticipating use for SecondaryCache support
+  void* reserved_for_future_use = nullptr;
 };  // struct ClockHandle

-class ClockHandleTable {
+class HyperClockTable {
 public:
-  explicit ClockHandleTable(int hash_bits, bool initial_charge_metadata);
-  ~ClockHandleTable();
+  // Target size to be exactly a common cache line size (see static_assert in
+  // clock_cache.cc)
+  struct ALIGN_AS(64U) HandleImpl : public ClockHandle {
+    // The number of elements that hash to this slot or a lower one, but wind
+    // up in this slot or a higher one.
+    std::atomic<uint32_t> displacements{};

-  Status Insert(const ClockHandleBasicData& proto, ClockHandle** handle,
+    // Whether this is a "deteched" handle that is independently allocated
+    // with `new` (so must be deleted with `delete`).
+    // TODO: ideally this would be packed into some other data field, such
+    // as upper bits of total_charge, but that incurs a measurable performance
+    // regression.
+    bool detached = false;
+
+    inline bool IsDetached() const { return detached; }
+
+    inline void SetDetached() { detached = true; }
+  };  // struct HandleImpl
+
+  struct Opts {
+    size_t estimated_value_size;
+  };
+
+  HyperClockTable(size_t capacity, bool strict_capacity_limit,
+                  CacheMetadataChargePolicy metadata_charge_policy,
+                  MemoryAllocator* allocator, const Opts& opts);
+  ~HyperClockTable();
+
+  Status Insert(const ClockHandleBasicData& proto, HandleImpl** handle,
                Cache::Priority priority, size_t capacity,
                bool strict_capacity_limit);

-  ClockHandle* Lookup(const UniqueId64x2& hashed_key);
+  HandleImpl* Lookup(const UniqueId64x2& hashed_key);

-  bool Release(ClockHandle* handle, bool useful, bool erase_if_last_ref);
+  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref);

-  void Ref(ClockHandle& handle);
+  void Ref(HandleImpl& handle);

  void Erase(const UniqueId64x2& hashed_key);

-  void ConstApplyToEntriesRange(std::function<void(const ClockHandle&)> func,
+  void ConstApplyToEntriesRange(std::function<void(const HandleImpl&)> func,
                                size_t index_begin, size_t index_end,
                                bool apply_if_will_be_deleted) const;

@@ -407,12 +436,12 @@ class ClockHandleTable {

  int GetLengthBits() const { return length_bits_; }

-  size_t GetOccupancyLimit() const { return occupancy_limit_; }
-
  size_t GetOccupancy() const {
    return occupancy_.load(std::memory_order_relaxed);
  }

+  size_t GetOccupancyLimit() const { return occupancy_limit_; }
+
  size_t GetUsage() const { return usage_.load(std::memory_order_relaxed); }

  size_t GetDetachedUsage() const {
@@ -420,8 +449,8 @@ class ClockHandleTable {
  }

  // Acquire/release N references
-  void TEST_RefN(ClockHandle& handle, size_t n);
-  void TEST_ReleaseN(ClockHandle* handle, size_t n);
+  void TEST_RefN(HandleImpl& handle, size_t n);
+  void TEST_ReleaseN(HandleImpl* handle, size_t n);

 private:  // functions
  // Returns x mod 2^{length_bits_}.
@@ -432,8 +461,8 @@ class ClockHandleTable {
  // Runs the clock eviction algorithm trying to reclaim at least
  // requested_charge. Returns how much is evicted, which could be less
  // if it appears impossible to evict the requested amount without blocking.
-  void Evict(size_t requested_charge, size_t* freed_charge,
-             size_t* freed_count);
+  inline void Evict(size_t requested_charge, size_t* freed_charge,
+                    size_t* freed_count);

  // Returns the first slot in the probe sequence, starting from the given
  // probe number, with a handle e such that match(e) is true. At every
@@ -446,15 +475,56 @@ class ClockHandleTable {
  // value of probe is one more than the last non-aborting probe during the
  // call. This is so that that the variable can be used to keep track of
  // progress across consecutive calls to FindSlot.
-  inline ClockHandle* FindSlot(const UniqueId64x2& hashed_key,
-                               std::function<bool(ClockHandle*)> match,
-                               std::function<bool(ClockHandle*)> stop,
-                               std::function<void(ClockHandle*)> update,
-                               size_t& probe);
+  inline HandleImpl* FindSlot(const UniqueId64x2& hashed_key,
+                              std::function<bool(HandleImpl*)> match,
+                              std::function<bool(HandleImpl*)> stop,
+                              std::function<void(HandleImpl*)> update,
+                              size_t& probe);

  // Re-decrement all displacements in probe path starting from beginning
  // until (not including) the given handle
-  void Rollback(const UniqueId64x2& hashed_key, const ClockHandle* h);
+  inline void Rollback(const UniqueId64x2& hashed_key, const HandleImpl* h);
+
+  // Subtracts `total_charge` from `usage_` and 1 from `occupancy_`.
+  // Ideally this comes after releasing the entry itself so that we
+  // actually have the available occupancy/usage that is claimed.
+  // However, that means total_charge has to be saved from the handle
+  // before releasing it so that it can be provided to this function.
+  inline void ReclaimEntryUsage(size_t total_charge);
+
+  // Helper for updating `usage_` for new entry with given `total_charge`
+  // and evicting if needed under strict_capacity_limit=true rules. This
+  // means the operation might fail with Status::MemoryLimit. If
+  // `need_evict_for_occupancy`, then eviction of at least one entry is
+  // required, and the operation should fail if not possible.
+  // NOTE: Otherwise, occupancy_ is not managed in this function
+  inline Status ChargeUsageMaybeEvictStrict(size_t total_charge,
+                                            size_t capacity,
+                                            bool need_evict_for_occupancy);
+
+  // Helper for updating `usage_` for new entry with given `total_charge`
+  // and evicting if needed under strict_capacity_limit=false rules. This
+  // means that updating `usage_` always succeeds even if forced to exceed
+  // capacity. If `need_evict_for_occupancy`, then eviction of at least one
+  // entry is required, and the operation should return false if such eviction
+  // is not possible. `usage_` is not updated in that case. Otherwise, returns
+  // true, indicating success.
+  // NOTE: occupancy_ is not managed in this function
+  inline bool ChargeUsageMaybeEvictNonStrict(size_t total_charge,
+                                             size_t capacity,
+                                             bool need_evict_for_occupancy);
+
+  // Creates a "detached" handle for returning from an Insert operation that
+  // cannot be completed by actually inserting into the table.
+  // Updates `detached_usage_` but not `usage_` nor `occupancy_`.
+  inline HandleImpl* DetachedInsert(const ClockHandleBasicData& proto);
+
+  MemoryAllocator* GetAllocator() const { return allocator_; }
+
+  // Returns the number of bits used to hash an element in the hash
+  // table.
+  static int CalcHashBits(size_t capacity, size_t estimated_value_size,
+                          CacheMetadataChargePolicy metadata_charge_policy);

 private:  // data
  // Number of hash bits used for table index.
@@ -468,7 +538,10 @@ class ClockHandleTable {
  const size_t occupancy_limit_;

  // Array of slots comprising the hash table.
-  const std::unique_ptr<ClockHandle[]> array_;
+  const std::unique_ptr<HandleImpl[]> array_;
+
+  // From Cache, for deleter
+  MemoryAllocator* const allocator_;

  // We partition the following members into different cache lines
  // to avoid false sharing among Lookup, Release, Erase and Insert
@@ -487,17 +560,18 @@ class ClockHandleTable {

  // Part of usage by detached entries (not in table)
  std::atomic<size_t> detached_usage_{};
-};  // class ClockHandleTable
+};  // class HyperClockTable

 // A single shard of sharded cache.
+template <class Table>
 class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
 public:
-  ClockCacheShard(size_t capacity, size_t estimated_value_size,
-                  bool strict_capacity_limit,
-                  CacheMetadataChargePolicy metadata_charge_policy);
+  ClockCacheShard(size_t capacity, bool strict_capacity_limit,
+                  CacheMetadataChargePolicy metadata_charge_policy,
+                  MemoryAllocator* allocator, const typename Table::Opts& opts);

  // For CacheShard concept
-  using HandleImpl = ClockHandle;
+  using HandleImpl = typename Table::HandleImpl;
  // Hash is lossless hash of 128-bit key
  using HashVal = UniqueId64x2;
  using HashCref = const HashVal&;
@@ -531,74 +605,62 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {

  void SetStrictCapacityLimit(bool strict_capacity_limit);

-  Status Insert(const Slice& key, const UniqueId64x2& hashed_key, void* value,
-                size_t charge, Cache::DeleterFn deleter, ClockHandle** handle,
-                Cache::Priority priority);
+  Status Insert(const Slice& key, const UniqueId64x2& hashed_key,
+                Cache::ObjectPtr value, const Cache::CacheItemHelper* helper,
+                size_t charge, HandleImpl** handle, Cache::Priority priority);

-  ClockHandle* Lookup(const Slice& key, const UniqueId64x2& hashed_key);
+  HandleImpl* Lookup(const Slice& key, const UniqueId64x2& hashed_key);

-  bool Release(ClockHandle* handle, bool useful, bool erase_if_last_ref);
+  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref);

-  bool Release(ClockHandle* handle, bool erase_if_last_ref = false);
+  bool Release(HandleImpl* handle, bool erase_if_last_ref = false);

-  bool Ref(ClockHandle* handle);
+  bool Ref(HandleImpl* handle);

  void Erase(const Slice& key, const UniqueId64x2& hashed_key);

+  size_t GetCapacity() const;
+
  size_t GetUsage() const;

+  size_t GetDetachedUsage() const;
+
  size_t GetPinnedUsage() const;

  size_t GetOccupancyCount() const;

+  size_t GetOccupancyLimit() const;
+
  size_t GetTableAddressCount() const;

  void ApplyToSomeEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, Cache::ObjectPtr obj,
+                               size_t charge,
+                               const Cache::CacheItemHelper* helper)>& callback,
      size_t average_entries_per_lock, size_t* state);

  void EraseUnRefEntries();

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

-  // SecondaryCache not yet supported
-  Status Insert(const Slice& key, const UniqueId64x2& hashed_key, void* value,
-                const Cache::CacheItemHelper* helper, size_t charge,
-                ClockHandle** handle, Cache::Priority priority) {
-    return Insert(key, hashed_key, value, charge, helper->del_cb, handle,
-                  priority);
-  }
-
-  ClockHandle* Lookup(const Slice& key, const UniqueId64x2& hashed_key,
-                      const Cache::CacheItemHelper* /*helper*/,
-                      const Cache::CreateCallback& /*create_cb*/,
-                      Cache::Priority /*priority*/, bool /*wait*/,
-                      Statistics* /*stats*/) {
+  HandleImpl* Lookup(const Slice& key, const UniqueId64x2& hashed_key,
+                     const Cache::CacheItemHelper* /*helper*/,
+                     Cache::CreateContext* /*create_context*/,
+                     Cache::Priority /*priority*/, bool /*wait*/,
+                     Statistics* /*stats*/) {
    return Lookup(key, hashed_key);
  }

-  bool IsReady(ClockHandle* /*handle*/) { return true; }
+  bool IsReady(HandleImpl* /*handle*/) { return true; }

-  void Wait(ClockHandle* /*handle*/) {}
+  void Wait(HandleImpl* /*handle*/) {}

  // Acquire/release N references
-  void TEST_RefN(ClockHandle* handle, size_t n);
-  void TEST_ReleaseN(ClockHandle* handle, size_t n);
-
- private:  // functions
-  friend class ClockCache;
-  friend class ClockCacheTest;
-
-  ClockHandle* DetachedInsert(const ClockHandleBasicData& h);
-
-  // Returns the number of bits used to hash an element in the hash
-  // table.
-  static int CalcHashBits(size_t capacity, size_t estimated_value_size,
-                          CacheMetadataChargePolicy metadata_charge_policy);
+  void TEST_RefN(HandleImpl* handle, size_t n);
+  void TEST_ReleaseN(HandleImpl* handle, size_t n);

 private:  // data
-  ClockHandleTable table_;
+  Table table_;

  // Maximum total charge of all elements stored in the table.
  std::atomic<size_t> capacity_;
@@ -611,8 +673,10 @@ class HyperClockCache
 #ifdef NDEBUG
    final
 #endif
-    : public ShardedCache<ClockCacheShard> {
+    : public ShardedCache<ClockCacheShard<HyperClockTable>> {
 public:
+  using Shard = ClockCacheShard<HyperClockTable>;
+
  HyperClockCache(size_t capacity, size_t estimated_value_size,
                  int num_shard_bits, bool strict_capacity_limit,
                  CacheMetadataChargePolicy metadata_charge_policy,
@@ -620,13 +684,16 @@ class HyperClockCache

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

-  void* Value(Handle* handle) override;
+  Cache::ObjectPtr Value(Handle* handle) override;

  size_t GetCharge(Handle* handle) const override;

-  DeleterFn GetDeleter(Handle* handle) const override;
+  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
+
+  void ReportProblems(
+      const std::shared_ptr<Logger>& /*info_log*/) const override;
 };  // class HyperClockCache

-}  // namespace hyper_clock_cache
+}  // namespace clock_cache

 }  // namespace ROCKSDB_NAMESPACE
@@ -37,8 +37,10 @@ CompressedSecondaryCache::CompressedSecondaryCache(
 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) {
+    const Slice& key, const Cache::CacheItemHelper* helper,
+    Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
+    bool& is_in_sec_cache) {
+  assert(helper);
  std::unique_ptr<SecondaryCacheResultHandle> handle;
  is_in_sec_cache = false;
  Cache::Handle* lru_handle = cache_->Lookup(key);
@@ -64,12 +66,14 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
    ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
    handle_value_charge = cache_->GetCharge(lru_handle);
  }
+  MemoryAllocator* allocator = cache_options_.memory_allocator.get();

  Status s;
-  void* value{nullptr};
+  Cache::ObjectPtr value{nullptr};
  size_t charge{0};
  if (cache_options_.compression_type == kNoCompression) {
-    s = create_cb(ptr->get(), handle_value_charge, &value, &charge);
+    s = helper->create_cb(Slice(ptr->get(), handle_value_charge),
+                          create_context, allocator, &value, &charge);
  } else {
    UncompressionContext uncompression_context(cache_options_.compression_type);
    UncompressionInfo uncompression_info(uncompression_context,
@@ -79,14 +83,14 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
    size_t uncompressed_size{0};
    CacheAllocationPtr uncompressed = UncompressData(
        uncompression_info, (char*)ptr->get(), handle_value_charge,
-        &uncompressed_size, cache_options_.compress_format_version,
-        cache_options_.memory_allocator.get());
+        &uncompressed_size, cache_options_.compress_format_version, allocator);

    if (!uncompressed) {
      cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
      return nullptr;
    }
-    s = create_cb(uncompressed.get(), uncompressed_size, &value, &charge);
+    s = helper->create_cb(Slice(uncompressed.get(), uncompressed_size),
+                          create_context, allocator, &value, &charge);
  }

  if (!s.ok()) {
@@ -98,8 +102,9 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
    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))
+        ->Insert(key, /*obj=*/nullptr,
+                 GetHelper(cache_options_.enable_custom_split_merge),
+                 /*charge=*/0)
        .PermitUncheckedError();
  } else {
    is_in_sec_cache = true;
@@ -109,19 +114,20 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
  return handle;
 }

-Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
+Status CompressedSecondaryCache::Insert(const Slice& key,
+                                        Cache::ObjectPtr 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);
+  auto internal_helper = GetHelper(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);
+    return cache_->Insert(key, /*obj=*/nullptr, internal_helper,
+                          /*charge=*/0);
  } else {
    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
  }
@@ -169,10 +175,10 @@ Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
    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);
+    return cache_->Insert(key, value_chunks_head, internal_helper, charge);
  } else {
    CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    return cache_->Insert(key, buf, size, del_cb);
+    return cache_->Insert(key, buf, internal_helper, size);
  }
 }

@@ -276,23 +282,29 @@ CacheAllocationPtr CompressedSecondaryCache::MergeChunksIntoValue(
  return ptr;
 }

-Cache::DeleterFn CompressedSecondaryCache::GetDeletionCallback(
-    bool enable_custom_split_merge) {
+const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
+    bool enable_custom_split_merge) const {
  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;
-      };
-    };
+    static const Cache::CacheItemHelper kHelper{
+        CacheEntryRole::kMisc,
+        [](Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
+          CacheValueChunk* chunks_head = static_cast<CacheValueChunk*>(obj);
+          while (chunks_head != nullptr) {
+            CacheValueChunk* tmp_chunk = chunks_head;
+            chunks_head = chunks_head->next;
+            tmp_chunk->Free();
+            obj = nullptr;
+          };
+        }};
+    return &kHelper;
  } else {
-    return [](const Slice& /*key*/, void* obj) {
-      delete reinterpret_cast<CacheAllocationPtr*>(obj);
-      obj = nullptr;
-    };
+    static const Cache::CacheItemHelper kHelper{
+        CacheEntryRole::kMisc,
+        [](Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
+          delete static_cast<CacheAllocationPtr*>(obj);
+          obj = nullptr;
+        }};
+    return &kHelper;
  }
 }

@@ -21,7 +21,7 @@ namespace ROCKSDB_NAMESPACE {

 class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
 public:
-  CompressedSecondaryCacheResultHandle(void* value, size_t size)
+  CompressedSecondaryCacheResultHandle(Cache::ObjectPtr value, size_t size)
      : value_(value), size_(size) {}
  ~CompressedSecondaryCacheResultHandle() override = default;

@@ -34,12 +34,12 @@ class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {

  void Wait() override {}

-  void* Value() override { return value_; }
+  Cache::ObjectPtr Value() override { return value_; }

  size_t Size() override { return size_; }

 private:
-  void* value_;
+  Cache::ObjectPtr value_;
  size_t size_;
 };

@@ -83,12 +83,13 @@ class CompressedSecondaryCache : public SecondaryCache {

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

-  Status Insert(const Slice& key, void* value,
+  Status Insert(const Slice& key, Cache::ObjectPtr value,
                const Cache::CacheItemHelper* helper) override;

  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
-      bool advise_erase, bool& is_in_sec_cache) override;
+      const Slice& key, const Cache::CacheItemHelper* helper,
+      Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
+      bool& is_in_sec_cache) override;

  bool SupportForceErase() const override { return true; }

@@ -129,8 +130,8 @@ class CompressedSecondaryCache : public SecondaryCache {
  CacheAllocationPtr MergeChunksIntoValue(const void* chunks_head,
                                          size_t& charge);

-  // An implementation of Cache::DeleterFn.
-  static Cache::DeleterFn GetDeletionCallback(bool enable_custom_split_merge);
+  // TODO: clean up to use cleaner interfaces in typed_cache.h
+  const Cache::CacheItemHelper* GetHelper(bool enable_custom_split_merge) const;
  std::shared_ptr<Cache> cache_;
  CompressedSecondaryCacheOptions cache_options_;
  mutable port::Mutex capacity_mutex_;
@@ -16,7 +16,8 @@

 namespace ROCKSDB_NAMESPACE {

-class CompressedSecondaryCacheTest : public testing::Test {
+class CompressedSecondaryCacheTest : public testing::Test,
+                                     public Cache::CreateContext {
 public:
  CompressedSecondaryCacheTest() : fail_create_(false) {}
  ~CompressedSecondaryCacheTest() override = default;
@@ -37,13 +38,13 @@ class CompressedSecondaryCacheTest : public testing::Test {
    size_t size_;
  };

-  static size_t SizeCallback(void* obj) {
-    return reinterpret_cast<TestItem*>(obj)->Size();
+  static size_t SizeCallback(Cache::ObjectPtr obj) {
+    return static_cast<TestItem*>(obj)->Size();
  }

-  static Status SaveToCallback(void* from_obj, size_t from_offset,
-                               size_t length, void* out) {
-    auto item = reinterpret_cast<TestItem*>(from_obj);
+  static Status SaveToCallback(Cache::ObjectPtr from_obj, size_t from_offset,
+                               size_t length, char* out) {
+    auto item = static_cast<TestItem*>(from_obj);
    const char* buf = item->Buf();
    EXPECT_EQ(length, item->Size());
    EXPECT_EQ(from_offset, 0);
@@ -51,30 +52,36 @@ class CompressedSecondaryCacheTest : public testing::Test {
    return Status::OK();
  }

-  static void DeletionCallback(const Slice& /*key*/, void* obj) {
-    delete reinterpret_cast<TestItem*>(obj);
+  static void DeletionCallback(Cache::ObjectPtr obj,
+                               MemoryAllocator* /*alloc*/) {
+    delete static_cast<TestItem*>(obj);
    obj = nullptr;
  }

-  static Cache::CacheItemHelper helper_;
-
-  static Status SaveToCallbackFail(void* /*obj*/, size_t /*offset*/,
-                                   size_t /*size*/, void* /*out*/) {
+  static Status SaveToCallbackFail(Cache::ObjectPtr /*obj*/, size_t /*offset*/,
+                                   size_t /*size*/, char* /*out*/) {
    return Status::NotSupported();
  }

-  static Cache::CacheItemHelper helper_fail_;
-
-  Cache::CreateCallback test_item_creator = [&](const void* buf, size_t size,
-                                                void** out_obj,
-                                                size_t* charge) -> Status {
-    if (fail_create_) {
+  static Status CreateCallback(const Slice& data, Cache::CreateContext* context,
+                               MemoryAllocator* /*allocator*/,
+                               Cache::ObjectPtr* out_obj, size_t* out_charge) {
+    auto t = static_cast<CompressedSecondaryCacheTest*>(context);
+    if (t->fail_create_) {
      return Status::NotSupported();
    }
-    *out_obj = reinterpret_cast<void*>(new TestItem((char*)buf, size));
-    *charge = size;
+    *out_obj = new TestItem(data.data(), data.size());
+    *out_charge = data.size();
    return Status::OK();
-  };
+  }
+
+  static constexpr Cache::CacheItemHelper kHelper{
+      CacheEntryRole::kMisc, &DeletionCallback, &SizeCallback, &SaveToCallback,
+      &CreateCallback};
+
+  static constexpr Cache::CacheItemHelper kHelperFail{
+      CacheEntryRole::kMisc, &DeletionCallback, &SizeCallback,
+      &SaveToCallbackFail, &CreateCallback};

  void SetFailCreate(bool fail) { fail_create_ = fail; }

@@ -84,7 +91,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    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);
+        "k0", &kHelper, this, true, /*advise_erase=*/true, is_in_sec_cache);
    ASSERT_EQ(handle0, nullptr);

    Random rnd(301);
@@ -92,23 +99,21 @@ class CompressedSecondaryCacheTest : public testing::Test {
    std::string str1(rnd.RandomString(1000));
    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_OK(sec_cache->Insert("k1", &item1, &kHelper));
    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);
+        "k1", &kHelper, this, 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_OK(sec_cache->Insert("k1", &item1, &kHelper));
    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);
+        "k1", &kHelper, this, true, /*advise_erase=*/true, is_in_sec_cache);
    ASSERT_NE(handle1_2, nullptr);
    ASSERT_FALSE(is_in_sec_cache);
    if (sec_cache_is_compressed) {
@@ -128,21 +133,19 @@ class CompressedSecondaryCacheTest : public testing::Test {

    // 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);
+        "k1", &kHelper, this, true, /*advise_erase=*/true, is_in_sec_cache);
    ASSERT_EQ(handle1_3, nullptr);

    // Insert and Lookup the item k2.
    std::string str2(rnd.RandomString(1000));
    TestItem item2(str2.data(), str2.length());
-    ASSERT_OK(sec_cache->Insert("k2", &item2,
-                                &CompressedSecondaryCacheTest::helper_));
+    ASSERT_OK(sec_cache->Insert("k2", &item2, &kHelper));
    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);
+        "k2", &kHelper, this, true, /*advise_erase=*/false, is_in_sec_cache);
    ASSERT_EQ(handle2_1, nullptr);

-    ASSERT_OK(sec_cache->Insert("k2", &item2,
-                                &CompressedSecondaryCacheTest::helper_));
+    ASSERT_OK(sec_cache->Insert("k2", &item2, &kHelper));
    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,
@@ -154,7 +157,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
      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);
+        "k2", &kHelper, this, true, /*advise_erase=*/false, is_in_sec_cache);
    ASSERT_NE(handle2_2, nullptr);
    std::unique_ptr<TestItem> val2 =
        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle2_2->Value()));
@@ -223,28 +226,24 @@ class CompressedSecondaryCacheTest : public testing::Test {
    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_));
+    ASSERT_OK(sec_cache->Insert("k1", &item1, &kHelper));
    // Insert k1.
-    ASSERT_OK(sec_cache->Insert("k1", &item1,
-                                &CompressedSecondaryCacheTest::helper_));
+    ASSERT_OK(sec_cache->Insert("k1", &item1, &kHelper));

    // 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.
-    ASSERT_OK(sec_cache->Insert("k2", &item2,
-                                &CompressedSecondaryCacheTest::helper_));
+    ASSERT_OK(sec_cache->Insert("k2", &item2, &kHelper));
    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);
+        "k1", &kHelper, this, 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_));
+    ASSERT_OK(sec_cache->Insert("k2", &item2, &kHelper));
    std::unique_ptr<SecondaryCacheResultHandle> handle2 = sec_cache->Lookup(
-        "k2", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
+        "k2", &kHelper, this, true, /*advise_erase=*/false, is_in_sec_cache);
    ASSERT_NE(handle2, nullptr);
    std::unique_ptr<TestItem> val2 =
        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle2->Value()));
@@ -252,27 +251,24 @@ class CompressedSecondaryCacheTest : public testing::Test {
    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_));
+    ASSERT_OK(sec_cache->Insert("k1", &item1, &kHelper));

    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 = sec_cache->Lookup(
-        "k1", test_item_creator, true, /*advise_erase=*/false, is_in_sec_cache);
+        "k1", &kHelper, this, 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);
+        "k2", &kHelper, this, true, /*advise_erase=*/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_));
+    ASSERT_OK(sec_cache->Insert("k3", &item3, &kHelperFail));
+    ASSERT_NOK(sec_cache->Insert("k3", &item3, &kHelperFail));

    sec_cache.reset();
  }
@@ -309,15 +305,13 @@ class CompressedSecondaryCacheTest : public testing::Test {
    Random rnd(301);
    std::string str1 = rnd.RandomString(1001);
    auto item1_1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_1, &CompressedSecondaryCacheTest::helper_, str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1_1, &kHelper, str1.length()));

    std::string str2 = rnd.RandomString(1012);
    auto 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_OK(cache->Insert("k2", item2_1, &kHelper, 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);
@@ -326,22 +320,19 @@ class CompressedSecondaryCacheTest : public testing::Test {
    auto 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_OK(cache->Insert("k3", item3_1, &kHelper, str3.length()));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 2);

    // After this Insert, primary cache contains k1 and secondary cache contains
    // k1's dummy item, k2's dummy item, and k3's dummy item.
    auto item1_2 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_2, &CompressedSecondaryCacheTest::helper_, str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1_2, &kHelper, 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.
    auto item2_2 = new TestItem(str2.data(), str2.length());
-    ASSERT_OK(cache->Insert(
-        "k2", item2_2, &CompressedSecondaryCacheTest::helper_, str2.length()));
+    ASSERT_OK(cache->Insert("k2", item2_2, &kHelper, 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,
@@ -356,8 +347,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    // After this Insert, primary cache contains k3 and secondary cache contains
    // k1's item and k2's item.
    auto item3_2 = new TestItem(str3.data(), str3.length());
-    ASSERT_OK(cache->Insert(
-        "k3", item3_2, &CompressedSecondaryCacheTest::helper_, str3.length()));
+    ASSERT_OK(cache->Insert("k3", item3_2, &kHelper, 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,
@@ -370,8 +360,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    }

    Cache::Handle* handle;
-    handle = cache->Lookup("k3", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k3", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());
    ASSERT_NE(handle, nullptr);
    auto val3 = static_cast<TestItem*>(cache->Value(handle));
@@ -380,15 +369,13 @@ class CompressedSecondaryCacheTest : public testing::Test {
    cache->Release(handle);

    // Lookup an non-existent key.
-    handle = cache->Lookup("k0", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k0", &kHelper, this, Cache::Priority::LOW, true,
                           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.
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k1", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());
    ASSERT_NE(handle, nullptr);
    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
@@ -400,8 +387,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    // This Lookup should erase k1 from the secondary cache and insert
    // it into primary cache; then k3 is demoted.
    // k2 and k3 are in secondary cache.
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k1", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());
    ASSERT_NE(handle, nullptr);
    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
@@ -409,8 +395,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    cache->Release(handle);

    // k2 is still in secondary cache.
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());
    ASSERT_NE(handle, nullptr);
    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 2);
@@ -418,8 +403,7 @@ class CompressedSecondaryCacheTest : public testing::Test {

    // Testing SetCapacity().
    ASSERT_OK(secondary_cache->SetCapacity(0));
-    handle = cache->Lookup("k3", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k3", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());
    ASSERT_EQ(handle, nullptr);

@@ -429,35 +413,30 @@ class CompressedSecondaryCacheTest : public testing::Test {
    ASSERT_EQ(capacity, 7000);
    auto item1_3 = new TestItem(str1.data(), str1.length());
    // After this Insert, primary cache contains k1.
-    ASSERT_OK(cache->Insert(
-        "k1", item1_3, &CompressedSecondaryCacheTest::helper_, str2.length()));
+    ASSERT_OK(cache->Insert("k1", item1_3, &kHelper, str2.length()));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 3);
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 4);

    auto item2_3 = 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_3, &CompressedSecondaryCacheTest::helper_, str1.length()));
+    ASSERT_OK(cache->Insert("k2", item2_3, &kHelper, str1.length()));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 4);

    auto item1_4 = new TestItem(str1.data(), str1.length());
    // After this Insert, primary cache contains k1 and secondary cache contains
    // k1's dummy item and k2's dummy item.
-    ASSERT_OK(cache->Insert(
-        "k1", item1_4, &CompressedSecondaryCacheTest::helper_, str2.length()));
+    ASSERT_OK(cache->Insert("k1", item1_4, &kHelper, str2.length()));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 5);

    auto item2_4 = new TestItem(str2.data(), str2.length());
    // After this Insert, primary cache contains k2 and secondary cache contains
    // k1's real item and k2's dummy item.
-    ASSERT_OK(cache->Insert(
-        "k2", item2_4, &CompressedSecondaryCacheTest::helper_, str2.length()));
+    ASSERT_OK(cache->Insert("k2", item2_4, &kHelper, str2.length()));
    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 5);
    // This Lookup should just insert a dummy handle in the primary cache
    // and the k1 is still in the secondary cache.
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true,
+    handle = cache->Lookup("k1", &kHelper, this, Cache::Priority::LOW, true,
                           stats.get());

    ASSERT_NE(handle, nullptr);
@@ -496,18 +475,13 @@ class CompressedSecondaryCacheTest : public testing::Test {
    Random rnd(301);
    std::string str1 = rnd.RandomString(1001);
    auto item1 = std::make_unique<TestItem>(str1.data(), str1.length());
-    ASSERT_NOK(cache->Insert("k1", item1.get(), nullptr, str1.length()));
-    ASSERT_OK(cache->Insert("k1", item1.get(),
-                            &CompressedSecondaryCacheTest::helper_,
-                            str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1.get(), &kHelper, str1.length()));
    item1.release();  // Appease clang-analyze "potential memory leak"

    Cache::Handle* handle;
-    handle = cache->Lookup("k2", nullptr, test_item_creator,
-                           Cache::Priority::LOW, true);
+    handle = cache->Lookup("k2", nullptr, this, Cache::Priority::LOW, true);
    ASSERT_EQ(handle, nullptr);
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, false);
+    handle = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, false);
    ASSERT_EQ(handle, nullptr);

    cache.reset();
@@ -543,29 +517,25 @@ class CompressedSecondaryCacheTest : public testing::Test {
    Random rnd(301);
    std::string str1 = rnd.RandomString(1001);
    auto item1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert("k1", item1,
-                            &CompressedSecondaryCacheTest::helper_fail_,
-                            str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1, &kHelperFail, str1.length()));

    std::string str2 = rnd.RandomString(1002);
    auto item2 = new TestItem(str2.data(), str2.length());
    // k1 should be demoted to the secondary cache.
-    ASSERT_OK(cache->Insert("k2", item2,
-                            &CompressedSecondaryCacheTest::helper_fail_,
-                            str2.length()));
+    ASSERT_OK(cache->Insert("k2", item2, &kHelperFail, str2.length()));

    Cache::Handle* handle;
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_fail_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle =
+        cache->Lookup("k2", &kHelperFail, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle, nullptr);
    cache->Release(handle);
    // This lookup should fail, since k1 demotion would have failed.
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_fail_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle =
+        cache->Lookup("k1", &kHelperFail, this, Cache::Priority::LOW, true);
    ASSERT_EQ(handle, nullptr);
    // Since k1 was not promoted, k2 should still be in cache.
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_fail_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle =
+        cache->Lookup("k2", &kHelperFail, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle, nullptr);
    cache->Release(handle);

@@ -602,28 +572,23 @@ class CompressedSecondaryCacheTest : public testing::Test {
    Random rnd(301);
    std::string str1 = rnd.RandomString(1001);
    auto item1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert("k1", item1, &CompressedSecondaryCacheTest::helper_,
-                            str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1, &kHelper, str1.length()));

    std::string str2 = rnd.RandomString(1002);
    auto item2 = new TestItem(str2.data(), str2.length());
    // k1 should be demoted to the secondary cache.
-    ASSERT_OK(cache->Insert("k2", item2, &CompressedSecondaryCacheTest::helper_,
-                            str2.length()));
+    ASSERT_OK(cache->Insert("k2", item2, &kHelper, str2.length()));

    Cache::Handle* handle;
    SetFailCreate(true);
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle, nullptr);
    cache->Release(handle);
    // This lookup should fail, since k1 creation would have failed
-    handle = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle = cache->Lookup("k1", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_EQ(handle, nullptr);
    // Since k1 didn't get promoted, k2 should still be in cache
-    handle = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                           test_item_creator, Cache::Priority::LOW, true);
+    handle = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle, nullptr);
    cache->Release(handle);

@@ -660,32 +625,27 @@ class CompressedSecondaryCacheTest : public testing::Test {
    Random rnd(301);
    std::string str1 = rnd.RandomString(1001);
    auto item1_1 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_1, &CompressedSecondaryCacheTest::helper_, str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1_1, &kHelper, str1.length()));

    std::string str2 = rnd.RandomString(1002);
    std::string str2_clone{str2};
    auto item2 = 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, &CompressedSecondaryCacheTest::helper_,
-                            str2.length()));
+    ASSERT_OK(cache->Insert("k2", item2, &kHelper, str2.length()));

    // After this Insert, primary cache contains k1 and secondary cache contains
    // k1's dummy item and k2's dummy item.
    auto item1_2 = new TestItem(str1.data(), str1.length());
-    ASSERT_OK(cache->Insert(
-        "k1", item1_2, &CompressedSecondaryCacheTest::helper_, str1.length()));
+    ASSERT_OK(cache->Insert("k1", item1_2, &kHelper, str1.length()));

    auto 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()));
+    ASSERT_OK(cache->Insert("k2", item2_2, &kHelper, str2.length()));

    Cache::Handle* handle2;
-    handle2 = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                            test_item_creator, Cache::Priority::LOW, true);
+    handle2 = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle2, nullptr);
    cache->Release(handle2);

@@ -693,14 +653,12 @@ class CompressedSecondaryCacheTest : public testing::Test {
    // strict_capacity_limit is true, but the lookup should still succeed.
    // A k1's dummy item is inserted into primary cache.
    Cache::Handle* handle1;
-    handle1 = cache->Lookup("k1", &CompressedSecondaryCacheTest::helper_,
-                            test_item_creator, Cache::Priority::LOW, true);
+    handle1 = cache->Lookup("k1", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle1, nullptr);
    cache->Release(handle1);

    // Since k1 didn't get inserted, k2 should still be in cache
-    handle2 = cache->Lookup("k2", &CompressedSecondaryCacheTest::helper_,
-                            test_item_creator, Cache::Priority::LOW, true);
+    handle2 = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true);
    ASSERT_NE(handle2, nullptr);
    cache->Release(handle2);

@@ -741,7 +699,7 @@ class CompressedSecondaryCacheTest : public testing::Test {
    current_chunk = current_chunk->next;
    ASSERT_EQ(current_chunk->size, 98);

-    sec_cache->GetDeletionCallback(true)("dummy", chunks_head);
+    sec_cache->GetHelper(true)->del_cb(chunks_head, /*alloc*/ nullptr);
  }

  void MergeChunksIntoValueTest() {
@@ -822,23 +780,13 @@ class CompressedSecondaryCacheTest : public testing::Test {
    std::string value_str{value.get(), charge};
    ASSERT_EQ(strcmp(value_str.data(), str.data()), 0);

-    sec_cache->GetDeletionCallback(true)("dummy", chunks_head);
+    sec_cache->GetHelper(true)->del_cb(chunks_head, /*alloc*/ nullptr);
  }

 private:
  bool fail_create_;
 };

-Cache::CacheItemHelper CompressedSecondaryCacheTest::helper_(
-    CompressedSecondaryCacheTest::SizeCallback,
-    CompressedSecondaryCacheTest::SaveToCallback,
-    CompressedSecondaryCacheTest::DeletionCallback);
-
-Cache::CacheItemHelper CompressedSecondaryCacheTest::helper_fail_(
-    CompressedSecondaryCacheTest::SizeCallback,
-    CompressedSecondaryCacheTest::SaveToCallbackFail,
-    CompressedSecondaryCacheTest::DeletionCallback);
-
 class CompressedSecCacheTestWithCompressAndAllocatorParam
    : public CompressedSecondaryCacheTest,
      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
@@ -869,7 +817,6 @@ class CompressedSecondaryCacheTestWithCompressionParam
  bool sec_cache_is_compressed_;
 };

-#ifndef ROCKSDB_LITE

 TEST_P(CompressedSecondaryCacheTestWithCompressionParam, BasicTestFromString) {
  std::shared_ptr<SecondaryCache> sec_cache{nullptr};
@@ -934,7 +881,6 @@ TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
  BasicTestHelper(sec_cache, sec_cache_is_compressed_);
 }

-#endif  // ROCKSDB_LITE

 TEST_P(CompressedSecondaryCacheTestWithCompressionParam, FailsTest) {
  FailsTest(sec_cache_is_compressed_);
@@ -1,580 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "cache/fast_lru_cache.h"
-
-#include <cassert>
-#include <cstdint>
-#include <cstdio>
-#include <functional>
-
-#include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
-#include "port/lang.h"
-#include "util/distributed_mutex.h"
-#include "util/hash.h"
-#include "util/math.h"
-#include "util/random.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace fast_lru_cache {
-
-LRUHandleTable::LRUHandleTable(int hash_bits)
-    : length_bits_(hash_bits),
-      length_bits_mask_((uint32_t{1} << length_bits_) - 1),
-      occupancy_(0),
-      occupancy_limit_(static_cast<uint32_t>((uint32_t{1} << length_bits_) *
-                                             kStrictLoadFactor)),
-      array_(new LRUHandle[size_t{1} << length_bits_]) {
-  assert(hash_bits <= 32);
-}
-
-LRUHandleTable::~LRUHandleTable() {
-  ApplyToEntriesRange([](LRUHandle* h) { h->FreeData(); }, 0, GetTableSize());
-}
-
-LRUHandle* LRUHandleTable::Lookup(const Slice& key, uint32_t hash) {
-  int probe = 0;
-  int slot = FindVisibleElement(key, hash, probe, 0);
-  return (slot == -1) ? nullptr : &array_[slot];
-}
-
-LRUHandle* LRUHandleTable::Insert(LRUHandle* h, LRUHandle** old) {
-  int probe = 0;
-  int slot = FindVisibleElementOrAvailableSlot(h->key(), h->hash, probe,
-                                               1 /*displacement*/);
-  *old = nullptr;
-  if (slot == -1) {
-    // TODO(Guido) Don't we need to roll back displacements here?
-    return nullptr;
-  }
-
-  if (array_[slot].IsEmpty() || array_[slot].IsTombstone()) {
-    bool empty = array_[slot].IsEmpty();
-    Assign(slot, h);
-    LRUHandle* new_entry = &array_[slot];
-    if (empty) {
-      // This used to be an empty slot.
-      return new_entry;
-    }
-    // It used to be a tombstone, so there may already be a copy of the
-    // key in the table.
-    slot = FindVisibleElement(h->key(), h->hash, probe, 0 /*displacement*/);
-    if (slot == -1) {
-      // No existing copy of the key.
-      return new_entry;
-    }
-    *old = &array_[slot];
-    return new_entry;
-  } else {
-    // There is an existing copy of the key.
-    *old = &array_[slot];
-    // Find an available slot for the new element.
-    array_[slot].displacements++;
-    slot = FindAvailableSlot(h->key(), probe, 1 /*displacement*/);
-    if (slot == -1) {
-      // No available slots. Roll back displacements.
-      probe = 0;
-      slot = FindVisibleElement(h->key(), h->hash, probe, -1);
-      array_[slot].displacements--;
-      FindAvailableSlot(h->key(), probe, -1);
-      return nullptr;
-    }
-    Assign(slot, h);
-    return &array_[slot];
-  }
-}
-
-void LRUHandleTable::Remove(LRUHandle* h) {
-  assert(h->next == nullptr &&
-         h->prev == nullptr);  // Already off the LRU list.
-  int probe = 0;
-  FindSlot(
-      h->key(), [&h](LRUHandle* e) { return e == h; }, probe,
-      -1 /*displacement*/);
-  h->SetIsVisible(false);
-  h->SetIsElement(false);
-  occupancy_--;
-}
-
-void LRUHandleTable::Assign(int slot, LRUHandle* h) {
-  LRUHandle* dst = &array_[slot];
-  uint32_t disp = dst->displacements;
-  *dst = *h;
-  dst->displacements = disp;
-  dst->SetIsVisible(true);
-  dst->SetIsElement(true);
-  occupancy_++;
-}
-
-void LRUHandleTable::Exclude(LRUHandle* h) { h->SetIsVisible(false); }
-
-int LRUHandleTable::FindVisibleElement(const Slice& key, uint32_t hash,
-                                       int& probe, int displacement) {
-  return FindSlot(
-      key,
-      [&](LRUHandle* h) { return h->Matches(key, hash) && h->IsVisible(); },
-      probe, displacement);
-}
-
-int LRUHandleTable::FindAvailableSlot(const Slice& key, int& probe,
-                                      int displacement) {
-  return FindSlot(
-      key, [](LRUHandle* h) { return h->IsEmpty() || h->IsTombstone(); }, probe,
-      displacement);
-}
-
-int LRUHandleTable::FindVisibleElementOrAvailableSlot(const Slice& key,
-                                                      uint32_t hash, int& probe,
-                                                      int displacement) {
-  return FindSlot(
-      key,
-      [&](LRUHandle* h) {
-        return h->IsEmpty() || h->IsTombstone() ||
-               (h->Matches(key, hash) && h->IsVisible());
-      },
-      probe, displacement);
-}
-
-inline int LRUHandleTable::FindSlot(const Slice& key,
-                                    std::function<bool(LRUHandle*)> cond,
-                                    int& probe, int displacement) {
-  uint32_t base = ModTableSize(Hash(key.data(), key.size(), kProbingSeed1));
-  uint32_t increment =
-      ModTableSize((Hash(key.data(), key.size(), kProbingSeed2) << 1) | 1);
-  uint32_t current = ModTableSize(base + probe * increment);
-  while (true) {
-    LRUHandle* h = &array_[current];
-    probe++;
-    if (current == base && probe > 1) {
-      // We looped back.
-      return -1;
-    }
-    if (cond(h)) {
-      return current;
-    }
-    if (h->IsEmpty()) {
-      // We check emptyness after the condition, because
-      // the condition may be emptyness.
-      return -1;
-    }
-    h->displacements += displacement;
-    current = ModTableSize(current + increment);
-  }
-}
-
-LRUCacheShard::LRUCacheShard(size_t capacity, size_t estimated_value_size,
-                             bool strict_capacity_limit,
-                             CacheMetadataChargePolicy metadata_charge_policy)
-    : CacheShardBase(metadata_charge_policy),
-      capacity_(capacity),
-      strict_capacity_limit_(strict_capacity_limit),
-      table_(
-          CalcHashBits(capacity, estimated_value_size, metadata_charge_policy)),
-      usage_(0),
-      lru_usage_(0) {
-  // Make empty circular linked list.
-  lru_.next = &lru_;
-  lru_.prev = &lru_;
-  lru_low_pri_ = &lru_;
-}
-
-void LRUCacheShard::EraseUnRefEntries() {
-  autovector<LRUHandle> last_reference_list;
-  {
-    DMutexLock l(mutex_);
-    while (lru_.next != &lru_) {
-      LRUHandle* old = lru_.next;
-      // LRU list contains only elements which can be evicted.
-      assert(old->IsVisible() && !old->HasRefs());
-      LRU_Remove(old);
-      table_.Remove(old);
-      assert(usage_ >= old->total_charge);
-      usage_ -= old->total_charge;
-      last_reference_list.push_back(*old);
-    }
-  }
-
-  // Free the entries here outside of mutex for performance reasons.
-  for (auto& h : last_reference_list) {
-    h.FreeData();
-  }
-}
-
-void LRUCacheShard::ApplyToSomeEntries(
-    const std::function<void(const Slice& key, void* value, size_t charge,
-                             DeleterFn deleter)>& callback,
-    size_t average_entries_per_lock, size_t* state) {
-  // The state is essentially going to be the starting hash, which works
-  // nicely even if we resize between calls because we use upper-most
-  // hash bits for table indexes.
-  DMutexLock l(mutex_);
-  size_t length_bits = table_.GetLengthBits();
-  size_t length = table_.GetTableSize();
-
-  assert(average_entries_per_lock > 0);
-  // Assuming we are called with same average_entries_per_lock repeatedly,
-  // this simplifies some logic (index_end will not overflow).
-  assert(average_entries_per_lock < length || *state == 0);
-
-  size_t index_begin = *state >> (sizeof(size_t) * 8u - length_bits);
-  size_t index_end = index_begin + average_entries_per_lock;
-  if (index_end >= length) {
-    // Going to end
-    index_end = length;
-    *state = SIZE_MAX;
-  } else {
-    *state = index_end << (sizeof(size_t) * 8u - length_bits);
-  }
-
-  table_.ApplyToEntriesRange(
-      [callback,
-       metadata_charge_policy = metadata_charge_policy_](LRUHandle* h) {
-        callback(h->key(), h->value, h->GetCharge(metadata_charge_policy),
-                 h->deleter);
-      },
-      index_begin, index_end);
-}
-
-void LRUCacheShard::LRU_Remove(LRUHandle* h) {
-  assert(h->next != nullptr);
-  assert(h->prev != nullptr);
-  h->next->prev = h->prev;
-  h->prev->next = h->next;
-  h->prev = h->next = nullptr;
-  assert(lru_usage_ >= h->total_charge);
-  lru_usage_ -= h->total_charge;
-}
-
-void LRUCacheShard::LRU_Insert(LRUHandle* h) {
-  assert(h->next == nullptr);
-  assert(h->prev == nullptr);
-  // Insert h to head of LRU list.
-  h->next = &lru_;
-  h->prev = lru_.prev;
-  h->prev->next = h;
-  h->next->prev = h;
-  lru_usage_ += h->total_charge;
-}
-
-void LRUCacheShard::EvictFromLRU(size_t charge,
-                                 autovector<LRUHandle>* deleted) {
-  while ((usage_ + charge) > capacity_ && lru_.next != &lru_) {
-    LRUHandle* old = lru_.next;
-    // LRU list contains only elements which can be evicted.
-    assert(old->IsVisible() && !old->HasRefs());
-    LRU_Remove(old);
-    table_.Remove(old);
-    assert(usage_ >= old->total_charge);
-    usage_ -= old->total_charge;
-    deleted->push_back(*old);
-  }
-}
-
-size_t LRUCacheShard::CalcEstimatedHandleCharge(
-    size_t estimated_value_size,
-    CacheMetadataChargePolicy metadata_charge_policy) {
-  LRUHandle h;
-  h.CalcTotalCharge(estimated_value_size, metadata_charge_policy);
-  return h.total_charge;
-}
-
-int LRUCacheShard::CalcHashBits(
-    size_t capacity, size_t estimated_value_size,
-    CacheMetadataChargePolicy metadata_charge_policy) {
-  size_t handle_charge =
-      CalcEstimatedHandleCharge(estimated_value_size, metadata_charge_policy);
-  assert(handle_charge > 0);
-  uint32_t num_entries =
-      static_cast<uint32_t>(capacity / (kLoadFactor * handle_charge)) + 1;
-  assert(num_entries <= uint32_t{1} << 31);
-  return FloorLog2((num_entries << 1) - 1);
-}
-
-void LRUCacheShard::SetCapacity(size_t capacity) {
-  autovector<LRUHandle> last_reference_list;
-  {
-    DMutexLock l(mutex_);
-    if (capacity > capacity_) {
-      assert(false);  // Not supported.
-    }
-    capacity_ = capacity;
-    EvictFromLRU(0, &last_reference_list);
-  }
-
-  // Free the entries here outside of mutex for performance reasons.
-  for (auto& h : last_reference_list) {
-    h.FreeData();
-  }
-}
-
-void LRUCacheShard::SetStrictCapacityLimit(bool strict_capacity_limit) {
-  DMutexLock l(mutex_);
-  strict_capacity_limit_ = strict_capacity_limit;
-}
-
-Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
-                             size_t charge, Cache::DeleterFn deleter,
-                             LRUHandle** handle, Cache::Priority /*priority*/) {
-  if (key.size() != kCacheKeySize) {
-    return Status::NotSupported("FastLRUCache only supports key size " +
-                                std::to_string(kCacheKeySize) + "B");
-  }
-
-  LRUHandle tmp;
-  tmp.value = value;
-  tmp.deleter = deleter;
-  tmp.hash = hash;
-  tmp.CalcTotalCharge(charge, metadata_charge_policy_);
-  for (int i = 0; i < kCacheKeySize; i++) {
-    tmp.key_data[i] = key.data()[i];
-  }
-
-  Status s = Status::OK();
-  autovector<LRUHandle> last_reference_list;
-  {
-    DMutexLock l(mutex_);
-    assert(table_.GetOccupancy() <= table_.GetOccupancyLimit());
-
-    // Free the space following strict LRU policy until enough space
-    // is freed or the lru list is empty.
-    EvictFromLRU(tmp.total_charge, &last_reference_list);
-    if ((usage_ + tmp.total_charge > capacity_ &&
-         (strict_capacity_limit_ || handle == nullptr)) ||
-        table_.GetOccupancy() == table_.GetOccupancyLimit()) {
-      // There are two measures of capacity:
-      // - Space (or charge) capacity: The maximum possible sum of the charges
-      //    of the elements.
-      // - Table capacity: The number of slots in the hash table.
-      // These are incomparable, in the sense that one doesn't imply the other.
-      // Typically we will reach space capacity before table capacity---
-      // if the user always inserts values with size equal to
-      // estimated_value_size, then at most a kLoadFactor fraction of slots
-      // will ever be occupied. But in some cases we may reach table capacity
-      // before space capacity---if the user initially claims a very large
-      // estimated_value_size but then inserts tiny values, more elements than
-      // initially estimated will be inserted.
-
-      // TODO(Guido) Some tests (at least two from cache_test, as well as the
-      // stress tests) currently assume the table capacity is unbounded.
-      if (handle == nullptr) {
-        // Don't insert the entry but still return ok, as if the entry inserted
-        // into cache and get evicted immediately.
-        last_reference_list.push_back(tmp);
-      } else {
-        if (table_.GetOccupancy() == table_.GetOccupancyLimit()) {
-          // TODO: Consider using a distinct status for this case, but usually
-          // it will be handled the same way as reaching charge capacity limit
-          s = Status::MemoryLimit(
-              "Insert failed because all slots in the hash table are full.");
-        } else {
-          s = Status::MemoryLimit(
-              "Insert failed because the total charge has exceeded the "
-              "capacity.");
-        }
-      }
-    } else {
-      // Insert into the cache. Note that the cache might get larger than its
-      // capacity if not enough space was freed up.
-      LRUHandle* old;
-      LRUHandle* h = table_.Insert(&tmp, &old);
-      assert(h != nullptr);  // We're below occupancy, so this insertion should
-                             // never fail.
-      usage_ += h->total_charge;
-      if (old != nullptr) {
-        s = Status::OkOverwritten();
-        assert(old->IsVisible());
-        table_.Exclude(old);
-        if (!old->HasRefs()) {
-          // old is on LRU because it's in cache and its reference count is 0.
-          LRU_Remove(old);
-          table_.Remove(old);
-          assert(usage_ >= old->total_charge);
-          usage_ -= old->total_charge;
-          last_reference_list.push_back(*old);
-        }
-      }
-      if (handle == nullptr) {
-        LRU_Insert(h);
-      } else {
-        // If caller already holds a ref, no need to take one here.
-        if (!h->HasRefs()) {
-          h->Ref();
-        }
-        *handle = h;
-      }
-    }
-  }
-
-  // Free the entries here outside of mutex for performance reasons.
-  for (auto& h : last_reference_list) {
-    h.FreeData();
-  }
-
-  return s;
-}
-
-LRUHandle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash) {
-  LRUHandle* h = nullptr;
-  {
-    DMutexLock l(mutex_);
-    h = table_.Lookup(key, hash);
-    if (h != nullptr) {
-      assert(h->IsVisible());
-      if (!h->HasRefs()) {
-        // The entry is in LRU since it's in hash and has no external
-        // references.
-        LRU_Remove(h);
-      }
-      h->Ref();
-    }
-  }
-  return h;
-}
-
-bool LRUCacheShard::Ref(LRUHandle* h) {
-  DMutexLock l(mutex_);
-  // To create another reference - entry must be already externally referenced.
-  assert(h->HasRefs());
-  h->Ref();
-  return true;
-}
-
-bool LRUCacheShard::Release(LRUHandle* h, bool erase_if_last_ref) {
-  if (h == nullptr) {
-    return false;
-  }
-  LRUHandle copy;
-  bool last_reference = false;
-  {
-    DMutexLock l(mutex_);
-    last_reference = h->Unref();
-    if (last_reference && h->IsVisible()) {
-      // The item is still in cache, and nobody else holds a reference to it.
-      if (usage_ > capacity_ || erase_if_last_ref) {
-        // The LRU list must be empty since the cache is full.
-        assert(lru_.next == &lru_ || erase_if_last_ref);
-        // Take this opportunity and remove the item.
-        table_.Remove(h);
-      } else {
-        // Put the item back on the LRU list, and don't free it.
-        LRU_Insert(h);
-        last_reference = false;
-      }
-    }
-    // If it was the last reference, then decrement the cache usage.
-    if (last_reference) {
-      assert(usage_ >= h->total_charge);
-      usage_ -= h->total_charge;
-      copy = *h;
-    }
-  }
-
-  // Free the entry here outside of mutex for performance reasons.
-  if (last_reference) {
-    copy.FreeData();
-  }
-  return last_reference;
-}
-
-void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
-  LRUHandle copy;
-  bool last_reference = false;
-  {
-    DMutexLock l(mutex_);
-    LRUHandle* h = table_.Lookup(key, hash);
-    if (h != nullptr) {
-      table_.Exclude(h);
-      if (!h->HasRefs()) {
-        // The entry is in LRU since it's in cache and has no external
-        // references.
-        LRU_Remove(h);
-        table_.Remove(h);
-        assert(usage_ >= h->total_charge);
-        usage_ -= h->total_charge;
-        last_reference = true;
-        copy = *h;
-      }
-    }
-  }
-  // Free the entry here outside of mutex for performance reasons.
-  // last_reference will only be true if e != nullptr.
-  if (last_reference) {
-    copy.FreeData();
-  }
-}
-
-size_t LRUCacheShard::GetUsage() const {
-  DMutexLock l(mutex_);
-  return usage_;
-}
-
-size_t LRUCacheShard::GetPinnedUsage() const {
-  DMutexLock l(mutex_);
-  assert(usage_ >= lru_usage_);
-  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();
-}
-
-LRUCache::LRUCache(size_t capacity, size_t estimated_value_size,
-                   int num_shard_bits, bool strict_capacity_limit,
-                   CacheMetadataChargePolicy metadata_charge_policy)
-    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
-                   nullptr /*allocator*/) {
-  assert(estimated_value_size > 0 ||
-         metadata_charge_policy != kDontChargeCacheMetadata);
-  size_t per_shard = GetPerShardCapacity();
-  InitShards([=](LRUCacheShard* cs) {
-    new (cs) LRUCacheShard(per_shard, estimated_value_size,
-                           strict_capacity_limit, metadata_charge_policy);
-  });
-}
-
-void* LRUCache::Value(Handle* handle) {
-  return reinterpret_cast<const LRUHandle*>(handle)->value;
-}
-
-size_t LRUCache::GetCharge(Handle* handle) const {
-  return reinterpret_cast<const LRUHandle*>(handle)->GetCharge(
-      GetShard(0).metadata_charge_policy_);
-}
-
-Cache::DeleterFn LRUCache::GetDeleter(Handle* handle) const {
-  auto h = reinterpret_cast<const LRUHandle*>(handle);
-  return h->deleter;
-}
-
-}  // namespace fast_lru_cache
-
-std::shared_ptr<Cache> NewFastLRUCache(
-    size_t capacity, size_t estimated_value_size, int num_shard_bits,
-    bool strict_capacity_limit,
-    CacheMetadataChargePolicy metadata_charge_policy) {
-  if (num_shard_bits >= 20) {
-    return nullptr;  // The cache cannot be sharded into too many fine pieces.
-  }
-  if (num_shard_bits < 0) {
-    num_shard_bits = GetDefaultCacheShardBits(capacity);
-  }
-  return std::make_shared<fast_lru_cache::LRUCache>(
-      capacity, estimated_value_size, num_shard_bits, strict_capacity_limit,
-      metadata_charge_policy);
-}
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -1,477 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-
-#include "cache/cache_key.h"
-#include "cache/sharded_cache.h"
-#include "port/lang.h"
-#include "port/malloc.h"
-#include "port/port.h"
-#include "rocksdb/secondary_cache.h"
-#include "util/autovector.h"
-#include "util/distributed_mutex.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace fast_lru_cache {
-
-// Forward declaration of friend class.
-class FastLRUCacheTest;
-
-// LRU cache implementation using an open-address hash table.
-//
-// Every slot in the hash table is an LRUHandle. Because handles can be
-// referenced externally, we can't discard them immediately once they are
-// deleted (via a delete or an LRU eviction) or replaced by a new version
-// (via an insert of the same key). The state of an element is defined by
-// the following two properties:
-// (R) Referenced: An element can be referenced externally (refs > 0), or not.
-//    Importantly, an element can be evicted if and only if it's not
-//    referenced. In particular, when an element becomes referenced, it's
-//    temporarily taken out of the LRU list until all references to it
-//    are dropped.
-// (V) Visible: An element can visible for lookups (IS_VISIBLE set), or not.
-//    Initially, every element is visible. An element that is not visible is
-//    called a ghost.
-// These properties induce 4 different states, with transitions defined as
-// follows:
-// - V --> not V: When a visible element is deleted or replaced by a new
-//    version.
-// - Not V --> V: This cannot happen. A ghost remains in that state until it's
-//    not referenced any more, at which point it's ready to be removed from the
-//    hash table. (A ghost simply waits to transition to the afterlife---it will
-//    never be visible again.)
-// - R --> not R: When all references to an element are dropped.
-// - Not R --> R: When an unreferenced element becomes referenced. This can only
-//    happen if the element is V, since references to an element can only be
-//    created when it's visible.
-//
-// Internally, the cache uses an open-addressed hash table to index the handles.
-// We use tombstone counters to keep track of displacements.
-// Because of the tombstones and the two possible visibility states of an
-// element, the table slots can be in 4 different states:
-// 1. Visible element (IS_ELEMENT set and IS_VISIBLE set): The slot contains a
-//    key-value element.
-// 2. Ghost element (IS_ELEMENT set and IS_VISIBLE unset): The slot contains an
-//    element that has been removed, but it's still referenced. It's invisible
-//    to lookups.
-// 3. Tombstone (IS_ELEMENT unset and displacements > 0): The slot contains a
-//    tombstone.
-// 4. Empty (IS_ELEMENT unset and displacements == 0): The slot is unused.
-//    A slot that is an element can further have IS_VISIBLE set or not.
-// When a ghost is removed from the table, it can either transition to being a
-// tombstone or an empty slot, depending on the number of displacements of the
-// slot. In any case, the slot becomes available. When a handle is inserted
-// into that slot, it becomes a visible element again.
-
-// The load factor p is a real number in (0, 1) such that at all
-// times at most a fraction p of all slots, without counting tombstones,
-// are occupied by elements. This means that the probability that a
-// random probe hits an empty slot is at most p, and thus at most 1/p probes
-// are required on average. For example, p = 70% implies that between 1 and 2
-// probes are needed on average (bear in mind that this reasoning doesn't
-// consider the effects of clustering over time).
-// Because the size of the hash table is always rounded up to the next
-// power of 2, p is really an upper bound on the actual load factor---the
-// actual load factor is anywhere between p/2 and p. This is a bit wasteful,
-// but bear in mind that slots only hold metadata, not actual values.
-// Since space cost is dominated by the values (the LSM blocks),
-// overprovisioning the table with metadata only increases the total cache space
-// usage by a tiny fraction.
-constexpr double kLoadFactor = 0.35;
-
-// The user can exceed kLoadFactor if the sizes of the inserted values don't
-// match estimated_value_size, or if strict_capacity_limit == false. To
-// avoid performance to plunge, we set a strict upper bound on the load factor.
-constexpr double kStrictLoadFactor = 0.7;
-
-// Arbitrary seeds.
-constexpr uint32_t kProbingSeed1 = 0xbc9f1d34;
-constexpr uint32_t kProbingSeed2 = 0x7a2bb9d5;
-
-// An experimental (under development!) alternative to LRUCache
-
-struct LRUHandle {
-  void* value;
-  Cache::DeleterFn deleter;
-  LRUHandle* next;
-  LRUHandle* prev;
-  size_t total_charge;  // TODO(opt): Only allow uint32_t?
-  // The hash of key(). Used for fast sharding and comparisons.
-  uint32_t hash;
-  // The number of external refs to this entry.
-  uint32_t refs;
-
-  enum Flags : uint8_t {
-    // Whether the handle is visible to Lookups.
-    IS_VISIBLE = (1 << 0),
-    // Whether the slot is in use by an element.
-    IS_ELEMENT = (1 << 1),
-  };
-  uint8_t flags;
-
-  // The number of elements that hash to this slot or a lower one,
-  // but wind up in a higher slot.
-  uint32_t displacements;
-
-  std::array<char, kCacheKeySize> key_data;
-
-  LRUHandle() {
-    value = nullptr;
-    deleter = nullptr;
-    next = nullptr;
-    prev = nullptr;
-    total_charge = 0;
-    hash = 0;
-    refs = 0;
-    flags = 0;
-    displacements = 0;
-    key_data.fill(0);
-  }
-
-  Slice key() const { return Slice(key_data.data(), kCacheKeySize); }
-
-  // For HandleImpl concept
-  uint32_t GetHash() const { return hash; }
-
-  // Increase the reference count by 1.
-  void Ref() { refs++; }
-
-  // Just reduce the reference count by 1. Return true if it was last reference.
-  bool Unref() {
-    assert(refs > 0);
-    refs--;
-    return refs == 0;
-  }
-
-  // Return true if there are external refs, false otherwise.
-  bool HasRefs() const { return refs > 0; }
-
-  bool IsVisible() const { return flags & IS_VISIBLE; }
-
-  void SetIsVisible(bool is_visible) {
-    if (is_visible) {
-      flags |= IS_VISIBLE;
-    } else {
-      flags &= ~IS_VISIBLE;
-    }
-  }
-
-  bool IsElement() const { return flags & IS_ELEMENT; }
-
-  void SetIsElement(bool is_element) {
-    if (is_element) {
-      flags |= IS_ELEMENT;
-    } else {
-      flags &= ~IS_ELEMENT;
-    }
-  }
-
-  void FreeData() {
-    assert(refs == 0);
-    if (deleter) {
-      (*deleter)(key(), value);
-    }
-  }
-
-  // Calculate the memory usage by metadata.
-  inline size_t CalcMetaCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) const {
-    if (metadata_charge_policy != kFullChargeCacheMetadata) {
-      return 0;
-    } else {
-      // #ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      //       return malloc_usable_size(
-      //           const_cast<void*>(static_cast<const void*>(this)));
-      // #else
-      // TODO(Guido) malloc_usable_size only works when we call it on
-      // a pointer allocated with malloc. Because our handles are all
-      // allocated in a single shot as an array, the user can't call
-      // CalcMetaCharge (or CalcTotalCharge or GetCharge) on a handle
-      // pointer returned by the cache. Moreover, malloc_usable_size
-      // expects a heap-allocated handle, but sometimes in our code we
-      // wish to pass a stack-allocated handle (this is only a performance
-      // concern).
-      // What is the right way to compute metadata charges with pre-allocated
-      // handles?
-      return sizeof(LRUHandle);
-      // #endif
-    }
-  }
-
-  inline void CalcTotalCharge(
-      size_t charge, CacheMetadataChargePolicy metadata_charge_policy) {
-    total_charge = charge + CalcMetaCharge(metadata_charge_policy);
-  }
-
-  inline size_t GetCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) const {
-    size_t meta_charge = CalcMetaCharge(metadata_charge_policy);
-    assert(total_charge >= meta_charge);
-    return total_charge - meta_charge;
-  }
-
-  inline bool IsEmpty() {
-    return !this->IsElement() && this->displacements == 0;
-  }
-
-  inline bool IsTombstone() {
-    return !this->IsElement() && this->displacements > 0;
-  }
-
-  inline bool Matches(const Slice& some_key, uint32_t some_hash) {
-    return this->IsElement() && this->hash == some_hash &&
-           this->key() == some_key;
-  }
-};
-
-
-class LRUHandleTable {
- public:
-  explicit LRUHandleTable(int hash_bits);
-  ~LRUHandleTable();
-
-  // Returns a pointer to a visible element matching the key/hash, or
-  // nullptr if not present.
-  LRUHandle* Lookup(const Slice& key, uint32_t hash);
-
-  // Inserts a copy of h into the hash table.
-  // Returns a pointer to the inserted handle, or nullptr if no slot
-  // available was found. If an existing visible element matching the
-  // key/hash is already present in the hash table, the argument old
-  // is set to pointe to it; otherwise, it's set to nullptr.
-  LRUHandle* Insert(LRUHandle* h, LRUHandle** old);
-
-  // Removes h from the hash table. The handle must already be off
-  // the LRU list.
-  void Remove(LRUHandle* h);
-
-  // Turns a visible element h into a ghost (i.e., not visible).
-  void Exclude(LRUHandle* h);
-
-  // Assigns a copy of h to the given slot.
-  void Assign(int slot, LRUHandle* h);
-
-  template <typename T>
-  void ApplyToEntriesRange(T func, size_t index_begin, size_t index_end) {
-    for (size_t i = index_begin; i < index_end; i++) {
-      LRUHandle* h = &array_[i];
-      if (h->IsVisible()) {
-        func(h);
-      }
-    }
-  }
-
-  uint32_t GetTableSize() const { return uint32_t{1} << length_bits_; }
-
-  int GetLengthBits() const { return length_bits_; }
-
-  uint32_t GetOccupancyLimit() const { return occupancy_limit_; }
-
-  uint32_t GetOccupancy() const { return occupancy_; }
-
-  // Returns x mod 2^{length_bits_}.
-  uint32_t ModTableSize(uint32_t x) { return x & length_bits_mask_; }
-
- private:
-  int FindVisibleElement(const Slice& key, uint32_t hash, int& probe,
-                         int displacement);
-
-  int FindAvailableSlot(const Slice& key, int& probe, int displacement);
-
-  int FindVisibleElementOrAvailableSlot(const Slice& key, uint32_t hash,
-                                        int& probe, int displacement);
-
-  // Returns the index of the first slot probed (hashing with
-  // the given key) with a handle e such that cond(e) is true.
-  // Otherwise, if no match is found, returns -1.
-  // For every handle e probed except the final slot, updates
-  // e->displacements += displacement.
-  // The argument probe is modified such that consecutive calls
-  // to FindSlot continue probing right after where the previous
-  // call left.
-  int FindSlot(const Slice& key, std::function<bool(LRUHandle*)> cond,
-               int& probe, int displacement);
-
-  // Number of hash bits used for table index.
-  // The size of the table is 1 << length_bits_.
-  int length_bits_;
-
-  const uint32_t length_bits_mask_;
-
-  // Number of elements in the table.
-  uint32_t occupancy_;
-
-  // Maximum number of elements the user can store in the table.
-  uint32_t occupancy_limit_;
-
-  std::unique_ptr<LRUHandle[]> array_;
-};
-
-// A single shard of sharded cache.
-class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
- public:
-  LRUCacheShard(size_t capacity, size_t estimated_value_size,
-                bool strict_capacity_limit,
-                CacheMetadataChargePolicy metadata_charge_policy);
-
-  // For CacheShard concept
-  using HandleImpl = LRUHandle;
-
-  // Keep 32-bit hashing for now (FIXME: upgrade to 64-bit)
-  using HashVal = uint32_t;
-  using HashCref = uint32_t;
-  static inline HashVal ComputeHash(const Slice& key) {
-    return Lower32of64(GetSliceNPHash64(key));
-  }
-  static inline uint32_t HashPieceForSharding(HashCref hash) { return hash; }
-
-  // Separate from constructor so caller can easily make an array of LRUCache
-  // if current usage is more than new capacity, the function will attempt to
-  // free the needed space.
-  void SetCapacity(size_t capacity);
-
-  // Set the flag to reject insertion if cache if full.
-  void SetStrictCapacityLimit(bool strict_capacity_limit);
-
-  // Like Cache methods, but with an extra "hash" parameter.
-  // Insert an item into the hash table and, if handle is null, insert into
-  // the LRU list. Older items are evicted as necessary. If the cache is full
-  // and free_handle_on_fail is true, the item is deleted and handle is set to
-  // nullptr.
-  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
-                Cache::DeleterFn deleter, LRUHandle** handle,
-                Cache::Priority priority);
-
-  Status Insert(const Slice& key, uint32_t hash, void* value,
-                const Cache::CacheItemHelper* helper, size_t charge,
-                LRUHandle** handle, Cache::Priority priority) {
-    return Insert(key, hash, value, charge, helper->del_cb, handle, priority);
-  }
-
-  LRUHandle* Lookup(const Slice& key, uint32_t hash,
-                    const Cache::CacheItemHelper* /*helper*/,
-                    const Cache::CreateCallback& /*create_cb*/,
-                    Cache::Priority /*priority*/, bool /*wait*/,
-                    Statistics* /*stats*/) {
-    return Lookup(key, hash);
-  }
-  LRUHandle* Lookup(const Slice& key, uint32_t hash);
-
-  bool Release(LRUHandle* handle, bool /*useful*/, bool erase_if_last_ref) {
-    return Release(handle, erase_if_last_ref);
-  }
-  bool IsReady(LRUHandle* /*handle*/) { return true; }
-  void Wait(LRUHandle* /*handle*/) {}
-
-  bool Ref(LRUHandle* handle);
-  bool Release(LRUHandle* handle, bool erase_if_last_ref = false);
-  void Erase(const Slice& key, uint32_t hash);
-
-  size_t GetUsage() const;
-  size_t GetPinnedUsage() const;
-  size_t GetOccupancyCount() const;
-  size_t GetTableAddressCount() const;
-
-  void ApplyToSomeEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
-      size_t average_entries_per_lock, size_t* state);
-
-  void EraseUnRefEntries();
-
- private:
-  friend class LRUCache;
-  friend class FastLRUCacheTest;
-
-  void LRU_Remove(LRUHandle* e);
-  void LRU_Insert(LRUHandle* e);
-
-  // Free some space following strict LRU policy until enough space
-  // to hold (usage_ + charge) is freed or the LRU list is empty
-  // This function is not thread safe - it needs to be executed while
-  // holding the mutex_.
-  void EvictFromLRU(size_t charge, autovector<LRUHandle>* deleted);
-
-  // Returns the charge of a single handle.
-  static size_t CalcEstimatedHandleCharge(
-      size_t estimated_value_size,
-      CacheMetadataChargePolicy metadata_charge_policy);
-
-  // Returns the number of bits used to hash an element in the hash
-  // table.
-  static int CalcHashBits(size_t capacity, size_t estimated_value_size,
-                          CacheMetadataChargePolicy metadata_charge_policy);
-
-  // Initialized before use.
-  size_t capacity_;
-
-  // Whether to reject insertion if cache reaches its full capacity.
-  bool strict_capacity_limit_;
-
-  // 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
-  LRUHandle lru_;
-
-  // Pointer to head of low-pri pool in LRU list.
-  LRUHandle* lru_low_pri_;
-
-  // ------------^^^^^^^^^^^^^-----------
-  // Not frequently modified data members
-  // ------------------------------------
-  //
-  // We separate data members that are updated frequently from the ones that
-  // are not frequently updated so that they don't share the same cache line
-  // which will lead into false cache sharing
-  //
-  // ------------------------------------
-  // Frequently modified data members
-  // ------------vvvvvvvvvvvvv-----------
-  LRUHandleTable table_;
-
-  // Memory size for entries residing in the cache.
-  size_t usage_;
-
-  // Memory size for entries residing only in the LRU list.
-  size_t lru_usage_;
-
-  // mutex_ protects the following state.
-  // We don't count mutex_ as the cache's internal state so semantically we
-  // don't mind mutex_ invoking the non-const actions.
-  mutable DMutex mutex_;
-};
-
-class LRUCache
-#ifdef NDEBUG
-    final
-#endif
-    : public ShardedCache<LRUCacheShard> {
- public:
-  LRUCache(size_t capacity, size_t estimated_value_size, int num_shard_bits,
-           bool strict_capacity_limit,
-           CacheMetadataChargePolicy metadata_charge_policy =
-               kDontChargeCacheMetadata);
-  const char* Name() const override { return "LRUCache"; }
-  void* Value(Handle* handle) override;
-  size_t GetCharge(Handle* handle) const override;
-  DeleterFn GetDeleter(Handle* handle) const override;
-};
-}  // namespace fast_lru_cache
-
-std::shared_ptr<Cache> NewFastLRUCache(
-    size_t capacity, size_t estimated_value_size, int num_shard_bits,
-    bool strict_capacity_limit,
-    CacheMetadataChargePolicy metadata_charge_policy);
-
-}  // namespace ROCKSDB_NAMESPACE
@@ -22,20 +22,28 @@
 namespace ROCKSDB_NAMESPACE {
 namespace lru_cache {

+namespace {
 // A distinct pointer value for marking "dummy" cache entries
-void* const kDummyValueMarker = const_cast<char*>("kDummyValueMarker");
+struct DummyValue {
+  char val[12] = "kDummyValue";
+};
+DummyValue kDummyValue{};
+}  // namespace

-LRUHandleTable::LRUHandleTable(int max_upper_hash_bits)
+LRUHandleTable::LRUHandleTable(int max_upper_hash_bits,
+                               MemoryAllocator* allocator)
    : length_bits_(/* historical starting size*/ 4),
      list_(new LRUHandle* [size_t{1} << length_bits_] {}),
      elems_(0),
-      max_length_bits_(max_upper_hash_bits) {}
+      max_length_bits_(max_upper_hash_bits),
+      allocator_(allocator) {}

 LRUHandleTable::~LRUHandleTable() {
+  auto alloc = allocator_;
  ApplyToEntriesRange(
-      [](LRUHandle* h) {
+      [alloc](LRUHandle* h) {
        if (!h->HasRefs()) {
-          h->Free();
+          h->Free(alloc);
        }
      },
      0, size_t{1} << length_bits_);
@@ -118,6 +126,7 @@ LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
                             double low_pri_pool_ratio, bool use_adaptive_mutex,
                             CacheMetadataChargePolicy metadata_charge_policy,
                             int max_upper_hash_bits,
+                             MemoryAllocator* allocator,
                             SecondaryCache* secondary_cache)
    : CacheShardBase(metadata_charge_policy),
      capacity_(0),
@@ -128,7 +137,7 @@ LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
      high_pri_pool_capacity_(0),
      low_pri_pool_ratio_(low_pri_pool_ratio),
      low_pri_pool_capacity_(0),
-      table_(max_upper_hash_bits),
+      table_(max_upper_hash_bits, allocator),
      usage_(0),
      lru_usage_(0),
      mutex_(use_adaptive_mutex),
@@ -159,13 +168,14 @@ void LRUCacheShard::EraseUnRefEntries() {
  }

  for (auto entry : last_reference_list) {
-    entry->Free();
+    entry->Free(table_.GetAllocator());
  }
 }

 void LRUCacheShard::ApplyToSomeEntries(
-    const std::function<void(const Slice& key, void* value, size_t charge,
-                             DeleterFn deleter)>& callback,
+    const std::function<void(const Slice& key, Cache::ObjectPtr value,
+                             size_t charge,
+                             const Cache::CacheItemHelper* helper)>& callback,
    size_t average_entries_per_lock, size_t* state) {
  // The state is essentially going to be the starting hash, which works
  // nicely even if we resize between calls because we use upper-most
@@ -192,11 +202,8 @@ void LRUCacheShard::ApplyToSomeEntries(
  table_.ApplyToEntriesRange(
      [callback,
       metadata_charge_policy = metadata_charge_policy_](LRUHandle* h) {
-        DeleterFn deleter = h->IsSecondaryCacheCompatible()
-                                ? h->info_.helper->del_cb
-                                : h->info_.deleter;
        callback(h->key(), h->value, h->GetCharge(metadata_charge_policy),
-                 deleter);
+                 h->helper);
      },
      index_begin, index_end);
 }
@@ -339,11 +346,11 @@ void LRUCacheShard::TryInsertIntoSecondaryCache(
  for (auto entry : evicted_handles) {
    if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
        !entry->IsInSecondaryCache()) {
-      secondary_cache_->Insert(entry->key(), entry->value, entry->info_.helper)
+      secondary_cache_->Insert(entry->key(), entry->value, entry->helper)
          .PermitUncheckedError();
    }
    // Free the entries here outside of mutex for performance reasons.
-    entry->Free();
+    entry->Free(table_.GetAllocator());
  }
 }

@@ -464,7 +471,7 @@ void LRUCacheShard::Promote(LRUHandle* e) {
      TryInsertIntoSecondaryCache(last_reference_list);
      if (free_standalone_handle) {
        e->Unref();
-        e->Free();
+        e->Free(table_.GetAllocator());
        e = nullptr;
      } else {
        PERF_COUNTER_ADD(block_cache_standalone_handle_count, 1);
@@ -476,9 +483,9 @@ void LRUCacheShard::Promote(LRUHandle* e) {
      // rare case that one exists
      Cache::Priority priority =
          e->IsHighPri() ? Cache::Priority::HIGH : Cache::Priority::LOW;
-      s = Insert(e->key(), e->hash, kDummyValueMarker, /*charge=*/0,
-                 /*deleter=*/nullptr, /*helper=*/nullptr, /*handle=*/nullptr,
-                 priority);
+      s = Insert(e->key(), e->hash, &kDummyValue, &kNoopCacheItemHelper,
+                 /*charge=*/0,
+                 /*handle=*/nullptr, priority);
    } else {
      e->SetInCache(true);
      LRUHandle* handle = e;
@@ -508,7 +515,7 @@ void LRUCacheShard::Promote(LRUHandle* e) {

 LRUHandle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash,
                                 const Cache::CacheItemHelper* helper,
-                                 const Cache::CreateCallback& create_cb,
+                                 Cache::CreateContext* create_context,
                                 Cache::Priority priority, bool wait,
                                 Statistics* stats) {
  LRUHandle* e = nullptr;
@@ -518,7 +525,7 @@ LRUHandle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash,
    e = table_.Lookup(key, hash);
    if (e != nullptr) {
      assert(e->InCache());
-      if (e->value == kDummyValueMarker) {
+      if (e->value == &kDummyValue) {
        // 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
@@ -547,24 +554,17 @@ LRUHandle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash,
  // 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 (!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);
+  if (!e && secondary_cache_ && helper && helper->create_cb) {
    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, helper, create_context, wait,
+                                 found_dummy_entry, is_in_sec_cache);
    if (secondary_handle != nullptr) {
      e = static_cast<LRUHandle*>(malloc(sizeof(LRUHandle) - 1 + key.size()));

      e->m_flags = 0;
      e->im_flags = 0;
-      e->SetSecondaryCacheCompatible(true);
-      e->info_.helper = helper;
+      e->helper = helper;
      e->key_length = key.size();
      e->hash = hash;
      e->refs = 0;
@@ -585,7 +585,7 @@ LRUHandle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash,
          if (!e->value) {
            // The secondary cache returned a handle, but the lookup failed.
            e->Unref();
-            e->Free();
+            e->Free(table_.GetAllocator());
            e = nullptr;
          } else {
            PERF_COUNTER_ADD(secondary_cache_hit_count, 1);
@@ -669,16 +669,18 @@ bool LRUCacheShard::Release(LRUHandle* e, bool /*useful*/,

  // Free the entry here outside of mutex for performance reasons.
  if (last_reference) {
-    e->Free();
+    e->Free(table_.GetAllocator());
  }
  return last_reference;
 }

-Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
-                             size_t charge,
-                             void (*deleter)(const Slice& key, void* value),
+Status LRUCacheShard::Insert(const Slice& key, uint32_t hash,
+                             Cache::ObjectPtr value,
                             const Cache::CacheItemHelper* helper,
-                             LRUHandle** handle, Cache::Priority priority) {
+                             size_t charge, LRUHandle** handle,
+                             Cache::Priority priority) {
+  assert(helper);
+
  // 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.
@@ -688,17 +690,7 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  e->value = value;
  e->m_flags = 0;
  e->im_flags = 0;
-  if (helper) {
-    // Use only one of the two parameters
-    assert(deleter == nullptr);
-    // value == nullptr is reserved for indicating failure for when secondary
-    // cache compatible
-    assert(value != nullptr);
-    e->SetSecondaryCacheCompatible(true);
-    e->info_.helper = helper;
-  } else {
-    e->info_.deleter = deleter;
-  }
+  e->helper = helper;
  e->key_length = key.size();
  e->hash = hash;
  e->refs = 0;
@@ -708,6 +700,10 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  memcpy(e->key_data, key.data(), key.size());
  e->CalcTotalCharge(charge, metadata_charge_policy_);

+  // value == nullptr is reserved for indicating failure for when secondary
+  // cache compatible
+  assert(!(e->IsSecondaryCacheCompatible() && value == nullptr));
+
  return InsertItem(e, handle, /* free_handle_on_fail */ true);
 }

@@ -733,7 +729,7 @@ void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
  // Free the entry here outside of mutex for performance reasons.
  // last_reference will only be true if e != nullptr.
  if (last_reference) {
-    e->Free();
+    e->Free(table_.GetAllocator());
  }
 }

@@ -793,18 +789,19 @@ LRUCache::LRUCache(size_t capacity, int num_shard_bits,
      secondary_cache_(std::move(_secondary_cache)) {
  size_t per_shard = GetPerShardCapacity();
  SecondaryCache* secondary_cache = secondary_cache_.get();
+  MemoryAllocator* alloc = memory_allocator();
  InitShards([=](LRUCacheShard* cs) {
    new (cs) LRUCacheShard(
        per_shard, strict_capacity_limit, high_pri_pool_ratio,
        low_pri_pool_ratio, use_adaptive_mutex, metadata_charge_policy,
-        /* max_upper_hash_bits */ 32 - num_shard_bits, secondary_cache);
+        /* max_upper_hash_bits */ 32 - num_shard_bits, alloc, secondary_cache);
  });
 }

-void* LRUCache::Value(Handle* handle) {
+Cache::ObjectPtr LRUCache::Value(Handle* handle) {
  auto h = reinterpret_cast<const LRUHandle*>(handle);
  assert(!h->IsPending() || h->value == nullptr);
-  assert(h->value != kDummyValueMarker);
+  assert(h->value != &kDummyValue);
  return h->value;
 }

@@ -813,13 +810,10 @@ size_t LRUCache::GetCharge(Handle* handle) const {
      GetShard(0).metadata_charge_policy_);
 }

-Cache::DeleterFn LRUCache::GetDeleter(Handle* handle) const {
+const Cache::CacheItemHelper* LRUCache::GetCacheItemHelper(
+    Handle* handle) const {
  auto h = reinterpret_cast<const LRUHandle*>(handle);
-  if (h->IsSecondaryCacheCompatible()) {
-    return h->info_.helper->del_cb;
-  } else {
-    return h->info_.deleter;
-  }
+  return h->helper;
 }

 size_t LRUCache::TEST_GetLRUSize() {
@@ -13,6 +13,7 @@

 #include "cache/sharded_cache.h"
 #include "port/lang.h"
+#include "port/likely.h"
 #include "port/malloc.h"
 #include "port/port.h"
 #include "rocksdb/secondary_cache.h"
@@ -48,13 +49,8 @@ namespace lru_cache {
 // While refs > 0, public properties like value and deleter must not change.

 struct LRUHandle {
-  void* value;
-  union Info {
-    Info() {}
-    ~Info() {}
-    Cache::DeleterFn deleter;
-    const Cache::CacheItemHelper* helper;
-  } info_;
+  Cache::ObjectPtr value;
+  const Cache::CacheItemHelper* helper;
  // An entry is not added to the LRUHandleTable until the secondary cache
  // lookup is complete, so its safe to have this union.
  union {
@@ -93,14 +89,12 @@ struct LRUHandle {
    IM_IS_HIGH_PRI = (1 << 0),
    // Whether this entry is low priority entry.
    IM_IS_LOW_PRI = (1 << 1),
-    // Can this be inserted into the secondary cache.
-    IM_IS_SECONDARY_CACHE_COMPATIBLE = (1 << 2),
    // Is the handle still being read from a lower tier.
-    IM_IS_PENDING = (1 << 3),
+    IM_IS_PENDING = (1 << 2),
    // Whether this handle is still in a lower tier
-    IM_IS_IN_SECONDARY_CACHE = (1 << 4),
+    IM_IS_IN_SECONDARY_CACHE = (1 << 3),
    // Marks result handles that should not be inserted into cache
-    IM_IS_STANDALONE = (1 << 5),
+    IM_IS_STANDALONE = (1 << 4),
  };

  // Beginning of the key (MUST BE THE LAST FIELD IN THIS STRUCT!)
@@ -130,9 +124,7 @@ struct LRUHandle {
  bool IsLowPri() const { return im_flags & IM_IS_LOW_PRI; }
  bool InLowPriPool() const { return m_flags & M_IN_LOW_PRI_POOL; }
  bool HasHit() const { return m_flags & M_HAS_HIT; }
-  bool IsSecondaryCacheCompatible() const {
-    return im_flags & IM_IS_SECONDARY_CACHE_COMPATIBLE;
-  }
+  bool IsSecondaryCacheCompatible() const { return helper->size_cb != nullptr; }
  bool IsPending() const { return im_flags & IM_IS_PENDING; }
  bool IsInSecondaryCache() const {
    return im_flags & IM_IS_IN_SECONDARY_CACHE;
@@ -178,14 +170,6 @@ struct LRUHandle {

  void SetHit() { m_flags |= M_HAS_HIT; }

-  void SetSecondaryCacheCompatible(bool compat) {
-    if (compat) {
-      im_flags |= IM_IS_SECONDARY_CACHE_COMPATIBLE;
-    } else {
-      im_flags &= ~IM_IS_SECONDARY_CACHE_COMPATIBLE;
-    }
-  }
-
  void SetIsPending(bool pending) {
    if (pending) {
      im_flags |= IM_IS_PENDING;
@@ -210,22 +194,19 @@ struct LRUHandle {
    }
  }

-  void Free() {
+  void Free(MemoryAllocator* allocator) {
    assert(refs == 0);

-    if (!IsSecondaryCacheCompatible() && info_.deleter) {
-      (*info_.deleter)(key(), value);
-    } else if (IsSecondaryCacheCompatible()) {
-      if (IsPending()) {
-        assert(sec_handle != nullptr);
-        SecondaryCacheResultHandle* tmp_sec_handle = sec_handle;
-        tmp_sec_handle->Wait();
-        value = tmp_sec_handle->Value();
-        delete tmp_sec_handle;
-      }
-      if (value) {
-        (*info_.helper->del_cb)(key(), value);
-      }
+    if (UNLIKELY(IsPending())) {
+      assert(sec_handle != nullptr);
+      SecondaryCacheResultHandle* tmp_sec_handle = sec_handle;
+      tmp_sec_handle->Wait();
+      value = tmp_sec_handle->Value();
+      delete tmp_sec_handle;
+    }
+    assert(helper);
+    if (helper->del_cb) {
+      helper->del_cb(value, allocator);
    }

    free(this);
@@ -267,7 +248,7 @@ struct LRUHandle {
 // 4.4.3's builtin hashtable.
 class LRUHandleTable {
 public:
-  explicit LRUHandleTable(int max_upper_hash_bits);
+  explicit LRUHandleTable(int max_upper_hash_bits, MemoryAllocator* allocator);
  ~LRUHandleTable();

  LRUHandle* Lookup(const Slice& key, uint32_t hash);
@@ -291,6 +272,8 @@ class LRUHandleTable {

  size_t GetOccupancyCount() const { return elems_; }

+  MemoryAllocator* GetAllocator() const { return allocator_; }
+
 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
@@ -312,6 +295,9 @@ class LRUHandleTable {

  // Set from max_upper_hash_bits (see constructor).
  const int max_length_bits_;
+
+  // From Cache, needed for delete
+  MemoryAllocator* const allocator_;
 };

 // A single shard of sharded cache.
@@ -321,7 +307,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
                double high_pri_pool_ratio, double low_pri_pool_ratio,
                bool use_adaptive_mutex,
                CacheMetadataChargePolicy metadata_charge_policy,
-                int max_upper_hash_bits, SecondaryCache* secondary_cache);
+                int max_upper_hash_bits, MemoryAllocator* allocator,
+                SecondaryCache* secondary_cache);

 public:  // Type definitions expected as parameter to ShardedCache
  using HandleImpl = LRUHandle;
@@ -348,26 +335,15 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
  void SetLowPriorityPoolRatio(double low_pri_pool_ratio);

  // Like Cache methods, but with an extra "hash" parameter.
-  inline Status Insert(const Slice& key, uint32_t hash, void* value,
-                       size_t charge, Cache::DeleterFn deleter,
-                       LRUHandle** handle, Cache::Priority priority) {
-    return Insert(key, hash, value, charge, deleter, nullptr, handle, priority);
-  }
-  inline Status Insert(const Slice& key, uint32_t hash, void* value,
-                       const Cache::CacheItemHelper* helper, size_t charge,
-                       LRUHandle** handle, Cache::Priority priority) {
-    assert(helper);
-    return Insert(key, hash, value, charge, nullptr, helper, handle, priority);
-  }
-  // If helper_cb is null, the values of the following arguments don't matter.
+  Status Insert(const Slice& key, uint32_t hash, Cache::ObjectPtr value,
+                const Cache::CacheItemHelper* helper, size_t charge,
+                LRUHandle** handle, Cache::Priority priority);
+
  LRUHandle* Lookup(const Slice& key, uint32_t hash,
                    const Cache::CacheItemHelper* helper,
-                    const Cache::CreateCallback& create_cb,
+                    Cache::CreateContext* create_context,
                    Cache::Priority priority, bool wait, Statistics* stats);
-  inline LRUHandle* Lookup(const Slice& key, uint32_t hash) {
-    return Lookup(key, hash, nullptr, nullptr, Cache::Priority::LOW, true,
-                  nullptr);
-  }
+
  bool Release(LRUHandle* handle, bool useful, bool erase_if_last_ref);
  bool IsReady(LRUHandle* /*handle*/);
  void Wait(LRUHandle* /*handle*/) {}
@@ -384,8 +360,9 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
  size_t GetTableAddressCount() const;

  void ApplyToSomeEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, Cache::ObjectPtr value,
+                               size_t charge,
+                               const Cache::CacheItemHelper* helper)>& callback,
      size_t average_entries_per_lock, size_t* state);

  void EraseUnRefEntries();
@@ -414,9 +391,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
  // nullptr.
  Status InsertItem(LRUHandle* item, LRUHandle** handle,
                    bool free_handle_on_fail);
-  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
-                DeleterFn deleter, const Cache::CacheItemHelper* helper,
-                LRUHandle** handle, Cache::Priority priority);
  // Promote an item looked up from the secondary cache to the LRU cache.
  // The item may be still in the secondary cache.
  // It is only inserted into the hash table and not the LRU list, and only
@@ -521,9 +495,9 @@ class LRUCache
               kDontChargeCacheMetadata,
           std::shared_ptr<SecondaryCache> secondary_cache = nullptr);
  const char* Name() const override { return "LRUCache"; }
-  void* Value(Handle* handle) override;
+  ObjectPtr Value(Handle* handle) override;
  size_t GetCharge(Handle* handle) const override;
-  DeleterFn GetDeleter(Handle* handle) const override;
+  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
  void WaitAll(std::vector<Handle*>& handles) override;

  // Retrieves number of elements in LRU, for unit test purpose only.
@@ -10,7 +10,7 @@

 #include "cache/cache_key.h"
 #include "cache/clock_cache.h"
-#include "cache/fast_lru_cache.h"
+#include "cache_helpers.h"
 #include "db/db_test_util.h"
 #include "file/sst_file_manager_impl.h"
 #include "port/port.h"
@@ -20,6 +20,7 @@
 #include "rocksdb/sst_file_manager.h"
 #include "rocksdb/utilities/cache_dump_load.h"
 #include "test_util/testharness.h"
+#include "typed_cache.h"
 #include "util/coding.h"
 #include "util/random.h"
 #include "utilities/cache_dump_load_impl.h"
@@ -50,14 +51,15 @@ class LRUCacheTest : public testing::Test {
                               high_pri_pool_ratio, low_pri_pool_ratio,
                               use_adaptive_mutex, kDontChargeCacheMetadata,
                               /*max_upper_hash_bits=*/24,
+                               /*allocator*/ nullptr,
                               /*secondary_cache=*/nullptr);
  }

  void Insert(const std::string& key,
              Cache::Priority priority = Cache::Priority::LOW) {
-    EXPECT_OK(cache_->Insert(key, 0 /*hash*/, nullptr /*value*/, 1 /*charge*/,
-                             nullptr /*deleter*/, nullptr /*handle*/,
-                             priority));
+    EXPECT_OK(cache_->Insert(key, 0 /*hash*/, nullptr /*value*/,
+                             &kNoopCacheItemHelper, 1 /*charge*/,
+                             nullptr /*handle*/, priority));
  }

  void Insert(char key, Cache::Priority priority = Cache::Priority::LOW) {
@@ -65,7 +67,8 @@ class LRUCacheTest : public testing::Test {
  }

  bool Lookup(const std::string& key) {
-    auto handle = cache_->Lookup(key, 0 /*hash*/);
+    auto handle = cache_->Lookup(key, 0 /*hash*/, nullptr, nullptr,
+                                 Cache::Priority::LOW, true, nullptr);
    if (handle) {
      cache_->Release(handle, true /*useful*/, false /*erase*/);
      return true;
@@ -364,152 +367,14 @@ TEST_F(LRUCacheTest, EntriesWithPriority) {
  ValidateLRUList({"x", "y", "g", "z", "d", "m"}, 2, 2, 2);
 }

-// TODO: FastLRUCache and ClockCache use the same tests. We can probably remove
-// them from FastLRUCache after ClockCache becomes productive, and we don't plan
-// to use or maintain FastLRUCache any more.
-namespace fast_lru_cache {
-
-// TODO(guido) Replicate LRU policy tests from LRUCache here.
-class FastLRUCacheTest : public testing::Test {
- public:
-  FastLRUCacheTest() {}
-  ~FastLRUCacheTest() override { DeleteCache(); }
-
-  void DeleteCache() {
-    if (cache_ != nullptr) {
-      cache_->~LRUCacheShard();
-      port::cacheline_aligned_free(cache_);
-      cache_ = nullptr;
-    }
-  }
-
-  void NewCache(size_t capacity) {
-    DeleteCache();
-    cache_ = reinterpret_cast<LRUCacheShard*>(
-        port::cacheline_aligned_alloc(sizeof(LRUCacheShard)));
-    new (cache_) LRUCacheShard(capacity, 1 /*estimated_value_size*/,
-                               false /*strict_capacity_limit*/,
-                               kDontChargeCacheMetadata);
-  }
-
-  Status Insert(const std::string& key) {
-    return cache_->Insert(key, 0 /*hash*/, nullptr /*value*/, 1 /*charge*/,
-                          nullptr /*deleter*/, nullptr /*handle*/,
-                          Cache::Priority::LOW);
-  }
-
-  Status Insert(char key, size_t len) { return Insert(std::string(len, key)); }
-
-  size_t CalcEstimatedHandleChargeWrapper(
-      size_t estimated_value_size,
-      CacheMetadataChargePolicy metadata_charge_policy) {
-    return LRUCacheShard::CalcEstimatedHandleCharge(estimated_value_size,
-                                                    metadata_charge_policy);
-  }
-
-  int CalcHashBitsWrapper(size_t capacity, size_t estimated_value_size,
-                          CacheMetadataChargePolicy metadata_charge_policy) {
-    return LRUCacheShard::CalcHashBits(capacity, estimated_value_size,
-                                       metadata_charge_policy);
-  }
-
-  // Maximum number of items that a shard can hold.
-  double CalcMaxOccupancy(size_t capacity, size_t estimated_value_size,
-                          CacheMetadataChargePolicy metadata_charge_policy) {
-    size_t handle_charge = LRUCacheShard::CalcEstimatedHandleCharge(
-        estimated_value_size, metadata_charge_policy);
-    return capacity / (kLoadFactor * handle_charge);
-  }
-  bool TableSizeIsAppropriate(int hash_bits, double max_occupancy) {
-    if (hash_bits == 0) {
-      return max_occupancy <= 1;
-    } else {
-      return (1 << hash_bits >= max_occupancy) &&
-             (1 << (hash_bits - 1) <= max_occupancy);
-    }
-  }
-
- private:
-  LRUCacheShard* cache_ = nullptr;
-};
-
-TEST_F(FastLRUCacheTest, ValidateKeySize) {
-  NewCache(3);
-  EXPECT_OK(Insert('a', 16));
-  EXPECT_NOK(Insert('b', 15));
-  EXPECT_OK(Insert('b', 16));
-  EXPECT_NOK(Insert('c', 17));
-  EXPECT_NOK(Insert('d', 1000));
-  EXPECT_NOK(Insert('e', 11));
-  EXPECT_NOK(Insert('f', 0));
-}
-
-TEST_F(FastLRUCacheTest, CalcHashBitsTest) {
-  size_t capacity;
-  size_t estimated_value_size;
-  double max_occupancy;
-  int hash_bits;
-  CacheMetadataChargePolicy metadata_charge_policy;
-  // Vary the cache capacity, fix the element charge.
-  for (int i = 0; i < 2048; i++) {
-    capacity = i;
-    estimated_value_size = 0;
-    metadata_charge_policy = kFullChargeCacheMetadata;
-    max_occupancy = CalcMaxOccupancy(capacity, estimated_value_size,
-                                     metadata_charge_policy);
-    hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                    metadata_charge_policy);
-    EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
-  }
-  // Fix the cache capacity, vary the element charge.
-  for (int i = 0; i < 1024; i++) {
-    capacity = 1024;
-    estimated_value_size = i;
-    metadata_charge_policy = kFullChargeCacheMetadata;
-    max_occupancy = CalcMaxOccupancy(capacity, estimated_value_size,
-                                     metadata_charge_policy);
-    hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                    metadata_charge_policy);
-    EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
-  }
-  // Zero-capacity cache, and only values have charge.
-  capacity = 0;
-  estimated_value_size = 1;
-  metadata_charge_policy = kDontChargeCacheMetadata;
-  hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                  metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
-  // Zero-capacity cache, and only metadata has charge.
-  capacity = 0;
-  estimated_value_size = 0;
-  metadata_charge_policy = kFullChargeCacheMetadata;
-  hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                  metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
-  // Small cache, large elements.
-  capacity = 1024;
-  estimated_value_size = 8192;
-  metadata_charge_policy = kFullChargeCacheMetadata;
-  hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                  metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, 0 /* max_occupancy */));
-  // Large capacity.
-  capacity = 31924172;
-  estimated_value_size = 8192;
-  metadata_charge_policy = kFullChargeCacheMetadata;
-  max_occupancy =
-      CalcMaxOccupancy(capacity, estimated_value_size, metadata_charge_policy);
-  hash_bits = CalcHashBitsWrapper(capacity, estimated_value_size,
-                                  metadata_charge_policy);
-  EXPECT_TRUE(TableSizeIsAppropriate(hash_bits, max_occupancy));
-}
-
-}  // namespace fast_lru_cache
-
-namespace hyper_clock_cache {
+namespace clock_cache {

 class ClockCacheTest : public testing::Test {
 public:
+  using Shard = HyperClockCache::Shard;
+  using Table = HyperClockTable;
+  using HandleImpl = Shard::HandleImpl;
+
  ClockCacheTest() {}
  ~ClockCacheTest() override { DeleteShard(); }

@@ -523,17 +388,20 @@ class ClockCacheTest : public testing::Test {

  void NewShard(size_t capacity, bool strict_capacity_limit = true) {
    DeleteShard();
-    shard_ = reinterpret_cast<ClockCacheShard*>(
-        port::cacheline_aligned_alloc(sizeof(ClockCacheShard)));
-    new (shard_) ClockCacheShard(capacity, 1, strict_capacity_limit,
-                                 kDontChargeCacheMetadata);
+    shard_ =
+        reinterpret_cast<Shard*>(port::cacheline_aligned_alloc(sizeof(Shard)));
+
+    Table::Opts opts;
+    opts.estimated_value_size = 1;
+    new (shard_) Shard(capacity, strict_capacity_limit,
+                       kDontChargeCacheMetadata, /*allocator*/ nullptr, opts);
  }

  Status Insert(const UniqueId64x2& hashed_key,
                Cache::Priority priority = Cache::Priority::LOW) {
    return shard_->Insert(TestKey(hashed_key), hashed_key, nullptr /*value*/,
-                          1 /*charge*/, nullptr /*deleter*/, nullptr /*handle*/,
-                          priority);
+                          &kNoopCacheItemHelper, 1 /*charge*/,
+                          nullptr /*handle*/, priority);
  }

  Status Insert(char key, Cache::Priority priority = Cache::Priority::LOW) {
@@ -543,8 +411,8 @@ class ClockCacheTest : public testing::Test {
  Status InsertWithLen(char key, size_t len) {
    std::string skey(len, key);
    return shard_->Insert(skey, TestHashedKey(key), nullptr /*value*/,
-                          1 /*charge*/, nullptr /*deleter*/, nullptr /*handle*/,
-                          Cache::Priority::LOW);
+                          &kNoopCacheItemHelper, 1 /*charge*/,
+                          nullptr /*handle*/, Cache::Priority::LOW);
  }

  bool Lookup(const Slice& key, const UniqueId64x2& hashed_key,
@@ -580,7 +448,7 @@ class ClockCacheTest : public testing::Test {
    return {(static_cast<uint64_t>(key) << 56) + 1234U, 5678U};
  }

-  ClockCacheShard* shard_ = nullptr;
+  Shard* shard_ = nullptr;
 };

 TEST_F(ClockCacheTest, Misc) {
@@ -604,7 +472,8 @@ TEST_F(ClockCacheTest, Misc) {
 }

 TEST_F(ClockCacheTest, Limits) {
-  NewShard(3, false /*strict_capacity_limit*/);
+  constexpr size_t kCapacity = 3;
+  NewShard(kCapacity, false /*strict_capacity_limit*/);
  for (bool strict_capacity_limit : {false, true, false}) {
    SCOPED_TRACE("strict_capacity_limit = " +
                 std::to_string(strict_capacity_limit));
@@ -617,7 +486,7 @@ TEST_F(ClockCacheTest, Limits) {
    // Single entry charge beyond capacity
    {
      Status s = shard_->Insert(TestKey(hkey), hkey, nullptr /*value*/,
-                                5 /*charge*/, nullptr /*deleter*/,
+                                &kNoopCacheItemHelper, 5 /*charge*/,
                                nullptr /*handle*/, Cache::Priority::LOW);
      if (strict_capacity_limit) {
        EXPECT_TRUE(s.IsMemoryLimit());
@@ -628,9 +497,9 @@ TEST_F(ClockCacheTest, Limits) {

    // Single entry fills capacity
    {
-      ClockHandle* h;
+      HandleImpl* h;
      ASSERT_OK(shard_->Insert(TestKey(hkey), hkey, nullptr /*value*/,
-                               3 /*charge*/, nullptr /*deleter*/, &h,
+                               &kNoopCacheItemHelper, 3 /*charge*/, &h,
                               Cache::Priority::LOW));
      // Try to insert more
      Status s = Insert('a');
@@ -644,16 +513,19 @@ TEST_F(ClockCacheTest, Limits) {
      shard_->Release(h, false /*useful*/, false /*erase_if_last_ref*/);
    }

-    // Insert more than table size can handle (cleverly using zero-charge
-    // entries) to exceed occupancy limit.
+    // Insert more than table size can handle to exceed occupancy limit.
+    // (Cleverly using mostly zero-charge entries, but some non-zero to
+    // verify usage tracking on detached entries.)
    {
      size_t n = shard_->GetTableAddressCount() + 1;
-      std::unique_ptr<ClockHandle* []> ha { new ClockHandle* [n] {} };
+      std::unique_ptr<HandleImpl* []> ha { new HandleImpl* [n] {} };
      Status s;
      for (size_t i = 0; i < n && s.ok(); ++i) {
        hkey[1] = i;
-        s = shard_->Insert(TestKey(hkey), hkey, nullptr /*value*/, 0 /*charge*/,
-                           nullptr /*deleter*/, &ha[i], Cache::Priority::LOW);
+        s = shard_->Insert(TestKey(hkey), hkey, nullptr /*value*/,
+                           &kNoopCacheItemHelper,
+                           (i + kCapacity < n) ? 0 : 1 /*charge*/, &ha[i],
+                           Cache::Priority::LOW);
        if (i == 0) {
          EXPECT_OK(s);
        }
@@ -791,18 +663,25 @@ TEST_F(ClockCacheTest, ClockEvictionTest) {
  }
 }

-void IncrementIntDeleter(const Slice& /*key*/, void* value) {
-  *reinterpret_cast<int*>(value) += 1;
-}
+namespace {
+struct DeleteCounter {
+  int deleted = 0;
+};
+const Cache::CacheItemHelper kDeleteCounterHelper{
+    CacheEntryRole::kMisc,
+    [](Cache::ObjectPtr value, MemoryAllocator* /*alloc*/) {
+      static_cast<DeleteCounter*>(value)->deleted += 1;
+    }};
+}  // namespace

 // Testing calls to CorrectNearOverflow in Release
 TEST_F(ClockCacheTest, ClockCounterOverflowTest) {
  NewShard(6, /*strict_capacity_limit*/ false);
-  ClockHandle* h;
-  int deleted = 0;
+  HandleImpl* h;
+  DeleteCounter val;
  UniqueId64x2 hkey = TestHashedKey('x');
-  ASSERT_OK(shard_->Insert(TestKey(hkey), hkey, &deleted, 1,
-                           IncrementIntDeleter, &h, Cache::Priority::HIGH));
+  ASSERT_OK(shard_->Insert(TestKey(hkey), hkey, &val, &kDeleteCounterHelper, 1,
+                           &h, Cache::Priority::HIGH));

  // Some large number outstanding
  shard_->TEST_RefN(h, 123456789);
@@ -822,36 +701,36 @@ TEST_F(ClockCacheTest, ClockCounterOverflowTest) {
  // Free all but last 1
  shard_->TEST_ReleaseN(h, 123456789);
  // Still alive
-  ASSERT_EQ(deleted, 0);
+  ASSERT_EQ(val.deleted, 0);
  // Free last ref, which will finalize erasure
  shard_->Release(h);
  // Deleted
-  ASSERT_EQ(deleted, 1);
+  ASSERT_EQ(val.deleted, 1);
 }

 // This test is mostly to exercise some corner case logic, by forcing two
 // keys to have the same hash, and more
 TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  NewShard(6, /*strict_capacity_limit*/ false);
-  int deleted = 0;
+  DeleteCounter val;
  UniqueId64x2 hkey1 = TestHashedKey('x');
  Slice key1 = TestKey(hkey1);
  UniqueId64x2 hkey2 = TestHashedKey('y');
  Slice key2 = TestKey(hkey2);
  UniqueId64x2 hkey3 = TestHashedKey('z');
  Slice key3 = TestKey(hkey3);
-  ClockHandle* h1;
-  ASSERT_OK(shard_->Insert(key1, hkey1, &deleted, 1, IncrementIntDeleter, &h1,
+  HandleImpl* h1;
+  ASSERT_OK(shard_->Insert(key1, hkey1, &val, &kDeleteCounterHelper, 1, &h1,
                           Cache::Priority::HIGH));
-  ClockHandle* h2;
-  ASSERT_OK(shard_->Insert(key2, hkey2, &deleted, 1, IncrementIntDeleter, &h2,
+  HandleImpl* h2;
+  ASSERT_OK(shard_->Insert(key2, hkey2, &val, &kDeleteCounterHelper, 1, &h2,
                           Cache::Priority::HIGH));
-  ClockHandle* h3;
-  ASSERT_OK(shard_->Insert(key3, hkey3, &deleted, 1, IncrementIntDeleter, &h3,
+  HandleImpl* h3;
+  ASSERT_OK(shard_->Insert(key3, hkey3, &val, &kDeleteCounterHelper, 1, &h3,
                           Cache::Priority::HIGH));

  // Can repeatedly lookup+release despite the hash collision
-  ClockHandle* tmp_h;
+  HandleImpl* tmp_h;
  for (bool erase_if_last_ref : {true, false}) {  // but not last ref
    tmp_h = shard_->Lookup(key1, hkey1);
    ASSERT_EQ(h1, tmp_h);
@@ -872,7 +751,7 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  shard_->Erase(key1, hkey1);

  // All still alive
-  ASSERT_EQ(deleted, 0);
+  ASSERT_EQ(val.deleted, 0);

  // Invisible to Lookup
  tmp_h = shard_->Lookup(key1, hkey1);
@@ -890,8 +769,8 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  }

  // Also Insert with invisible entry there
-  ASSERT_OK(shard_->Insert(key1, hkey1, &deleted, 1, IncrementIntDeleter,
-                           nullptr, Cache::Priority::HIGH));
+  ASSERT_OK(shard_->Insert(key1, hkey1, &val, &kDeleteCounterHelper, 1, nullptr,
+                           Cache::Priority::HIGH));
  tmp_h = shard_->Lookup(key1, hkey1);
  // Found but distinct handle
  ASSERT_NE(nullptr, tmp_h);
@@ -899,13 +778,13 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  ASSERT_TRUE(shard_->Release(tmp_h, /*erase_if_last_ref*/ true));

  // tmp_h deleted
-  ASSERT_EQ(deleted--, 1);
+  ASSERT_EQ(val.deleted--, 1);

  // Release last ref on h1 (already invisible)
  ASSERT_TRUE(shard_->Release(h1, /*erase_if_last_ref*/ false));

  // h1 deleted
-  ASSERT_EQ(deleted--, 1);
+  ASSERT_EQ(val.deleted--, 1);
  h1 = nullptr;

  // Can still find h2, h3
@@ -923,7 +802,7 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  ASSERT_FALSE(shard_->Release(h2, /*erase_if_last_ref*/ false));

  // h2 still not deleted (unreferenced in cache)
-  ASSERT_EQ(deleted, 0);
+  ASSERT_EQ(val.deleted, 0);

  // Can still find it
  tmp_h = shard_->Lookup(key2, hkey2);
@@ -933,7 +812,7 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  ASSERT_TRUE(shard_->Release(h2, /*erase_if_last_ref*/ true));

  // h2 deleted
-  ASSERT_EQ(deleted--, 1);
+  ASSERT_EQ(val.deleted--, 1);
  tmp_h = shard_->Lookup(key2, hkey2);
  ASSERT_EQ(nullptr, tmp_h);

@@ -948,13 +827,13 @@ TEST_F(ClockCacheTest, CollidingInsertEraseTest) {
  ASSERT_FALSE(shard_->Release(h3, /*erase_if_last_ref*/ false));

  // h3 still not deleted (unreferenced in cache)
-  ASSERT_EQ(deleted, 0);
+  ASSERT_EQ(val.deleted, 0);

  // Explicit erase
  shard_->Erase(key3, hkey3);

  // h3 deleted
-  ASSERT_EQ(deleted--, 1);
+  ASSERT_EQ(val.deleted--, 1);
  tmp_h = shard_->Lookup(key3, hkey3);
  ASSERT_EQ(nullptr, tmp_h);
 }
@@ -999,7 +878,7 @@ TEST_F(ClockCacheTest, TableSizesTest) {
  }
 }

-}  // namespace hyper_clock_cache
+}  // namespace clock_cache

 class TestSecondaryCache : public SecondaryCache {
 public:
@@ -1017,12 +896,12 @@ class TestSecondaryCache : public SecondaryCache {
  using ResultMap = std::unordered_map<std::string, ResultType>;

  explicit TestSecondaryCache(size_t capacity)
-      : num_inserts_(0), num_lookups_(0), inject_failure_(false) {
-    cache_ =
-        NewLRUCache(capacity, 0, false, 0.5 /* high_pri_pool_ratio */, nullptr,
-                    kDefaultToAdaptiveMutex, kDontChargeCacheMetadata);
-  }
-  ~TestSecondaryCache() override { cache_.reset(); }
+      : cache_(NewLRUCache(capacity, 0, false, 0.5 /* high_pri_pool_ratio */,
+                           nullptr, kDefaultToAdaptiveMutex,
+                           kDontChargeCacheMetadata)),
+        num_inserts_(0),
+        num_lookups_(0),
+        inject_failure_(false) {}

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

@@ -1030,7 +909,7 @@ class TestSecondaryCache : public SecondaryCache {

  void ResetInjectFailure() { inject_failure_ = false; }

-  Status Insert(const Slice& key, void* value,
+  Status Insert(const Slice& key, Cache::ObjectPtr value,
                const Cache::CacheItemHelper* helper) override {
    if (inject_failure_) {
      return Status::Corruption("Insertion Data Corrupted");
@@ -1049,14 +928,12 @@ class TestSecondaryCache : public SecondaryCache {
      delete[] buf;
      return s;
    }
-    return cache_->Insert(key, buf, size,
-                          [](const Slice& /*key*/, void* val) -> void {
-                            delete[] static_cast<char*>(val);
-                          });
+    return cache_.Insert(key, buf, size);
  }

  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
+      const Slice& key, const Cache::CacheItemHelper* helper,
+      Cache::CreateContext* create_context, bool /*wait*/,
      bool /*advise_erase*/, bool& is_in_sec_cache) override {
    std::string key_str = key.ToString();
    TEST_SYNC_POINT_CALLBACK("TestSecondaryCache::Lookup", &key_str);
@@ -1072,24 +949,25 @@ class TestSecondaryCache : public SecondaryCache {
      return secondary_handle;
    }

-    Cache::Handle* handle = cache_->Lookup(key);
+    TypedHandle* handle = cache_.Lookup(key);
    num_lookups_++;
    if (handle) {
-      void* value = nullptr;
+      Cache::ObjectPtr value = nullptr;
      size_t charge = 0;
      Status s;
      if (type != ResultType::DEFER_AND_FAIL) {
-        char* ptr = (char*)cache_->Value(handle);
+        char* ptr = cache_.Value(handle);
        size_t size = DecodeFixed64(ptr);
        ptr += sizeof(uint64_t);
-        s = create_cb(ptr, size, &value, &charge);
+        s = helper->create_cb(Slice(ptr, size), create_context,
+                              /*alloc*/ nullptr, &value, &charge);
      }
      if (s.ok()) {
        secondary_handle.reset(new TestSecondaryCacheResultHandle(
            cache_.get(), handle, value, charge, type));
        is_in_sec_cache = true;
      } else {
-        cache_->Release(handle);
+        cache_.Release(handle);
      }
    }
    return secondary_handle;
@@ -1128,7 +1006,8 @@ class TestSecondaryCache : public SecondaryCache {
  class TestSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
   public:
    TestSecondaryCacheResultHandle(Cache* cache, Cache::Handle* handle,
-                                   void* value, size_t size, ResultType type)
+                                   Cache::ObjectPtr value, size_t size,
+                                   ResultType type)
        : cache_(cache),
          handle_(handle),
          value_(value),
@@ -1145,7 +1024,7 @@ class TestSecondaryCache : public SecondaryCache {

    void Wait() override {}

-    void* Value() override {
+    Cache::ObjectPtr Value() override {
      assert(is_ready_);
      return value_;
    }
@@ -1157,12 +1036,15 @@ class TestSecondaryCache : public SecondaryCache {
   private:
    Cache* cache_;
    Cache::Handle* handle_;
-    void* value_;
+    Cache::ObjectPtr value_;
    size_t size_;
    bool is_ready_;
  };

-  std::shared_ptr<Cache> cache_;
+  using SharedCache =
+      BasicTypedSharedCacheInterface<char[], CacheEntryRole::kMisc>;
+  using TypedHandle = SharedCache::TypedHandle;
+  SharedCache cache_;
  uint32_t num_inserts_;
  uint32_t num_lookups_;
  bool inject_failure_;
@@ -1182,7 +1064,8 @@ class DBSecondaryCacheTest : public DBTestBase {
  std::unique_ptr<Env> fault_env_;
 };

-class LRUCacheSecondaryCacheTest : public LRUCacheTest {
+class LRUCacheSecondaryCacheTest : public LRUCacheTest,
+                                   public Cache::CreateContext {
 public:
  LRUCacheSecondaryCacheTest() : fail_create_(false) {}
  ~LRUCacheSecondaryCacheTest() {}
@@ -1204,13 +1087,13 @@ class LRUCacheSecondaryCacheTest : public LRUCacheTest {
    size_t size_;
  };

-  static size_t SizeCallback(void* obj) {
-    return reinterpret_cast<TestItem*>(obj)->Size();
+  static size_t SizeCallback(Cache::ObjectPtr obj) {
+    return static_cast<TestItem*>(obj)->Size();
  }

-  static Status SaveToCallback(void* from_obj, size_t from_offset,
-                               size_t length, void* out) {
-    TestItem* item = reinterpret_cast<TestItem*>(from_obj);
+  static Status SaveToCallback(Cache::ObjectPtr from_obj, size_t from_offset,
+                               size_t length, char* out) {
+    TestItem* item = static_cast<TestItem*>(from_obj);
    char* buf = item->Buf();
    EXPECT_EQ(length, item->Size());
    EXPECT_EQ(from_offset, 0);
@@ -1218,27 +1101,30 @@ class LRUCacheSecondaryCacheTest : public LRUCacheTest {
    return Status::OK();
  }

-  static void DeletionCallback(const Slice& /*key*/, void* obj) {
-    delete reinterpret_cast<TestItem*>(obj);
+  static void DeletionCallback(Cache::ObjectPtr obj,
+                               MemoryAllocator* /*alloc*/) {
+    delete static_cast<TestItem*>(obj);
  }

  static Cache::CacheItemHelper helper_;

-  static Status SaveToCallbackFail(void* /*obj*/, size_t /*offset*/,
-                                   size_t /*size*/, void* /*out*/) {
+  static Status SaveToCallbackFail(Cache::ObjectPtr /*from_obj*/,
+                                   size_t /*from_offset*/, size_t /*length*/,
+                                   char* /*out*/) {
    return Status::NotSupported();
  }

  static Cache::CacheItemHelper helper_fail_;

-  Cache::CreateCallback test_item_creator = [&](const void* buf, size_t size,
-                                                void** out_obj,
-                                                size_t* charge) -> Status {
-    if (fail_create_) {
+  static Status CreateCallback(const Slice& data, Cache::CreateContext* context,
+                               MemoryAllocator* /*allocator*/,
+                               Cache::ObjectPtr* out_obj, size_t* out_charge) {
+    auto t = static_cast<LRUCacheSecondaryCacheTest*>(context);
+    if (t->fail_create_) {
      return Status::NotSupported();
    }
-    *out_obj = reinterpret_cast<void*>(new TestItem((char*)buf, size));
-    *charge = size;
+    *out_obj = new TestItem(data.data(), data.size());
+    *out_charge = data.size();
    return Status::OK();
  };

@@ -1248,15 +1134,17 @@ class LRUCacheSecondaryCacheTest : public LRUCacheTest {
  bool fail_create_;
 };

-Cache::CacheItemHelper LRUCacheSecondaryCacheTest::helper_(
+Cache::CacheItemHelper LRUCacheSecondaryCacheTest::helper_{
+    CacheEntryRole::kMisc, LRUCacheSecondaryCacheTest::DeletionCallback,
    LRUCacheSecondaryCacheTest::SizeCallback,
    LRUCacheSecondaryCacheTest::SaveToCallback,
-    LRUCacheSecondaryCacheTest::DeletionCallback);
+    LRUCacheSecondaryCacheTest::CreateCallback};

-Cache::CacheItemHelper LRUCacheSecondaryCacheTest::helper_fail_(
+Cache::CacheItemHelper LRUCacheSecondaryCacheTest::helper_fail_{
+    CacheEntryRole::kMisc, LRUCacheSecondaryCacheTest::DeletionCallback,
    LRUCacheSecondaryCacheTest::SizeCallback,
    LRUCacheSecondaryCacheTest::SaveToCallbackFail,
-    LRUCacheSecondaryCacheTest::DeletionCallback);
+    LRUCacheSecondaryCacheTest::CreateCallback};

 TEST_F(LRUCacheSecondaryCacheTest, BasicTest) {
  LRUCacheOptions opts(1024 /* capacity */, 0 /* num_shard_bits */,
@@ -1265,14 +1153,19 @@ TEST_F(LRUCacheSecondaryCacheTest, BasicTest) {
                       nullptr /* memory_allocator */, kDefaultToAdaptiveMutex,
                       kDontChargeCacheMetadata);
  std::shared_ptr<TestSecondaryCache> secondary_cache =
-      std::make_shared<TestSecondaryCache>(2048);
+      std::make_shared<TestSecondaryCache>(4096);
  opts.secondary_cache = secondary_cache;
  std::shared_ptr<Cache> cache = NewLRUCache(opts);
  std::shared_ptr<Statistics> stats = CreateDBStatistics();
  CacheKey k1 = CacheKey::CreateUniqueForCacheLifetime(cache.get());
  CacheKey k2 = CacheKey::CreateUniqueForCacheLifetime(cache.get());
+  CacheKey k3 = CacheKey::CreateUniqueForCacheLifetime(cache.get());

  Random rnd(301);
+  // Start with warming k3
+  std::string str3 = rnd.RandomString(1021);
+  ASSERT_OK(secondary_cache->InsertSaved(k3.AsSlice(), str3));
+
  std::string str1 = rnd.RandomString(1020);
  TestItem* item1 = new TestItem(str1.data(), str1.length());
  ASSERT_OK(cache->Insert(k1.AsSlice(), item1,
@@ -1287,17 +1180,29 @@ TEST_F(LRUCacheSecondaryCacheTest, BasicTest) {
  Cache::Handle* handle;
  handle =
      cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                    test_item_creator, Cache::Priority::LOW, true, stats.get());
+                    /*context*/ this, Cache::Priority::LOW, true, stats.get());
  ASSERT_NE(handle, nullptr);
+  ASSERT_EQ(static_cast<TestItem*>(cache->Value(handle))->Size(), str2.size());
  cache->Release(handle);
+
  // This lookup should promote k1 and demote k2
  handle =
      cache->Lookup(k1.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                    test_item_creator, Cache::Priority::LOW, true, stats.get());
+                    /*context*/ this, Cache::Priority::LOW, true, stats.get());
  ASSERT_NE(handle, nullptr);
+  ASSERT_EQ(static_cast<TestItem*>(cache->Value(handle))->Size(), str1.size());
  cache->Release(handle);
-  ASSERT_EQ(secondary_cache->num_inserts(), 2u);
-  ASSERT_EQ(secondary_cache->num_lookups(), 1u);
+
+  // This lookup should promote k3 and demote k1
+  handle =
+      cache->Lookup(k3.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
+                    /*context*/ this, Cache::Priority::LOW, true, stats.get());
+  ASSERT_NE(handle, nullptr);
+  ASSERT_EQ(static_cast<TestItem*>(cache->Value(handle))->Size(), str3.size());
+  cache->Release(handle);
+
+  ASSERT_EQ(secondary_cache->num_inserts(), 3u);
+  ASSERT_EQ(secondary_cache->num_lookups(), 2u);
  ASSERT_EQ(stats->getTickerCount(SECONDARY_CACHE_HITS),
            secondary_cache->num_lookups());
  PerfContext perf_ctx = *get_perf_context();
@@ -1323,18 +1228,19 @@ TEST_F(LRUCacheSecondaryCacheTest, BasicFailTest) {
  Random rnd(301);
  std::string str1 = rnd.RandomString(1020);
  auto item1 = std::make_unique<TestItem>(str1.data(), str1.length());
-  ASSERT_TRUE(cache->Insert(k1.AsSlice(), item1.get(), nullptr, str1.length())
-                  .IsInvalidArgument());
+  // NOTE: changed to assert helper != nullptr for efficiency / code size
+  // ASSERT_TRUE(cache->Insert(k1.AsSlice(), item1.get(), nullptr,
+  //                           str1.length()).IsInvalidArgument());
  ASSERT_OK(cache->Insert(k1.AsSlice(), item1.get(),
                          &LRUCacheSecondaryCacheTest::helper_, str1.length()));
  item1.release();  // Appease clang-analyze "potential memory leak"

  Cache::Handle* handle;
-  handle = cache->Lookup(k2.AsSlice(), nullptr, test_item_creator,
+  handle = cache->Lookup(k2.AsSlice(), nullptr, /*context*/ this,
                         Cache::Priority::LOW, true);
  ASSERT_EQ(handle, nullptr);
  handle = cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, false);
+                         /*context*/ this, Cache::Priority::LOW, false);
  ASSERT_EQ(handle, nullptr);

  cache.reset();
@@ -1372,18 +1278,18 @@ TEST_F(LRUCacheSecondaryCacheTest, SaveFailTest) {
  Cache::Handle* handle;
  handle =
      cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_fail_,
-                    test_item_creator, Cache::Priority::LOW, true);
+                    /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  // This lookup should fail, since k1 demotion would have failed
  handle =
      cache->Lookup(k1.AsSlice(), &LRUCacheSecondaryCacheTest::helper_fail_,
-                    test_item_creator, Cache::Priority::LOW, true);
+                    /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_EQ(handle, nullptr);
  // Since k1 didn't get promoted, k2 should still be in cache
  handle =
      cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_fail_,
-                    test_item_creator, Cache::Priority::LOW, true);
+                    /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  ASSERT_EQ(secondary_cache->num_inserts(), 1u);
@@ -1420,16 +1326,16 @@ TEST_F(LRUCacheSecondaryCacheTest, CreateFailTest) {
  Cache::Handle* handle;
  SetFailCreate(true);
  handle = cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, true);
+                         /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  // This lookup should fail, since k1 creation would have failed
  handle = cache->Lookup(k1.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, true);
+                         /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_EQ(handle, nullptr);
  // Since k1 didn't get promoted, k2 should still be in cache
  handle = cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, true);
+                         /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  ASSERT_EQ(secondary_cache->num_inserts(), 1u);
@@ -1465,19 +1371,19 @@ TEST_F(LRUCacheSecondaryCacheTest, FullCapacityTest) {

  Cache::Handle* handle;
  handle = cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, true);
+                         /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  // k1 promotion should fail due to the block cache being at capacity,
  // but the lookup should still succeed
  Cache::Handle* handle2;
  handle2 = cache->Lookup(k1.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                          test_item_creator, Cache::Priority::LOW, true);
+                          /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle2, nullptr);
  // Since k1 didn't get inserted, k2 should still be in cache
  cache->Release(handle);
  cache->Release(handle2);
  handle = cache->Lookup(k2.AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-                         test_item_creator, Cache::Priority::LOW, true);
+                         /*context*/ this, Cache::Priority::LOW, true);
  ASSERT_NE(handle, nullptr);
  cache->Release(handle);
  ASSERT_EQ(secondary_cache->num_inserts(), 1u);
@@ -1917,7 +1823,7 @@ TEST_F(LRUCacheSecondaryCacheTest, BasicWaitAllTest) {
  for (int i = 0; i < 6; ++i) {
    results.emplace_back(cache->Lookup(
        ock.WithOffset(i).AsSlice(), &LRUCacheSecondaryCacheTest::helper_,
-        test_item_creator, Cache::Priority::LOW, false));
+        /*context*/ this, Cache::Priority::LOW, false));
  }
  cache->WaitAll(results);
  for (int i = 0; i < 6; ++i) {
@@ -2043,26 +1949,18 @@ class LRUCacheWithStat : public LRUCache {
  }
  ~LRUCacheWithStat() {}

-  Status Insert(const Slice& key, void* value, size_t charge, DeleterFn deleter,
-                Handle** handle, Priority priority) override {
-    insert_count_++;
-    return LRUCache::Insert(key, value, charge, deleter, handle, priority);
-  }
-  Status Insert(const Slice& key, void* value, const CacheItemHelper* helper,
-                size_t charge, Handle** handle = nullptr,
+  Status Insert(const Slice& key, Cache::ObjectPtr value,
+                const CacheItemHelper* helper, size_t charge,
+                Handle** handle = nullptr,
                Priority priority = Priority::LOW) override {
    insert_count_++;
    return LRUCache::Insert(key, value, helper, charge, handle, priority);
  }
-  Handle* Lookup(const Slice& key, Statistics* stats) override {
-    lookup_count_++;
-    return LRUCache::Lookup(key, stats);
-  }
  Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                 const CreateCallback& create_cb, Priority priority, bool wait,
+                 CreateContext* create_context, Priority priority, bool wait,
                 Statistics* stats = nullptr) override {
    lookup_count_++;
-    return LRUCache::Lookup(key, helper, create_cb, priority, wait, stats);
+    return LRUCache::Lookup(key, helper, create_context, priority, wait, stats);
  }

  uint32_t GetInsertCount() { return insert_count_; }
@@ -2077,7 +1975,6 @@ class LRUCacheWithStat : public LRUCache {
  uint32_t lookup_count_;
 };

-#ifndef ROCKSDB_LITE

 TEST_F(DBSecondaryCacheTest, LRUCacheDumpLoadBasic) {
  LRUCacheOptions cache_opts(1024 * 1024 /* capacity */, 0 /* num_shard_bits */,
@@ -2692,7 +2589,6 @@ TEST_F(DBSecondaryCacheTest, TestSecondaryCacheOptionTwoDB) {
  ASSERT_OK(DestroyDB(dbname2, options));
 }

-#endif  // ROCKSDB_LITE

 }  // namespace ROCKSDB_NAMESPACE

@@ -0,0 +1,41 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "rocksdb/secondary_cache.h"
+
+#include "cache/cache_entry_roles.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+namespace {
+
+void NoopDelete(Cache::ObjectPtr, MemoryAllocator*) {}
+
+size_t SliceSize(Cache::ObjectPtr obj) {
+  return static_cast<Slice*>(obj)->size();
+}
+
+Status SliceSaveTo(Cache::ObjectPtr from_obj, size_t from_offset, size_t length,
+                   char* out) {
+  const Slice& slice = *static_cast<Slice*>(from_obj);
+  std::memcpy(out, slice.data() + from_offset, length);
+  return Status::OK();
+}
+
+Status FailCreate(const Slice&, Cache::CreateContext*, MemoryAllocator*,
+                  Cache::ObjectPtr*, size_t*) {
+  return Status::NotSupported("Only for dumping data into SecondaryCache");
+}
+
+}  // namespace
+
+Status SecondaryCache::InsertSaved(const Slice& key, const Slice& saved) {
+  static Cache::CacheItemHelper helper{CacheEntryRole::kMisc, &NoopDelete,
+                                       &SliceSize, &SliceSaveTo, &FailCreate};
+  // NOTE: depends on Insert() being synchronous, not keeping pointer `&saved`
+  return Insert(key, const_cast<Slice*>(&saved), &helper);
+}
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -49,16 +49,12 @@ class CacheShardBase {
    HashCref GetHash() const;
    ...
  };
-  Status Insert(const Slice& key, HashCref hash, void* value, size_t charge,
-                DeleterFn deleter, HandleImpl** handle,
-                Cache::Priority priority) = 0;
-  Status Insert(const Slice& key, HashCref hash, void* value,
+  Status Insert(const Slice& key, HashCref hash, Cache::ObjectPtr value,
                const Cache::CacheItemHelper* helper, size_t charge,
                HandleImpl** handle, Cache::Priority priority) = 0;
-  HandleImpl* Lookup(const Slice& key, HashCref hash) = 0;
  HandleImpl* Lookup(const Slice& key, HashCref hash,
                        const Cache::CacheItemHelper* helper,
-                        const Cache::CreateCallback& create_cb,
+                        Cache::CreateContext* create_context,
                        Cache::Priority priority, bool wait,
                        Statistics* stats) = 0;
  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref) = 0;
@@ -77,8 +73,9 @@ class CacheShardBase {
  // *state == 0 and implementation sets *state = SIZE_MAX to indicate
  // completion.
  void ApplyToSomeEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, ObjectPtr value,
+                               size_t charge,
+                               const Cache::CacheItemHelper* helper)>& callback,
      size_t average_entries_per_lock, size_t* state) = 0;
  void EraseUnRefEntries() = 0;
  */
@@ -172,36 +169,24 @@ class ShardedCache : public ShardedCacheBase {
        [s_c_l](CacheShard* cs) { cs->SetStrictCapacityLimit(s_c_l); });
  }

-  Status Insert(const Slice& key, void* value, size_t charge, DeleterFn deleter,
-                Handle** handle, Priority priority) override {
-    HashVal hash = CacheShard::ComputeHash(key);
-    auto h_out = reinterpret_cast<HandleImpl**>(handle);
-    return GetShard(hash).Insert(key, hash, value, charge, deleter, h_out,
-                                 priority);
-  }
-  Status Insert(const Slice& key, void* value, const CacheItemHelper* helper,
-                size_t charge, Handle** handle = nullptr,
+  Status Insert(const Slice& key, ObjectPtr value,
+                const CacheItemHelper* helper, size_t charge,
+                Handle** handle = nullptr,
                Priority priority = Priority::LOW) override {
-    if (!helper) {
-      return Status::InvalidArgument();
-    }
+    assert(helper);
    HashVal hash = CacheShard::ComputeHash(key);
    auto h_out = reinterpret_cast<HandleImpl**>(handle);
    return GetShard(hash).Insert(key, hash, value, helper, charge, h_out,
                                 priority);
  }

-  Handle* Lookup(const Slice& key, Statistics* /*stats*/) override {
-    HashVal hash = CacheShard::ComputeHash(key);
-    HandleImpl* result = GetShard(hash).Lookup(key, hash);
-    return reinterpret_cast<Handle*>(result);
-  }
-  Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                 const CreateCallback& create_cb, Priority priority, bool wait,
+  Handle* Lookup(const Slice& key, const CacheItemHelper* helper = nullptr,
+                 CreateContext* create_context = nullptr,
+                 Priority priority = Priority::LOW, bool wait = true,
                 Statistics* stats = nullptr) override {
    HashVal hash = CacheShard::ComputeHash(key);
-    HandleImpl* result = GetShard(hash).Lookup(key, hash, helper, create_cb,
-                                               priority, wait, stats);
+    HandleImpl* result = GetShard(hash).Lookup(
+        key, hash, helper, create_context, priority, wait, stats);
    return reinterpret_cast<Handle*>(result);
  }

@@ -244,8 +229,8 @@ class ShardedCache : public ShardedCacheBase {
    return SumOverShards2(&CacheShard::GetTableAddressCount);
  }
  void ApplyToAllEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, ObjectPtr value, size_t charge,
+                               const CacheItemHelper* helper)>& callback,
      const ApplyToAllEntriesOptions& opts) override {
    uint32_t num_shards = GetNumShards();
    // Iterate over part of each shard, rotating between shards, to
@@ -0,0 +1,339 @@
+//  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).
+
+// APIs for accessing Cache in a type-safe and convenient way. Cache is kept
+// at a low, thin level of abstraction so that different implementations can
+// be plugged in, but these wrappers provide clean, convenient access to the
+// most common operations.
+//
+// A number of template classes are needed for sharing common structure. The
+// key classes are these:
+//
+// * PlaceholderCacheInterface - Used for making cache reservations, with
+// entries that have a charge but no value.
+// * BasicTypedCacheInterface<TValue> - Used for primary cache storage of
+// objects of type TValue.
+// * FullTypedCacheHelper<TValue, TCreateContext> - Used for secondary cache
+// compatible storage of objects of type TValue.
+// * For each of these, there's a "Shared" version
+// (e.g. FullTypedSharedCacheInterface) that holds a shared_ptr to the Cache,
+// rather than assuming external ownership by holding only a raw `Cache*`.
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+#include "cache/cache_helpers.h"
+#include "rocksdb/advanced_options.h"
+#include "rocksdb/cache.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// For future consideration:
+// * Pass in value to Insert with std::unique_ptr& to simplify ownership
+//   transfer logic in callers
+// * Make key type a template parameter (e.g. useful for table cache)
+// * Closer integration with CacheHandleGuard (opt-in, so not always
+//   paying the extra overhead)
+
+#define CACHE_TYPE_DEFS()                     \
+  using Priority = Cache::Priority;           \
+  using Handle = Cache::Handle;               \
+  using ObjectPtr = Cache::ObjectPtr;         \
+  using CreateContext = Cache::CreateContext; \
+  using CacheItemHelper = Cache::CacheItemHelper /* caller ; */
+
+template <typename CachePtr>
+class BaseCacheInterface {
+ public:
+  CACHE_TYPE_DEFS();
+
+  /*implicit*/ BaseCacheInterface(CachePtr cache) : cache_(std::move(cache)) {}
+
+  inline void Release(Handle* handle) { cache_->Release(handle); }
+
+  inline void ReleaseAndEraseIfLastRef(Handle* handle) {
+    cache_->Release(handle, /*erase_if_last_ref*/ true);
+  }
+
+  inline void RegisterReleaseAsCleanup(Handle* handle, Cleanable& cleanable) {
+    cleanable.RegisterCleanup(&ReleaseCacheHandleCleanup, get(), handle);
+  }
+
+  inline Cache* get() const { return &*cache_; }
+
+  explicit inline operator bool() const noexcept { return cache_ != nullptr; }
+
+ protected:
+  CachePtr cache_;
+};
+
+// PlaceholderCacheInterface - Used for making cache reservations, with
+// entries that have a charge but no value. CacheEntryRole is required as
+// a template parameter.
+template <CacheEntryRole kRole, typename CachePtr = Cache*>
+class PlaceholderCacheInterface : public BaseCacheInterface<CachePtr> {
+ public:
+  CACHE_TYPE_DEFS();
+  using BaseCacheInterface<CachePtr>::BaseCacheInterface;
+
+  inline Status Insert(const Slice& key, size_t charge, Handle** handle) {
+    return this->cache_->Insert(key, /*value=*/nullptr, &kHelper, charge,
+                                handle);
+  }
+
+  static constexpr Cache::CacheItemHelper kHelper{kRole};
+};
+
+template <CacheEntryRole kRole>
+using PlaceholderSharedCacheInterface =
+    PlaceholderCacheInterface<kRole, std::shared_ptr<Cache>>;
+
+template <class TValue>
+class BasicTypedCacheHelperFns {
+ public:
+  CACHE_TYPE_DEFS();
+  // E.g. char* for char[]
+  using TValuePtr = std::remove_extent_t<TValue>*;
+
+ protected:
+  inline static ObjectPtr UpCastValue(TValuePtr value) { return value; }
+  inline static TValuePtr DownCastValue(ObjectPtr value) {
+    return static_cast<TValuePtr>(value);
+  }
+
+  static void Delete(ObjectPtr value, MemoryAllocator* allocator) {
+    // FIXME: Currently, no callers actually allocate the ObjectPtr objects
+    // using the custom allocator, just subobjects that keep a reference to
+    // the allocator themselves (with CacheAllocationPtr).
+    if (/*DISABLED*/ false && allocator) {
+      if constexpr (std::is_destructible_v<TValue>) {
+        DownCastValue(value)->~TValue();
+      }
+      allocator->Deallocate(value);
+    } else {
+      // Like delete but properly handles TValue=char[] etc.
+      std::default_delete<TValue>{}(DownCastValue(value));
+    }
+  }
+};
+
+// In its own class to try to minimize the number of distinct CacheItemHelper
+// instances (e.g. don't vary by CachePtr)
+template <class TValue, CacheEntryRole kRole>
+class BasicTypedCacheHelper : public BasicTypedCacheHelperFns<TValue> {
+ public:
+  static constexpr Cache::CacheItemHelper kBasicHelper{
+      kRole, &BasicTypedCacheHelper::Delete};
+};
+
+// BasicTypedCacheInterface - Used for primary cache storage of objects of
+// type TValue, which can be cleaned up with std::default_delete<TValue>. The
+// role is provided by TValue::kCacheEntryRole or given in an optional
+// template parameter.
+template <class TValue, CacheEntryRole kRole = TValue::kCacheEntryRole,
+          typename CachePtr = Cache*>
+class BasicTypedCacheInterface : public BaseCacheInterface<CachePtr>,
+                                 public BasicTypedCacheHelper<TValue, kRole> {
+ public:
+  CACHE_TYPE_DEFS();
+  using typename BasicTypedCacheHelperFns<TValue>::TValuePtr;
+  struct TypedHandle : public Handle {};
+  using BasicTypedCacheHelper<TValue, kRole>::kBasicHelper;
+  // ctor
+  using BaseCacheInterface<CachePtr>::BaseCacheInterface;
+
+  inline Status Insert(const Slice& key, TValuePtr value, size_t charge,
+                       TypedHandle** handle = nullptr,
+                       Priority priority = Priority::LOW) {
+    auto untyped_handle = reinterpret_cast<Handle**>(handle);
+    return this->cache_->Insert(
+        key, BasicTypedCacheHelperFns<TValue>::UpCastValue(value),
+        &kBasicHelper, charge, untyped_handle, priority);
+  }
+
+  inline TypedHandle* Lookup(const Slice& key, Statistics* stats = nullptr) {
+    return reinterpret_cast<TypedHandle*>(
+        this->cache_->BasicLookup(key, stats));
+  }
+
+  inline CacheHandleGuard<TValue> Guard(TypedHandle* handle) {
+    if (handle) {
+      return CacheHandleGuard<TValue>(&*this->cache_, handle);
+    } else {
+      return {};
+    }
+  }
+
+  inline std::shared_ptr<TValue> SharedGuard(TypedHandle* handle) {
+    if (handle) {
+      return MakeSharedCacheHandleGuard<TValue>(&*this->cache_, handle);
+    } else {
+      return {};
+    }
+  }
+
+  inline TValuePtr Value(TypedHandle* handle) {
+    return BasicTypedCacheHelperFns<TValue>::DownCastValue(
+        this->cache_->Value(handle));
+  }
+};
+
+// BasicTypedSharedCacheInterface - Like BasicTypedCacheInterface but with a
+// shared_ptr<Cache> for keeping Cache alive.
+template <class TValue, CacheEntryRole kRole = TValue::kCacheEntryRole>
+using BasicTypedSharedCacheInterface =
+    BasicTypedCacheInterface<TValue, kRole, std::shared_ptr<Cache>>;
+
+// TValue must implement ContentSlice() and ~TValue
+// TCreateContext must implement Create(std::unique_ptr<TValue>*, ...)
+template <class TValue, class TCreateContext>
+class FullTypedCacheHelperFns : public BasicTypedCacheHelperFns<TValue> {
+ public:
+  CACHE_TYPE_DEFS();
+
+ protected:
+  using typename BasicTypedCacheHelperFns<TValue>::TValuePtr;
+  using BasicTypedCacheHelperFns<TValue>::DownCastValue;
+  using BasicTypedCacheHelperFns<TValue>::UpCastValue;
+
+  static size_t Size(ObjectPtr v) {
+    TValuePtr value = DownCastValue(v);
+    auto slice = value->ContentSlice();
+    return slice.size();
+  }
+
+  static Status SaveTo(ObjectPtr v, size_t from_offset, size_t length,
+                       char* out) {
+    TValuePtr value = DownCastValue(v);
+    auto slice = value->ContentSlice();
+    assert(from_offset < slice.size());
+    assert(from_offset + length <= slice.size());
+    std::copy_n(slice.data() + from_offset, length, out);
+    return Status::OK();
+  }
+
+  static Status Create(const Slice& data, CreateContext* context,
+                       MemoryAllocator* allocator, ObjectPtr* out_obj,
+                       size_t* out_charge) {
+    std::unique_ptr<TValue> value = nullptr;
+    if constexpr (sizeof(TCreateContext) > 0) {
+      TCreateContext* tcontext = static_cast<TCreateContext*>(context);
+      tcontext->Create(&value, out_charge, data, allocator);
+    } else {
+      TCreateContext::Create(&value, out_charge, data, allocator);
+    }
+    *out_obj = UpCastValue(value.release());
+    return Status::OK();
+  }
+};
+
+// In its own class to try to minimize the number of distinct CacheItemHelper
+// instances (e.g. don't vary by CachePtr)
+template <class TValue, class TCreateContext, CacheEntryRole kRole>
+class FullTypedCacheHelper
+    : public FullTypedCacheHelperFns<TValue, TCreateContext> {
+ public:
+  static constexpr Cache::CacheItemHelper kFullHelper{
+      kRole, &FullTypedCacheHelper::Delete, &FullTypedCacheHelper::Size,
+      &FullTypedCacheHelper::SaveTo, &FullTypedCacheHelper::Create};
+};
+
+// FullTypedCacheHelper - Used for secondary cache compatible storage of
+// objects of type TValue. In addition to BasicTypedCacheInterface constraints,
+// we require TValue::ContentSlice() to return persistable data. This
+// simplifies usage for the normal case of simple secondary cache compatibility
+// (can give you a Slice to the data already in memory). In addition to
+// TCreateContext performing the role of Cache::CreateContext, it is also
+// expected to provide a function Create(std::unique_ptr<TValue>* value,
+// size_t* out_charge, const Slice& data, MemoryAllocator* allocator) for
+// creating new TValue.
+template <class TValue, class TCreateContext,
+          CacheEntryRole kRole = TValue::kCacheEntryRole,
+          typename CachePtr = Cache*>
+class FullTypedCacheInterface
+    : public BasicTypedCacheInterface<TValue, kRole, CachePtr>,
+      public FullTypedCacheHelper<TValue, TCreateContext, kRole> {
+ public:
+  CACHE_TYPE_DEFS();
+  using typename BasicTypedCacheInterface<TValue, kRole, CachePtr>::TypedHandle;
+  using typename BasicTypedCacheHelperFns<TValue>::TValuePtr;
+  using BasicTypedCacheHelper<TValue, kRole>::kBasicHelper;
+  using FullTypedCacheHelper<TValue, TCreateContext, kRole>::kFullHelper;
+  using BasicTypedCacheHelperFns<TValue>::UpCastValue;
+  using BasicTypedCacheHelperFns<TValue>::DownCastValue;
+  // ctor
+  using BasicTypedCacheInterface<TValue, kRole,
+                                 CachePtr>::BasicTypedCacheInterface;
+
+  // Insert with SecondaryCache compatibility (subject to CacheTier).
+  // (Basic Insert() also inherited.)
+  inline Status InsertFull(
+      const Slice& key, TValuePtr value, size_t charge,
+      TypedHandle** handle = nullptr, Priority priority = Priority::LOW,
+      CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier) {
+    auto untyped_handle = reinterpret_cast<Handle**>(handle);
+    auto helper = lowest_used_cache_tier == CacheTier::kNonVolatileBlockTier
+                      ? &kFullHelper
+                      : &kBasicHelper;
+    return this->cache_->Insert(key, UpCastValue(value), helper, charge,
+                                untyped_handle, priority);
+  }
+
+  // Like SecondaryCache::InsertSaved, with SecondaryCache compatibility
+  // (subject to CacheTier).
+  inline Status InsertSaved(
+      const Slice& key, const Slice& data, TCreateContext* create_context,
+      Priority priority = Priority::LOW,
+      CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier,
+      size_t* out_charge = nullptr) {
+    ObjectPtr value;
+    size_t charge;
+    Status st = kFullHelper.create_cb(data, create_context,
+                                      this->cache_->memory_allocator(), &value,
+                                      &charge);
+    if (out_charge) {
+      *out_charge = charge;
+    }
+    if (st.ok()) {
+      st = InsertFull(key, DownCastValue(value), charge, nullptr /*handle*/,
+                      priority, lowest_used_cache_tier);
+    } else {
+      kFullHelper.del_cb(value, this->cache_->memory_allocator());
+    }
+    return st;
+  }
+
+  // Lookup with SecondaryCache support (subject to CacheTier).
+  // (Basic Lookup() also inherited.)
+  inline TypedHandle* LookupFull(
+      const Slice& key, TCreateContext* create_context = nullptr,
+      Priority priority = Priority::LOW, bool wait = true,
+      Statistics* stats = nullptr,
+      CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier) {
+    if (lowest_used_cache_tier == CacheTier::kNonVolatileBlockTier) {
+      return reinterpret_cast<TypedHandle*>(this->cache_->Lookup(
+          key, &kFullHelper, create_context, priority, wait, stats));
+    } else {
+      return BasicTypedCacheInterface<TValue, kRole, CachePtr>::Lookup(key,
+                                                                       stats);
+    }
+  }
+};
+
+// FullTypedSharedCacheInterface - Like FullTypedCacheInterface but with a
+// shared_ptr<Cache> for keeping Cache alive.
+template <class TValue, class TCreateContext,
+          CacheEntryRole kRole = TValue::kCacheEntryRole>
+using FullTypedSharedCacheInterface =
+    FullTypedCacheInterface<TValue, TCreateContext, kRole,
+                            std::shared_ptr<Cache>>;
+
+#undef CACHE_TYPE_DEFS
+
+}  // namespace ROCKSDB_NAMESPACE
@@ -8,7 +8,7 @@ DB_STRESS_CMD?=./db_stress
 include common.mk

 CRASHTEST_MAKE=$(MAKE) -f crash_test.mk
-CRASHTEST_PY=$(PYTHON) -u tools/db_crashtest.py --stress_cmd=$(DB_STRESS_CMD)
+CRASHTEST_PY=$(PYTHON) -u tools/db_crashtest.py --stress_cmd=$(DB_STRESS_CMD) --cleanup_cmd='$(DB_CLEANUP_CMD)'

 .PHONY: crash_test crash_test_with_atomic_flush crash_test_with_txn \
 	crash_test_with_best_efforts_recovery crash_test_with_ts \
@@ -8,6 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/arena_wrapped_db_iter.h"
+
 #include "memory/arena.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
@@ -9,7 +9,9 @@

 #pragma once
 #include <stdint.h>
+
 #include <string>
+
 #include "db/db_impl/db_impl.h"
 #include "db/db_iter.h"
 #include "db/range_del_aggregator.h"
@@ -13,12 +13,6 @@

 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;

@@ -45,46 +39,4 @@ size_t BlobContents::ApproximateMemoryUsage() const {
  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
@@ -18,8 +18,8 @@ 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(CacheAllocationPtr&& allocation, size_t size)
+      : allocation_(std::move(allocation)), data_(allocation_.get(), size) {}

  BlobContents(const BlobContents&) = delete;
  BlobContents& operator=(const BlobContents&) = delete;
@@ -34,23 +34,26 @@ class BlobContents {

  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);
+  // For TypedCacheInterface
+  const Slice& ContentSlice() const { return data_; }
+  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kBlobValue;

 private:
-  BlobContents(CacheAllocationPtr&& allocation, size_t size)
-      : allocation_(std::move(allocation)), data_(allocation_.get(), size) {}
-
  CacheAllocationPtr allocation_;
  Slice data_;
 };

+class BlobContentsCreator : public Cache::CreateContext {
+ public:
+  static void Create(std::unique_ptr<BlobContents>* out, size_t* out_charge,
+                     const Slice& contents, MemoryAllocator* alloc) {
+    auto raw = new BlobContents(AllocateAndCopyBlock(contents, alloc),
+                                contents.size());
+    out->reset(raw);
+    if (out_charge) {
+      *out_charge = raw->ApproximateMemoryUsage();
+    }
+  }
+};
+
 }  // namespace ROCKSDB_NAMESPACE
@@ -13,6 +13,7 @@
 #include "db/blob/blob_index.h"
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
+#include "db/blob/blob_source.h"
 #include "db/event_helpers.h"
 #include "db/version_set.h"
 #include "file/filename.h"
@@ -393,7 +394,7 @@ Status BlobFileBuilder::PutBlobIntoCacheIfNeeded(const Slice& blob,
                                                 uint64_t blob_offset) const {
  Status s = Status::OK();

-  auto blob_cache = immutable_options_->blob_cache;
+  BlobSource::SharedCacheInterface blob_cache{immutable_options_->blob_cache};
  auto statistics = immutable_options_->statistics.get();
  bool warm_cache =
      prepopulate_blob_cache_ == PrepopulateBlobCache::kFlushOnly &&
@@ -407,34 +408,12 @@ Status BlobFileBuilder::PutBlobIntoCacheIfNeeded(const Slice& blob,

    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);
-    }
+    s = blob_cache.InsertSaved(key, blob, nullptr /*context*/, priority,
+                               immutable_options_->lowest_used_cache_tier);

    if (s.ok()) {
      RecordTick(statistics, BLOB_DB_CACHE_ADD);
-      RecordTick(statistics, BLOB_DB_CACHE_BYTES_WRITE, buf->size());
-      buf.release();
+      RecordTick(statistics, BLOB_DB_CACHE_BYTES_WRITE, blob.size());
    } else {
      RecordTick(statistics, BLOB_DB_CACHE_ADD_FAILURES);
    }
@@ -42,13 +42,13 @@ Status BlobFileCache::GetBlobFileReader(
  assert(blob_file_reader);
  assert(blob_file_reader->IsEmpty());

-  const Slice key = GetSlice(&blob_file_number);
+  const Slice key = GetSliceForKey(&blob_file_number);

  assert(cache_);

-  Cache::Handle* handle = cache_->Lookup(key);
+  TypedHandle* handle = cache_.Lookup(key);
  if (handle) {
-    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
+    *blob_file_reader = cache_.Guard(handle);
    return Status::OK();
  }

@@ -57,9 +57,9 @@ Status BlobFileCache::GetBlobFileReader(
  // Check again while holding mutex
  MutexLock lock(mutex_.get(key));

-  handle = cache_->Lookup(key);
+  handle = cache_.Lookup(key);
  if (handle) {
-    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
+    *blob_file_reader = cache_.Guard(handle);
    return Status::OK();
  }

@@ -84,8 +84,7 @@ Status BlobFileCache::GetBlobFileReader(
  {
    constexpr size_t charge = 1;

-    const Status s = cache_->Insert(key, reader.get(), charge,
-                                    &DeleteCacheEntry<BlobFileReader>, &handle);
+    const Status s = cache_.Insert(key, reader.get(), charge, &handle);
    if (!s.ok()) {
      RecordTick(statistics, NO_FILE_ERRORS);
      return s;
@@ -94,7 +93,7 @@ Status BlobFileCache::GetBlobFileReader(

  reader.release();

-  *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
+  *blob_file_reader = cache_.Guard(handle);

  return Status::OK();
 }
@@ -7,7 +7,8 @@

 #include <cinttypes>

-#include "cache/cache_helpers.h"
+#include "cache/typed_cache.h"
+#include "db/blob/blob_file_reader.h"
 #include "rocksdb/rocksdb_namespace.h"
 #include "util/mutexlock.h"

@@ -18,7 +19,6 @@ struct ImmutableOptions;
 struct FileOptions;
 class HistogramImpl;
 class Status;
-class BlobFileReader;
 class Slice;
 class IOTracer;

@@ -36,7 +36,10 @@ class BlobFileCache {
                           CacheHandleGuard<BlobFileReader>* blob_file_reader);

 private:
-  Cache* cache_;
+  using CacheInterface =
+      BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
+  using TypedHandle = CacheInterface::TypedHandle;
+  CacheInterface cache_;
  // Note: mutex_ below is used to guard against multiple threads racing to open
  // the same file.
  Striped<port::Mutex, Slice> mutex_;
@@ -23,32 +23,19 @@ class BlobFileCompletionCallback {
      const std::vector<std::shared_ptr<EventListener>>& listeners,
      const std::string& dbname)
      : event_logger_(event_logger), listeners_(listeners), dbname_(dbname) {
-#ifndef ROCKSDB_LITE
    sst_file_manager_ = sst_file_manager;
    mutex_ = mutex;
    error_handler_ = error_handler;
-#else
-    (void)sst_file_manager;
-    (void)mutex;
-    (void)error_handler;
-#endif  // ROCKSDB_LITE
  }

  void OnBlobFileCreationStarted(const std::string& file_name,
                                 const std::string& column_family_name,
                                 int job_id,
                                 BlobFileCreationReason creation_reason) {
-#ifndef ROCKSDB_LITE
    // Notify the listeners.
    EventHelpers::NotifyBlobFileCreationStarted(listeners_, dbname_,
                                                column_family_name, file_name,
                                                job_id, creation_reason);
-#else
-    (void)file_name;
-    (void)column_family_name;
-    (void)job_id;
-    (void)creation_reason;
-#endif
  }

  Status OnBlobFileCompleted(const std::string& file_name,
@@ -61,7 +48,6 @@ class BlobFileCompletionCallback {
                             uint64_t blob_count, uint64_t blob_bytes) {
    Status s;

-#ifndef ROCKSDB_LITE
    auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager_);
    if (sfm) {
      // Report new blob files to SstFileManagerImpl
@@ -74,7 +60,6 @@ class BlobFileCompletionCallback {
        error_handler_->SetBGError(s, BackgroundErrorReason::kFlush);
      }
    }
-#endif  // !ROCKSDB_LITE

    // Notify the listeners.
    EventHelpers::LogAndNotifyBlobFileCreationFinished(
@@ -89,11 +74,9 @@ class BlobFileCompletionCallback {
  }

 private:
-#ifndef ROCKSDB_LITE
  SstFileManager* sst_file_manager_;
  InstrumentedMutex* mutex_;
  ErrorHandler* error_handler_;
-#endif  // ROCKSDB_LITE
  EventLogger* event_logger_;
  std::vector<std::shared_ptr<EventListener>> listeners_;
  std::string dbname_;
@@ -569,12 +569,7 @@ Status BlobFileReader::UncompressBlobIfNeeded(
  assert(result);

  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());
-
+    BlobContentsCreator::Create(result, nullptr, value_slice, allocator);
    return Status::OK();
  }

@@ -602,7 +597,7 @@ Status BlobFileReader::UncompressBlobIfNeeded(
    return Status::Corruption("Unable to uncompress blob");
  }

-  *result = BlobContents::Create(std::move(output), uncompressed_size);
+  result->reset(new BlobContents(std::move(output), uncompressed_size));

  return Status::OK();
 }
@@ -22,6 +22,8 @@ constexpr uint32_t kVersion1 = 1;

 using ExpirationRange = std::pair<uint64_t, uint64_t>;

+// clang-format off
+
 // Format of blob log file header (30 bytes):
 //
 //    +--------------+---------+---------+-------+-------------+-------------------+
@@ -35,6 +37,9 @@ using ExpirationRange = std::pair<uint64_t, uint64_t>;
 //
 // Expiration range in the header is a rough range based on
 // blob_db_options.ttl_range_secs.
+
+// clang-format on
+
 struct BlobLogHeader {
  static constexpr size_t kSize = 30;

@@ -57,6 +62,8 @@ struct BlobLogHeader {
  Status DecodeFrom(Slice slice);
 };

+// clang-format off
+
 // Format of blob log file footer (32 bytes):
 //
 //    +--------------+------------+-------------------+------------+
@@ -69,6 +76,9 @@ struct BlobLogHeader {
 //
 // Unlike the same field in file header, expiration range in the footer is the
 // range of smallest and largest expiration of the data in this file.
+
+// clang-format on
+
 struct BlobLogFooter {
  static constexpr size_t kSize = 32;

@@ -81,6 +91,8 @@ struct BlobLogFooter {
  Status DecodeFrom(Slice slice);
 };

+// clang-format off
+
 // Blob record format (32 bytes header + key + value):
 //
 //    +------------+--------------+------------+------------+----------+---------+-----------+
@@ -100,6 +112,9 @@ struct BlobLogFooter {
 //
 // We could use variable length encoding (Varint64) to save more space, but it
 // make reader more complicated.
+
+// clang-format on
+
 struct BlobLogRecord {
  // header include fields up to blob CRC
  static constexpr size_t kHeaderSize = 32;
@@ -30,16 +30,14 @@ BlobSource::BlobSource(const ImmutableOptions* immutable_options,
      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);
+    blob_cache_ = SharedCacheInterface{std::make_shared<ChargedCache>(
+        immutable_options->blob_cache, bbto->block_cache)};
  }
-#endif  // ROCKSDB_LITE
 }

 BlobSource::~BlobSource() = default;
@@ -82,9 +80,8 @@ Status BlobSource::PutBlobIntoCache(
  assert(cached_blob);
  assert(cached_blob->IsEmpty());

-  Cache::Handle* cache_handle = nullptr;
+  TypedHandle* cache_handle = nullptr;
  const Status s = InsertEntryIntoCache(cache_key, blob->get(),
-                                        (*blob)->ApproximateMemoryUsage(),
                                        &cache_handle, Cache::Priority::BOTTOM);
  if (s.ok()) {
    blob->release();
@@ -106,26 +103,10 @@ Status BlobSource::PutBlobIntoCache(
  return s;
 }

-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_);
-  } else {
-    cache_handle = blob_cache_->Lookup(key, statistics_);
-  }
-
-  return cache_handle;
+BlobSource::TypedHandle* BlobSource::GetEntryFromCache(const Slice& key) const {
+  return blob_cache_.LookupFull(
+      key, nullptr /* context */, Cache::Priority::BOTTOM,
+      true /* wait_for_cache */, statistics_, lowest_used_cache_tier_);
 }

 void BlobSource::PinCachedBlob(CacheHandleGuard<BlobContents>* cached_blob,
@@ -166,24 +147,11 @@ void BlobSource::PinOwnedBlob(std::unique_ptr<BlobContents>* owned_blob,
 }

 Status BlobSource::InsertEntryIntoCache(const Slice& key, BlobContents* value,
-                                        size_t charge,
-                                        Cache::Handle** cache_handle,
+                                        TypedHandle** 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);
-  } else {
-    s = blob_cache_->Insert(key, value, charge, cache_item_helper->del_cb,
-                            cache_handle, priority);
-  }
-
-  return s;
+  return blob_cache_.InsertFull(key, value, value->ApproximateMemoryUsage(),
+                                cache_handle, priority,
+                                lowest_used_cache_tier_);
 }

 Status BlobSource::GetBlob(const ReadOptions& read_options,
@@ -252,9 +220,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;
+    MemoryAllocator* const allocator =
+        (blob_cache_ && read_options.fill_cache)
+            ? blob_cache_.get()->memory_allocator()
+            : nullptr;

    uint64_t read_size = 0;
    s = blob_file_reader.GetValue()->GetBlob(
@@ -418,9 +387,10 @@ void BlobSource::MultiGetBlobFromOneFile(const ReadOptions& read_options,

    assert(blob_file_reader.GetValue());

-    MemoryAllocator* const allocator = (blob_cache_ && read_options.fill_cache)
-                                           ? blob_cache_->memory_allocator()
-                                           : nullptr;
+    MemoryAllocator* const allocator =
+        (blob_cache_ && read_options.fill_cache)
+            ? blob_cache_.get()->memory_allocator()
+            : nullptr;

    blob_file_reader.GetValue()->MultiGetBlob(read_options, allocator,
                                              _blob_reqs, &_bytes_read);
@@ -8,8 +8,9 @@
 #include <cinttypes>
 #include <memory>

-#include "cache/cache_helpers.h"
 #include "cache/cache_key.h"
+#include "cache/typed_cache.h"
+#include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_cache.h"
 #include "db/blob/blob_read_request.h"
 #include "rocksdb/cache.h"
@@ -23,7 +24,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.
@@ -106,6 +106,14 @@ class BlobSource {
  bool TEST_BlobInCache(uint64_t file_number, uint64_t file_size,
                        uint64_t offset, size_t* charge = nullptr) const;

+  // For TypedSharedCacheInterface
+  void Create(BlobContents** out, const char* buf, size_t size,
+              MemoryAllocator* alloc);
+
+  using SharedCacheInterface =
+      FullTypedSharedCacheInterface<BlobContents, BlobContentsCreator>;
+  using TypedHandle = SharedCacheInterface::TypedHandle;
+
 private:
  Status GetBlobFromCache(const Slice& cache_key,
                          CacheHandleGuard<BlobContents>* cached_blob) const;
@@ -120,10 +128,10 @@ class BlobSource {
  static void PinOwnedBlob(std::unique_ptr<BlobContents>* owned_blob,
                           PinnableSlice* value);

-  Cache::Handle* GetEntryFromCache(const Slice& key) const;
+  TypedHandle* GetEntryFromCache(const Slice& key) const;

  Status InsertEntryIntoCache(const Slice& key, BlobContents* value,
-                              size_t charge, Cache::Handle** cache_handle,
+                              TypedHandle** cache_handle,
                              Cache::Priority priority) const;

  inline CacheKey GetCacheKey(uint64_t file_number, uint64_t /*file_size*/,
@@ -141,7 +149,7 @@ class BlobSource {
  BlobFileCache* blob_file_cache_;

  // A cache to store uncompressed blobs.
-  std::shared_ptr<Cache> blob_cache_;
+  mutable SharedCacheInterface 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
@@ -1150,15 +1150,6 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
  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());
@@ -1219,14 +1210,15 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
    {
      CacheKey cache_key = base_cache_key.WithOffset(blob_offsets[0]);
      const Slice key0 = cache_key.AsSlice();
-      auto handle0 = blob_cache->Lookup(key0, statistics);
+      auto handle0 = blob_cache->BasicLookup(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);
+      auto sec_handle0 = secondary_cache->Lookup(
+          key0, &BlobSource::SharedCacheInterface::kFullHelper,
+          /*context*/ nullptr, true,
+          /*advise_erase=*/true, is_in_sec_cache);
      ASSERT_FALSE(is_in_sec_cache);
      ASSERT_NE(sec_handle0, nullptr);
      ASSERT_TRUE(sec_handle0->IsReady());
@@ -1246,14 +1238,15 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
    {
      CacheKey cache_key = base_cache_key.WithOffset(blob_offsets[1]);
      const Slice key1 = cache_key.AsSlice();
-      auto handle1 = blob_cache->Lookup(key1, statistics);
+      auto handle1 = blob_cache->BasicLookup(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);
+      auto sec_handle1 = secondary_cache->Lookup(
+          key1, &BlobSource::SharedCacheInterface::kFullHelper,
+          /*context*/ nullptr, true,
+          /*advise_erase=*/true, is_in_sec_cache);
      ASSERT_FALSE(is_in_sec_cache);
      ASSERT_EQ(sec_handle1, nullptr);

@@ -1276,7 +1269,7 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
      // 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);
+      auto handle0 = blob_cache->BasicLookup(key0, statistics);
      ASSERT_NE(handle0, nullptr);
      auto value = static_cast<BlobContents*>(blob_cache->Value(handle0));
      ASSERT_NE(value, nullptr);
@@ -1286,12 +1279,12 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
      // 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);
+      auto handle1 = blob_cache->BasicLookup(key1, statistics);
      ASSERT_EQ(handle1, nullptr);

      // erase key0 from the primary cache.
      blob_cache->Erase(key0);
-      handle0 = blob_cache->Lookup(key0, statistics);
+      handle0 = blob_cache->BasicLookup(key0, statistics);
      ASSERT_EQ(handle0, nullptr);

      // key1 promotion should succeed due to the primary cache being empty. we
@@ -1307,7 +1300,7 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
      // in the secondary cache. So, the primary cache's Lookup() without
      // secondary cache support cannot see it. (NOTE: The dummy handle used
      // to be a leaky abstraction but not anymore.)
-      handle1 = blob_cache->Lookup(key1, statistics);
+      handle1 = blob_cache->BasicLookup(key1, statistics);
      ASSERT_EQ(handle1, nullptr);

      // But after another access, it is promoted to primary cache
@@ -1315,7 +1308,7 @@ TEST_F(BlobSecondaryCacheTest, GetBlobsFromSecondaryCache) {
                                               blob_offsets[1]));

      // And Lookup() can find it (without secondary cache support)
-      handle1 = blob_cache->Lookup(key1, statistics);
+      handle1 = blob_cache->BasicLookup(key1, statistics);
      ASSERT_NE(handle1, nullptr);
      ASSERT_NE(blob_cache->Value(handle1), nullptr);
      blob_cache->Release(handle1);
@@ -1398,7 +1391,6 @@ class BlobSourceCacheReservationTest : public DBTestBase {
  std::string db_session_id_;
 };

-#ifndef ROCKSDB_LITE
 TEST_F(BlobSourceCacheReservationTest, SimpleCacheReservation) {
  options_.cf_paths.emplace_back(
      test::PerThreadDBPath(
@@ -1613,7 +1605,6 @@ TEST_F(BlobSourceCacheReservationTest, IncreaseCacheReservationOnFullCache) {
    }
  }
 }
-#endif  // ROCKSDB_LITE

 }  // namespace ROCKSDB_NAMESPACE

@@ -11,6 +11,7 @@
 #include "db/blob/blob_index.h"
 #include "db/blob/blob_log_format.h"
 #include "db/db_test_util.h"
+#include "db/db_with_timestamp_test_util.h"
 #include "port/stack_trace.h"
 #include "test_util/sync_point.h"
 #include "utilities/fault_injection_env.h"
@@ -584,7 +585,6 @@ TEST_F(DBBlobBasicTest, MultiGetBlobsFromCache) {
  }
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBlobBasicTest, MultiGetWithDirectIO) {
  Options options = GetDefaultOptions();

@@ -773,13 +773,12 @@ TEST_F(DBBlobBasicTest, MultiGetWithDirectIO) {
    ASSERT_EQ(values[2], second_blob);
  }
 }
-#endif  // !ROCKSDB_LITE

 TEST_F(DBBlobBasicTest, MultiGetBlobsFromMultipleFiles) {
  Options options = GetDefaultOptions();

  LRUCacheOptions co;
-  co.capacity = 2 << 20; // 2MB
+  co.capacity = 2 << 20;  // 2MB
  co.num_shard_bits = 2;
  co.metadata_charge_policy = kDontChargeCacheMetadata;
  auto backing_cache = NewLRUCache(co);
@@ -1062,7 +1061,6 @@ TEST_F(DBBlobBasicTest, GetBlob_IndexWithInvalidFileNumber) {
                  .IsCorruption());
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBlobBasicTest, GenerateIOTracing) {
  Options options = GetDefaultOptions();
  options.enable_blob_files = true;
@@ -1117,7 +1115,6 @@ TEST_F(DBBlobBasicTest, GenerateIOTracing) {
    ASSERT_GT(blob_files_op_count, 2);
  }
 }
-#endif  // !ROCKSDB_LITE

 TEST_F(DBBlobBasicTest, BestEffortsRecovery_MissingNewestBlobFile) {
  Options options = GetDefaultOptions();
@@ -1219,7 +1216,6 @@ TEST_F(DBBlobBasicTest, MultiGetMergeBlobWithPut) {
  ASSERT_EQ(values[2], "v2_0");
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBlobBasicTest, Properties) {
  Options options = GetDefaultOptions();
  options.enable_blob_files = true;
@@ -1382,7 +1378,6 @@ TEST_F(DBBlobBasicTest, PropertiesMultiVersion) {
                 BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size) +
                 blob_size + BlobLogFooter::kSize));
 }
-#endif  // !ROCKSDB_LITE

 class DBBlobBasicIOErrorTest : public DBBlobBasicTest,
                               public testing::WithParamInterface<std::string> {
@@ -1632,7 +1627,6 @@ TEST_F(DBBlobBasicTest, WarmCacheWithBlobsDuringFlush) {
            options.statistics->getTickerCount(BLOB_DB_CACHE_ADD));
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBlobBasicTest, DynamicallyWarmCacheDuringFlush) {
  Options options = GetDefaultOptions();

@@ -1700,7 +1694,6 @@ TEST_F(DBBlobBasicTest, DynamicallyWarmCacheDuringFlush) {
                              /*end=*/nullptr));
  EXPECT_EQ(0, options.statistics->getTickerCount(BLOB_DB_CACHE_ADD));
 }
-#endif  // !ROCKSDB_LITE

 TEST_F(DBBlobBasicTest, WarmCacheWithBlobsSecondary) {
  CompressedSecondaryCacheOptions secondary_cache_opts;
@@ -1779,6 +1772,212 @@ TEST_F(DBBlobBasicTest, WarmCacheWithBlobsSecondary) {
            1);
 }

+TEST_F(DBBlobBasicTest, GetEntityBlob) {
+  Options options = GetDefaultOptions();
+  options.enable_blob_files = true;
+  options.min_blob_size = 0;
+
+  Reopen(options);
+
+  constexpr char key[] = "key";
+  constexpr char blob_value[] = "blob_value";
+
+  ASSERT_OK(Put(key, blob_value));
+
+  ASSERT_OK(Flush());
+
+  PinnableWideColumns result;
+  ASSERT_OK(
+      db_->GetEntity(ReadOptions(), db_->DefaultColumnFamily(), key, &result));
+
+  WideColumns expected_columns{{kDefaultWideColumnName, blob_value}};
+  ASSERT_EQ(result.columns(), expected_columns);
+}
+
+class DBBlobWithTimestampTest : public DBBasicTestWithTimestampBase {
+ protected:
+  DBBlobWithTimestampTest()
+      : DBBasicTestWithTimestampBase("db_blob_with_timestamp_test") {}
+};
+
+TEST_F(DBBlobWithTimestampTest, GetBlob) {
+  Options options = GetDefaultOptions();
+  options.create_if_missing = true;
+  options.enable_blob_files = true;
+  options.min_blob_size = 0;
+  const size_t kTimestampSize = Timestamp(0, 0).size();
+  TestComparator test_cmp(kTimestampSize);
+  options.comparator = &test_cmp;
+
+  DestroyAndReopen(options);
+  WriteOptions write_opts;
+  const std::string ts = Timestamp(1, 0);
+  constexpr char key[] = "key";
+  constexpr char blob_value[] = "blob_value";
+
+  ASSERT_OK(db_->Put(write_opts, key, ts, blob_value));
+
+  ASSERT_OK(Flush());
+
+  const std::string read_ts = Timestamp(2, 0);
+  Slice read_ts_slice(read_ts);
+  ReadOptions read_opts;
+  read_opts.timestamp = &read_ts_slice;
+  std::string value;
+  ASSERT_OK(db_->Get(read_opts, key, &value));
+  ASSERT_EQ(value, blob_value);
+}
+
+TEST_F(DBBlobWithTimestampTest, MultiGetBlobs) {
+  constexpr size_t min_blob_size = 6;
+
+  Options options = GetDefaultOptions();
+  options.enable_blob_files = true;
+  options.min_blob_size = min_blob_size;
+  options.create_if_missing = true;
+  const size_t kTimestampSize = Timestamp(0, 0).size();
+  TestComparator test_cmp(kTimestampSize);
+  options.comparator = &test_cmp;
+
+  DestroyAndReopen(options);
+
+  // Put then retrieve three key-values. The first value is below the size limit
+  // and is thus stored inline; the other two are stored separately as blobs.
+  constexpr size_t num_keys = 3;
+
+  constexpr char first_key[] = "first_key";
+  constexpr char first_value[] = "short";
+  static_assert(sizeof(first_value) - 1 < min_blob_size,
+                "first_value too long to be inlined");
+
+  DestroyAndReopen(options);
+  WriteOptions write_opts;
+  const std::string ts = Timestamp(1, 0);
+  ASSERT_OK(db_->Put(write_opts, first_key, ts, first_value));
+
+  constexpr char second_key[] = "second_key";
+  constexpr char second_value[] = "long_value";
+  static_assert(sizeof(second_value) - 1 >= min_blob_size,
+                "second_value too short to be stored as blob");
+
+  ASSERT_OK(db_->Put(write_opts, second_key, ts, 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(db_->Put(write_opts, third_key, ts, third_value));
+
+  ASSERT_OK(Flush());
+
+  ReadOptions read_options;
+  const std::string read_ts = Timestamp(2, 0);
+  Slice read_ts_slice(read_ts);
+  read_options.timestamp = &read_ts_slice;
+  std::array<Slice, num_keys> keys{{first_key, second_key, third_key}};
+
+  {
+    std::array<PinnableSlice, num_keys> values;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGet(read_options, db_->DefaultColumnFamily(), num_keys, &keys[0],
+                  &values[0], &statuses[0]);
+
+    ASSERT_OK(statuses[0]);
+    ASSERT_EQ(values[0], first_value);
+
+    ASSERT_OK(statuses[1]);
+    ASSERT_EQ(values[1], second_value);
+
+    ASSERT_OK(statuses[2]);
+    ASSERT_EQ(values[2], third_value);
+  }
+}
+
+TEST_F(DBBlobWithTimestampTest, GetMergeBlobWithPut) {
+  Options options = GetDefaultOptions();
+  options.merge_operator = MergeOperators::CreateStringAppendOperator();
+  options.enable_blob_files = true;
+  options.min_blob_size = 0;
+  options.create_if_missing = true;
+  const size_t kTimestampSize = Timestamp(0, 0).size();
+  TestComparator test_cmp(kTimestampSize);
+  options.comparator = &test_cmp;
+
+  DestroyAndReopen(options);
+
+  WriteOptions write_opts;
+  const std::string ts = Timestamp(1, 0);
+  ASSERT_OK(db_->Put(write_opts, "Key1", ts, "v1"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(
+      db_->Merge(write_opts, db_->DefaultColumnFamily(), "Key1", ts, "v2"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(
+      db_->Merge(write_opts, db_->DefaultColumnFamily(), "Key1", ts, "v3"));
+  ASSERT_OK(Flush());
+
+  std::string value;
+  const std::string read_ts = Timestamp(2, 0);
+  Slice read_ts_slice(read_ts);
+  ReadOptions read_opts;
+  read_opts.timestamp = &read_ts_slice;
+  ASSERT_OK(db_->Get(read_opts, "Key1", &value));
+  ASSERT_EQ(value, "v1,v2,v3");
+}
+
+TEST_F(DBBlobWithTimestampTest, MultiGetMergeBlobWithPut) {
+  constexpr size_t num_keys = 3;
+
+  Options options = GetDefaultOptions();
+  options.merge_operator = MergeOperators::CreateStringAppendOperator();
+  options.enable_blob_files = true;
+  options.min_blob_size = 0;
+  options.create_if_missing = true;
+  const size_t kTimestampSize = Timestamp(0, 0).size();
+  TestComparator test_cmp(kTimestampSize);
+  options.comparator = &test_cmp;
+
+  DestroyAndReopen(options);
+
+  WriteOptions write_opts;
+  const std::string ts = Timestamp(1, 0);
+
+  ASSERT_OK(db_->Put(write_opts, "Key0", ts, "v0_0"));
+  ASSERT_OK(db_->Put(write_opts, "Key1", ts, "v1_0"));
+  ASSERT_OK(db_->Put(write_opts, "Key2", ts, "v2_0"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(
+      db_->Merge(write_opts, db_->DefaultColumnFamily(), "Key0", ts, "v0_1"));
+  ASSERT_OK(
+      db_->Merge(write_opts, db_->DefaultColumnFamily(), "Key1", ts, "v1_1"));
+  ASSERT_OK(Flush());
+  ASSERT_OK(
+      db_->Merge(write_opts, db_->DefaultColumnFamily(), "Key0", ts, "v0_2"));
+  ASSERT_OK(Flush());
+
+  const std::string read_ts = Timestamp(2, 0);
+  Slice read_ts_slice(read_ts);
+  ReadOptions read_opts;
+  read_opts.timestamp = &read_ts_slice;
+  std::array<Slice, num_keys> keys{{"Key0", "Key1", "Key2"}};
+  std::array<PinnableSlice, num_keys> values;
+  std::array<Status, num_keys> statuses;
+
+  db_->MultiGet(read_opts, db_->DefaultColumnFamily(), num_keys, &keys[0],
+                &values[0], &statuses[0]);
+
+  ASSERT_OK(statuses[0]);
+  ASSERT_EQ(values[0], "v0_0,v0_1,v0_2");
+
+  ASSERT_OK(statuses[1]);
+  ASSERT_EQ(values[1], "v1_0,v1_1");
+
+  ASSERT_OK(statuses[2]);
+  ASSERT_EQ(values[2], "v2_0");
+}
+
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -16,7 +16,6 @@ class DBBlobCompactionTest : public DBTestBase {
  explicit DBBlobCompactionTest()
      : DBTestBase("db_blob_compaction_test", /*env_do_fsync=*/false) {}

-#ifndef ROCKSDB_LITE
  const std::vector<InternalStats::CompactionStats>& GetCompactionStats() {
    VersionSet* const versions = dbfull()->GetVersionSet();
    assert(versions);
@@ -30,7 +29,6 @@ class DBBlobCompactionTest : public DBTestBase {

    return internal_stats->TEST_GetCompactionStats();
  }
-#endif  // ROCKSDB_LITE
 };

 namespace {
@@ -250,7 +248,6 @@ TEST_F(DBBlobCompactionTest, FilterByKeyLength) {
  ASSERT_OK(db_->Get(ReadOptions(), long_key, &value));
  ASSERT_EQ("value", value);

-#ifndef ROCKSDB_LITE
  const auto& compaction_stats = GetCompactionStats();
  ASSERT_GE(compaction_stats.size(), 2);

@@ -258,7 +255,6 @@ TEST_F(DBBlobCompactionTest, FilterByKeyLength) {
  // this involves neither reading nor writing blobs
  ASSERT_EQ(compaction_stats[1].bytes_read_blob, 0);
  ASSERT_EQ(compaction_stats[1].bytes_written_blob, 0);
-#endif  // ROCKSDB_LITE

  Close();
 }
@@ -299,7 +295,6 @@ TEST_F(DBBlobCompactionTest, FilterByValueLength) {
    ASSERT_EQ(long_value, value);
  }

-#ifndef ROCKSDB_LITE
  const auto& compaction_stats = GetCompactionStats();
  ASSERT_GE(compaction_stats.size(), 2);

@@ -307,12 +302,10 @@ TEST_F(DBBlobCompactionTest, FilterByValueLength) {
  // 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();

@@ -388,7 +381,6 @@ TEST_F(DBBlobCompactionTest, BlobCompactWithStartingLevel) {

  Close();
 }
-#endif

 TEST_F(DBBlobCompactionTest, BlindWriteFilter) {
  Options options = GetDefaultOptions();
@@ -413,7 +405,6 @@ TEST_F(DBBlobCompactionTest, BlindWriteFilter) {
    ASSERT_EQ(new_blob_value, Get(key));
  }

-#ifndef ROCKSDB_LITE
  const auto& compaction_stats = GetCompactionStats();
  ASSERT_GE(compaction_stats.size(), 2);

@@ -421,7 +412,6 @@ TEST_F(DBBlobCompactionTest, BlindWriteFilter) {
  // this involves writing but not reading blobs
  ASSERT_EQ(compaction_stats[1].bytes_read_blob, 0);
  ASSERT_GT(compaction_stats[1].bytes_written_blob, 0);
-#endif  // ROCKSDB_LITE

  Close();
 }
@@ -540,7 +530,6 @@ TEST_F(DBBlobCompactionTest, CompactionFilter) {
    ASSERT_EQ(kv.second + std::string(padding), Get(kv.first));
  }

-#ifndef ROCKSDB_LITE
  const auto& compaction_stats = GetCompactionStats();
  ASSERT_GE(compaction_stats.size(), 2);

@@ -548,7 +537,6 @@ TEST_F(DBBlobCompactionTest, CompactionFilter) {
  // this involves reading and writing blobs
  ASSERT_GT(compaction_stats[1].bytes_read_blob, 0);
  ASSERT_GT(compaction_stats[1].bytes_written_blob, 0);
-#endif  // ROCKSDB_LITE

  Close();
 }
@@ -606,7 +594,6 @@ TEST_F(DBBlobCompactionTest, CompactionFilterReadBlobAndKeep) {
                              /*end=*/nullptr));
  ASSERT_EQ(blob_files, GetBlobFileNumbers());

-#ifndef ROCKSDB_LITE
  const auto& compaction_stats = GetCompactionStats();
  ASSERT_GE(compaction_stats.size(), 2);

@@ -614,7 +601,6 @@ TEST_F(DBBlobCompactionTest, CompactionFilterReadBlobAndKeep) {
  // 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();
 }
@@ -34,7 +34,6 @@ class DBBlobCorruptionTest : public DBTestBase {
  }
 };

-#ifndef ROCKSDB_LITE
 TEST_F(DBBlobCorruptionTest, VerifyWholeBlobFileChecksum) {
  Options options = GetDefaultOptions();
  options.enable_blob_files = true;
@@ -71,7 +70,6 @@ TEST_F(DBBlobCorruptionTest, VerifyWholeBlobFileChecksum) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
-#endif  // !ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
@@ -131,9 +131,7 @@ class DBBlobIndexTest : public DBTestBase {
        ASSERT_OK(Flush());
        ASSERT_OK(
            dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-#ifndef ROCKSDB_LITE
        ASSERT_EQ("0,1", FilesPerLevel());
-#endif  // !ROCKSDB_LITE
        break;
    }
  }
@@ -459,7 +457,6 @@ TEST_F(DBBlobIndexTest, Iterate) {
    verify(15, Status::kOk, get_value(16, 0), get_value(14, 0),
           create_blob_iterator, check_is_blob(false));

-#ifndef ROCKSDB_LITE
    // Iterator with blob support and using seek.
    ASSERT_OK(dbfull()->SetOptions(
        cfh(), {{"max_sequential_skip_in_iterations", "0"}}));
@@ -484,7 +481,6 @@ TEST_F(DBBlobIndexTest, Iterate) {
           create_blob_iterator, check_is_blob(false));
    verify(15, Status::kOk, get_value(16, 0), get_value(14, 0),
           create_blob_iterator, check_is_blob(false));
-#endif  // !ROCKSDB_LITE

    for (auto* snapshot : snapshots) {
      dbfull()->ReleaseSnapshot(snapshot);
@@ -584,12 +580,10 @@ TEST_F(DBBlobIndexTest, IntegratedBlobIterate) {
  Status expected_status;
  verify(1, expected_status, expected_value);

-#ifndef ROCKSDB_LITE
  // Test DBIter::FindValueForCurrentKeyUsingSeek flow.
  ASSERT_OK(dbfull()->SetOptions(cfh(),
                                 {{"max_sequential_skip_in_iterations", "0"}}));
  verify(1, expected_status, expected_value);
-#endif  // !ROCKSDB_LITE
 }

 }  // namespace ROCKSDB_NAMESPACE
@@ -71,8 +71,9 @@ Status BuildTable(
    int job_id, const Env::IOPriority io_priority,
    TableProperties* table_properties, Env::WriteLifeTimeHint write_hint,
    const std::string* full_history_ts_low,
-    BlobFileCompletionCallback* blob_callback, uint64_t* num_input_entries,
-    uint64_t* memtable_payload_bytes, uint64_t* memtable_garbage_bytes) {
+    BlobFileCompletionCallback* blob_callback, Version* version,
+    uint64_t* num_input_entries, uint64_t* memtable_payload_bytes,
+    uint64_t* memtable_garbage_bytes) {
  assert((tboptions.column_family_id ==
          TablePropertiesCollectorFactory::Context::kUnknownColumnFamily) ==
         tboptions.column_family_name.empty());
@@ -106,11 +107,9 @@ Status BuildTable(
  std::vector<std::string> blob_file_paths;
  std::string file_checksum = kUnknownFileChecksum;
  std::string file_checksum_func_name = kUnknownFileChecksumFuncName;
-#ifndef ROCKSDB_LITE
  EventHelpers::NotifyTableFileCreationStarted(ioptions.listeners, dbname,
                                               tboptions.column_family_name,
                                               fname, job_id, tboptions.reason);
-#endif  // !ROCKSDB_LITE
  Env* env = db_options.env;
  assert(env);
  FileSystem* fs = db_options.fs.get();
@@ -175,10 +174,10 @@ Status BuildTable(
      builder = NewTableBuilder(tboptions, file_writer.get());
    }

+    auto ucmp = tboptions.internal_comparator.user_comparator();
    MergeHelper merge(
-        env, tboptions.internal_comparator.user_comparator(),
-        ioptions.merge_operator.get(), compaction_filter.get(), ioptions.logger,
-        true /* internal key corruption is not ok */,
+        env, ucmp, ioptions.merge_operator.get(), compaction_filter.get(),
+        ioptions.logger, true /* internal key corruption is not ok */,
        snapshots.empty() ? 0 : snapshots.back(), snapshot_checker);

    std::unique_ptr<BlobFileBuilder> blob_file_builder(
@@ -196,9 +195,8 @@ Status BuildTable(

    const std::atomic<bool> kManualCompactionCanceledFalse{false};
    CompactionIterator c_iter(
-        iter, tboptions.internal_comparator.user_comparator(), &merge,
-        kMaxSequenceNumber, &snapshots, earliest_write_conflict_snapshot,
-        job_snapshot, snapshot_checker, env,
+        iter, ucmp, &merge, kMaxSequenceNumber, &snapshots,
+        earliest_write_conflict_snapshot, job_snapshot, snapshot_checker, env,
        ShouldReportDetailedTime(env, ioptions.stats),
        true /* internal key corruption is not ok */, range_del_agg.get(),
        blob_file_builder.get(), ioptions.allow_data_in_errors,
@@ -241,14 +239,28 @@ Status BuildTable(

    if (s.ok()) {
      auto range_del_it = range_del_agg->NewIterator();
+      Slice last_tombstone_start_user_key{};
      for (range_del_it->SeekToFirst(); range_del_it->Valid();
           range_del_it->Next()) {
        auto tombstone = range_del_it->Tombstone();
        auto kv = tombstone.Serialize();
        builder->Add(kv.first.Encode(), kv.second);
-        meta->UpdateBoundariesForRange(kv.first, tombstone.SerializeEndKey(),
-                                       tombstone.seq_,
+        InternalKey tombstone_end = tombstone.SerializeEndKey();
+        meta->UpdateBoundariesForRange(kv.first, tombstone_end, tombstone.seq_,
                                       tboptions.internal_comparator);
+        if (version) {
+          if (last_tombstone_start_user_key.empty() ||
+              ucmp->CompareWithoutTimestamp(last_tombstone_start_user_key,
+                                            range_del_it->start_key()) < 0) {
+            SizeApproximationOptions approx_opts;
+            approx_opts.files_size_error_margin = 0.1;
+            meta->compensated_range_deletion_size += versions->ApproximateSize(
+                approx_opts, version, kv.first.Encode(), tombstone_end.Encode(),
+                0 /* start_level */, -1 /* end_level */,
+                TableReaderCaller::kFlush);
+          }
+          last_tombstone_start_user_key = range_del_it->start_key();
+        }
      }
    }

@@ -281,7 +293,8 @@ Status BuildTable(
      meta->fd.file_size = file_size;
      meta->marked_for_compaction = builder->NeedCompact();
      assert(meta->fd.GetFileSize() > 0);
-      tp = builder->GetTableProperties(); // refresh now that builder is finished
+      tp = builder
+               ->GetTableProperties();  // refresh now that builder is finished
      if (memtable_payload_bytes != nullptr &&
          memtable_garbage_bytes != nullptr) {
        const CompactionIterationStats& ci_stats = c_iter.iter_stats();
@@ -13,6 +13,7 @@
 #include "db/range_tombstone_fragmenter.h"
 #include "db/seqno_to_time_mapping.h"
 #include "db/table_properties_collector.h"
+#include "db/version_set.h"
 #include "logging/event_logger.h"
 #include "options/cf_options.h"
 #include "rocksdb/comparator.h"
@@ -70,7 +71,7 @@ extern Status BuildTable(
    Env::WriteLifeTimeHint write_hint = Env::WLTH_NOT_SET,
    const std::string* full_history_ts_low = nullptr,
    BlobFileCompletionCallback* blob_callback = nullptr,
-    uint64_t* num_input_entries = nullptr,
+    Version* version = nullptr, uint64_t* num_input_entries = nullptr,
    uint64_t* memtable_payload_bytes = nullptr,
    uint64_t* memtable_garbage_bytes = nullptr);

@@ -5,8 +5,6 @@

 #include <stdio.h>

-#ifndef ROCKSDB_LITE  // Lite does not support C API
-
 #include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -49,32 +47,32 @@ static void StartPhase(const char* name) {
 }
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning (disable: 4996) // getenv security warning
+#pragma warning(disable : 4996)  // getenv security warning
 #endif
 static const char* GetTempDir(void) {
-    const char* ret = getenv("TEST_TMPDIR");
-    if (ret == NULL || ret[0] == '\0')
+  const char* ret = getenv("TEST_TMPDIR");
+  if (ret == NULL || ret[0] == '\0')
 #ifdef OS_WIN
-      ret = getenv("TEMP");
+    ret = getenv("TEMP");
 #else
-      ret = "/tmp";
+    ret = "/tmp";
 #endif
-    return ret;
+  return ret;
 }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif

-#define CheckNoError(err)                                               \
-  if ((err) != NULL) {                                                  \
+#define CheckNoError(err)                                                 \
+  if ((err) != NULL) {                                                    \
    fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, (err)); \
-    abort();                                                            \
+    abort();                                                              \
  }

-#define CheckCondition(cond)                                            \
-  if (!(cond)) {                                                        \
+#define CheckCondition(cond)                                              \
+  if (!(cond)) {                                                          \
    fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, #cond); \
-    abort();                                                            \
+    abort();                                                              \
  }

 static void CheckEqual(const char* expected, const char* v, size_t n) {
@@ -98,21 +96,15 @@ static void Free(char** ptr) {
  }
 }

-static void CheckValue(
-    char* err,
-    const char* expected,
-    char** actual,
-    size_t actual_length) {
+static void CheckValue(char* err, const char* expected, char** actual,
+                       size_t actual_length) {
  CheckNoError(err);
  CheckEqual(expected, *actual, actual_length);
  Free(actual);
 }

-static void CheckGet(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    const char* key,
-    const char* expected) {
+static void CheckGet(rocksdb_t* db, const rocksdb_readoptions_t* options,
+                     const char* key, const char* expected) {
  char* err = NULL;
  size_t val_len;
  char* val;
@@ -122,12 +114,9 @@ static void CheckGet(
  Free(&val);
 }

-static void CheckGetCF(
-    rocksdb_t* db,
-    const rocksdb_readoptions_t* options,
-    rocksdb_column_family_handle_t* handle,
-    const char* key,
-    const char* expected) {
+static void CheckGetCF(rocksdb_t* db, const rocksdb_readoptions_t* options,
+                       rocksdb_column_family_handle_t* handle, const char* key,
+                       const char* expected) {
  char* err = NULL;
  size_t val_len;
  char* val;
@@ -174,8 +163,8 @@ static void CheckMultiGetValues(size_t num_keys, char** values,
  }
 }

-static void CheckIter(rocksdb_iterator_t* iter,
-                      const char* key, const char* val) {
+static void CheckIter(rocksdb_iterator_t* iter, const char* key,
+                      const char* val) {
  size_t len;
  const char* str;
  str = rocksdb_iter_key(iter, &len);
@@ -185,10 +174,9 @@ static void CheckIter(rocksdb_iterator_t* iter,
 }

 // Callback from rocksdb_writebatch_iterate()
-static void CheckPut(void* ptr,
-                     const char* k, size_t klen,
-                     const char* v, size_t vlen) {
-  int* state = (int*) ptr;
+static void CheckPut(void* ptr, const char* k, size_t klen, const char* v,
+                     size_t vlen) {
+  int* state = (int*)ptr;
  CheckCondition(*state < 2);
  switch (*state) {
    case 0:
@@ -205,7 +193,7 @@ static void CheckPut(void* ptr,

 // Callback from rocksdb_writebatch_iterate()
 static void CheckDel(void* ptr, const char* k, size_t klen) {
-  int* state = (int*) ptr;
+  int* state = (int*)ptr;
  CheckCondition(*state == 2);
  CheckEqual("bar", k, klen);
  (*state)++;
@@ -213,14 +201,16 @@ static void CheckDel(void* ptr, const char* k, size_t klen) {

 static void CmpDestroy(void* arg) { (void)arg; }

-static int CmpCompare(void* arg, const char* a, size_t alen,
-                      const char* b, size_t blen) {
+static int CmpCompare(void* arg, const char* a, size_t alen, const char* b,
+                      size_t blen) {
  (void)arg;
  size_t n = (alen < blen) ? alen : blen;
  int r = memcmp(a, b, n);
  if (r == 0) {
-    if (alen < blen) r = -1;
-    else if (alen > blen) r = +1;
+    if (alen < blen)
+      r = -1;
+    else if (alen > blen)
+      r = +1;
  }
  return r;
 }
@@ -405,11 +395,9 @@ static const char* MergeOperatorName(void* arg) {
  return "TestMergeOperator";
 }
 static char* MergeOperatorFullMerge(
-    void* arg,
-    const char* key, size_t key_length,
-    const char* existing_value, size_t existing_value_length,
-    const char* const* operands_list, const size_t* operands_list_length,
-    int num_operands,
+    void* arg, const char* key, size_t key_length, const char* existing_value,
+    size_t existing_value_length, const char* const* operands_list,
+    const size_t* operands_list_length, int num_operands,
    unsigned char* success, size_t* new_value_length) {
  (void)arg;
  (void)key;
@@ -425,12 +413,12 @@ static char* MergeOperatorFullMerge(
  memcpy(result, "fake", 4);
  return result;
 }
-static char* MergeOperatorPartialMerge(
-    void* arg,
-    const char* key, size_t key_length,
-    const char* const* operands_list, const size_t* operands_list_length,
-    int num_operands,
-    unsigned char* success, size_t* new_value_length) {
+static char* MergeOperatorPartialMerge(void* arg, const char* key,
+                                       size_t key_length,
+                                       const char* const* operands_list,
+                                       const size_t* operands_list_length,
+                                       int num_operands, unsigned char* success,
+                                       size_t* new_value_length) {
  (void)arg;
  (void)key;
  (void)key_length;
@@ -444,18 +432,16 @@ static char* MergeOperatorPartialMerge(
  return result;
 }

-static void CheckTxnGet(
-        rocksdb_transaction_t* txn,
-        const rocksdb_readoptions_t* options,
-        const char* key,
-        const char* expected) {
-        char* err = NULL;
-        size_t val_len;
-        char* val;
-        val = rocksdb_transaction_get(txn, options, key, strlen(key), &val_len, &err);
-        CheckNoError(err);
-        CheckEqual(expected, val, val_len);
-        Free(&val);
+static void CheckTxnGet(rocksdb_transaction_t* txn,
+                        const rocksdb_readoptions_t* options, const char* key,
+                        const char* expected) {
+  char* err = NULL;
+  size_t val_len;
+  char* val;
+  val = rocksdb_transaction_get(txn, options, key, strlen(key), &val_len, &err);
+  CheckNoError(err);
+  CheckEqual(expected, val, val_len);
+  Free(&val);
 }

 static void CheckTxnGetCF(rocksdb_transaction_t* txn,
@@ -502,11 +488,9 @@ static void CheckTxnPinGetCF(rocksdb_transaction_t* txn,
  rocksdb_pinnableslice_destroy(p);
 }

-static void CheckTxnDBGet(
-        rocksdb_transactiondb_t* txn_db,
-        const rocksdb_readoptions_t* options,
-        const char* key,
-        const char* expected) {
+static void CheckTxnDBGet(rocksdb_transactiondb_t* txn_db,
+                          const rocksdb_readoptions_t* options, const char* key,
+                          const char* expected) {
  char* err = NULL;
  size_t val_len;
  char* val;
@@ -632,7 +616,7 @@ int main(int argc, char** argv) {
  rocksdb_t* db;
  rocksdb_comparator_t* cmp;
  rocksdb_cache_t* cache;
-  rocksdb_dbpath_t *dbpath;
+  rocksdb_dbpath_t* dbpath;
  rocksdb_env_t* env;
  rocksdb_options_t* options;
  rocksdb_compactoptions_t* coptions;
@@ -649,30 +633,20 @@ int main(int argc, char** argv) {
  char* err = NULL;
  int run = -1;

-  snprintf(dbname, sizeof(dbname),
-           "%s/rocksdb_c_test-%d",
-           GetTempDir(),
-           ((int) geteuid()));
-
-  snprintf(dbbackupname, sizeof(dbbackupname),
-           "%s/rocksdb_c_test-%d-backup",
-           GetTempDir(),
-           ((int) geteuid()));
-
-  snprintf(dbcheckpointname, sizeof(dbcheckpointname),
-           "%s/rocksdb_c_test-%d-checkpoint",
-           GetTempDir(),
-           ((int) geteuid()));
-
-  snprintf(sstfilename, sizeof(sstfilename),
-           "%s/rocksdb_c_test-%d-sst",
-           GetTempDir(),
+  snprintf(dbname, sizeof(dbname), "%s/rocksdb_c_test-%d", GetTempDir(),
           ((int)geteuid()));

-  snprintf(dbpathname, sizeof(dbpathname),
-           "%s/rocksdb_c_test-%d-dbpath",
-           GetTempDir(),
-           ((int) geteuid()));
+  snprintf(dbbackupname, sizeof(dbbackupname), "%s/rocksdb_c_test-%d-backup",
+           GetTempDir(), ((int)geteuid()));
+
+  snprintf(dbcheckpointname, sizeof(dbcheckpointname),
+           "%s/rocksdb_c_test-%d-checkpoint", GetTempDir(), ((int)geteuid()));
+
+  snprintf(sstfilename, sizeof(sstfilename), "%s/rocksdb_c_test-%d-sst",
+           GetTempDir(), ((int)geteuid()));
+
+  snprintf(dbpathname, sizeof(dbpathname), "%s/rocksdb_c_test-%d-dbpath",
+           GetTempDir(), ((int)geteuid()));

  StartPhase("create_objects");
  cmp = rocksdb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
@@ -746,7 +720,8 @@ int main(int argc, char** argv) {
    rocksdb_destroy_db(options, dbbackupname, &err);
    CheckNoError(err);

-    rocksdb_backup_engine_t *be = rocksdb_backup_engine_open(options, dbbackupname, &err);
+    rocksdb_backup_engine_t* be =
+        rocksdb_backup_engine_open(options, dbbackupname, &err);
    CheckNoError(err);

    rocksdb_backup_engine_create_new_backup(be, db, &err);
@@ -759,7 +734,8 @@ int main(int argc, char** argv) {
    rocksdb_backup_engine_create_new_backup(be, db, &err);
    CheckNoError(err);

-    const rocksdb_backup_engine_info_t* bei = rocksdb_backup_engine_get_backup_info(be);
+    const rocksdb_backup_engine_info_t* bei =
+        rocksdb_backup_engine_get_backup_info(be);
    CheckCondition(rocksdb_backup_engine_info_count(bei) > 1);
    rocksdb_backup_engine_info_destroy(bei);

@@ -778,9 +754,11 @@ int main(int argc, char** argv) {
    rocksdb_destroy_db(options, dbname, &err);
    CheckNoError(err);

-    rocksdb_restore_options_t *restore_options = rocksdb_restore_options_create();
+    rocksdb_restore_options_t* restore_options =
+        rocksdb_restore_options_create();
    rocksdb_restore_options_set_keep_log_files(restore_options, 0);
-    rocksdb_backup_engine_restore_db_from_latest_backup(be, dbname, dbname, restore_options, &err);
+    rocksdb_backup_engine_restore_db_from_latest_backup(be, dbname, dbname,
+                                                        restore_options, &err);
    CheckNoError(err);
    rocksdb_restore_options_destroy(restore_options);

@@ -799,7 +777,8 @@ int main(int argc, char** argv) {
    rocksdb_destroy_db(options, dbcheckpointname, &err);
    CheckNoError(err);

-    rocksdb_checkpoint_t* checkpoint = rocksdb_checkpoint_object_create(db, &err);
+    rocksdb_checkpoint_t* checkpoint =
+        rocksdb_checkpoint_object_create(db, &err);
    CheckNoError(err);

    rocksdb_checkpoint_create(checkpoint, dbcheckpointname, 0, &err);
@@ -976,10 +955,10 @@ int main(int argc, char** argv) {
  StartPhase("writebatch_vectors");
  {
    rocksdb_writebatch_t* wb = rocksdb_writebatch_create();
-    const char* k_list[2] = { "z", "ap" };
-    const size_t k_sizes[2] = { 1, 2 };
-    const char* v_list[3] = { "x", "y", "z" };
-    const size_t v_sizes[3] = { 1, 1, 1 };
+    const char* k_list[2] = {"z", "ap"};
+    const size_t k_sizes[2] = {1, 2};
+    const char* v_list[3] = {"x", "y", "z"};
+    const size_t v_sizes[3] = {1, 1, 1};
    rocksdb_writebatch_putv(wb, 2, k_list, k_sizes, 3, v_list, v_sizes);
    rocksdb_write(db, woptions, wb, &err);
    CheckNoError(err);
@@ -1041,13 +1020,17 @@ int main(int argc, char** argv) {
    CheckCondition(count == 3);
    size_t size;
    char* value;
-    value = rocksdb_writebatch_wi_get_from_batch(wbi, options, "box", 3, &size, &err);
+    value = rocksdb_writebatch_wi_get_from_batch(wbi, options, "box", 3, &size,
+                                                 &err);
    CheckValue(err, "c", &value, size);
-    value = rocksdb_writebatch_wi_get_from_batch(wbi, options, "bar", 3, &size, &err);
+    value = rocksdb_writebatch_wi_get_from_batch(wbi, options, "bar", 3, &size,
+                                                 &err);
    CheckValue(err, NULL, &value, size);
-    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions, "foo", 3, &size, &err);
+    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions,
+                                                        "foo", 3, &size, &err);
    CheckValue(err, "hello", &value, size);
-    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions, "box", 3, &size, &err);
+    value = rocksdb_writebatch_wi_get_from_batch_and_db(wbi, db, roptions,
+                                                        "box", 3, &size, &err);
    CheckValue(err, "c", &value, size);
    rocksdb_write_writebatch_wi(db, woptions, wbi, &err);
    CheckNoError(err);
@@ -1064,10 +1047,10 @@ int main(int argc, char** argv) {
  StartPhase("writebatch_wi_vectors");
  {
    rocksdb_writebatch_wi_t* wb = rocksdb_writebatch_wi_create(0, 1);
-    const char* k_list[2] = { "z", "ap" };
-    const size_t k_sizes[2] = { 1, 2 };
-    const char* v_list[3] = { "x", "y", "z" };
-    const size_t v_sizes[3] = { 1, 1, 1 };
+    const char* k_list[2] = {"z", "ap"};
+    const size_t k_sizes[2] = {1, 2};
+    const char* v_list[3] = {"x", "y", "z"};
+    const size_t v_sizes[3] = {1, 1, 1};
    rocksdb_writebatch_wi_putv(wb, 2, k_list, k_sizes, 3, v_list, v_sizes);
    rocksdb_write_writebatch_wi(db, woptions, wb, &err);
    CheckNoError(err);
@@ -1156,13 +1139,14 @@ int main(int argc, char** argv) {

  StartPhase("multiget");
  {
-    const char* keys[3] = { "box", "foo", "notfound" };
-    const size_t keys_sizes[3] = { 3, 3, 8 };
+    const char* keys[3] = {"box", "foo", "notfound"};
+    const size_t keys_sizes[3] = {3, 3, 8};
    char* vals[3];
    size_t vals_sizes[3];
    char* errs[3];
    const char* expected[3] = {"c", "hello", NULL};
-    rocksdb_multi_get(db, roptions, 3, keys, keys_sizes, vals, vals_sizes, errs);
+    rocksdb_multi_get(db, roptions, 3, keys, keys_sizes, vals, vals_sizes,
+                      errs);
    CheckMultiGetValues(3, vals, vals_sizes, errs, expected);
  }

@@ -1180,10 +1164,10 @@ int main(int argc, char** argv) {
    char keybuf[100];
    char valbuf[100];
    uint64_t sizes[2];
-    const char* start[2] = { "a", "k00000000000000010000" };
-    size_t start_len[2] = { 1, 21 };
-    const char* limit[2] = { "k00000000000000010000", "z" };
-    size_t limit_len[2] = { 21, 1 };
+    const char* start[2] = {"a", "k00000000000000010000"};
+    size_t start_len[2] = {1, 21};
+    const char* limit[2] = {"k00000000000000010000", "z"};
+    size_t limit_len[2] = {21, 1};
    rocksdb_writeoptions_set_sync(woptions, 0);
    for (i = 0; i < n; i++) {
      snprintf(keybuf, sizeof(keybuf), "k%020d", i);
@@ -1393,8 +1377,8 @@ int main(int argc, char** argv) {
                                                  factory);
    db = CheckCompaction(db, options_with_filter_factory, roptions, woptions);

-    rocksdb_options_set_compaction_filter_factory(
-        options_with_filter_factory, NULL);
+    rocksdb_options_set_compaction_filter_factory(options_with_filter_factory,
+                                                  NULL);
    rocksdb_options_destroy(options_with_filter_factory);
  }

@@ -1449,7 +1433,8 @@ int main(int argc, char** argv) {
    rocksdb_close(db);

    size_t cflen;
-    char** column_fams = rocksdb_list_column_families(db_options, dbname, &cflen, &err);
+    char** column_fams =
+        rocksdb_list_column_families(db_options, dbname, &cflen, &err);
    CheckNoError(err);
    CheckEqual("default", column_fams[0], 7);
    CheckEqual("cf1", column_fams[1], 3);
@@ -1465,7 +1450,8 @@ int main(int argc, char** argv) {
    LoadAndCheckLatestOptions(dbname, env, false, cache, NULL, 2, cf_names,
                              NULL);

-    db = rocksdb_open_column_families(db_options, dbname, 2, cf_names, cf_opts, handles, &err);
+    db = rocksdb_open_column_families(db_options, dbname, 2, cf_names, cf_opts,
+                                      handles, &err);
    CheckNoError(err);

    rocksdb_put_cf(db, woptions, handles[1], "foo", 3, "hello", 5, &err);
@@ -1483,11 +1469,10 @@ int main(int argc, char** argv) {
                                     &err);
    CheckNoError(err);

-    rocksdb_flushoptions_t *flush_options = rocksdb_flushoptions_create();
+    rocksdb_flushoptions_t* flush_options = rocksdb_flushoptions_create();
    rocksdb_flushoptions_set_wait(flush_options, 1);
    rocksdb_flush_cf(db, flush_options, handles[1], &err);
-    CheckNoError(err)
-    rocksdb_flushoptions_destroy(flush_options);
+    CheckNoError(err) rocksdb_flushoptions_destroy(flush_options);

    CheckGetCF(db, roptions, handles[1], "foo", "hello");
    CheckPinGetCF(db, roptions, handles[1], "foo", "hello");
@@ -1524,27 +1509,29 @@ int main(int argc, char** argv) {
    rocksdb_flush_wal(db, 1, &err);
    CheckNoError(err);

-    const char* keys[3] = { "box", "box", "barfooxx" };
-    const rocksdb_column_family_handle_t* get_handles[3] = { handles[0], handles[1], handles[1] };
-    const size_t keys_sizes[3] = { 3, 3, 8 };
+    const char* keys[3] = {"box", "box", "barfooxx"};
+    const rocksdb_column_family_handle_t* get_handles[3] = {
+        handles[0], handles[1], handles[1]};
+    const size_t keys_sizes[3] = {3, 3, 8};
    char* vals[3];
    size_t vals_sizes[3];
    char* errs[3];
-    rocksdb_multi_get_cf(db, roptions, get_handles, 3, keys, keys_sizes, vals, vals_sizes, errs);
+    rocksdb_multi_get_cf(db, roptions, get_handles, 3, keys, keys_sizes, vals,
+                         vals_sizes, errs);

    int i;
    for (i = 0; i < 3; i++) {
      CheckEqual(NULL, errs[i], 0);
      switch (i) {
-      case 0:
-        CheckEqual(NULL, vals[i], vals_sizes[i]); // wrong cf
-        break;
-      case 1:
-        CheckEqual("c", vals[i], vals_sizes[i]); // bingo
-        break;
-      case 2:
-        CheckEqual(NULL, vals[i], vals_sizes[i]); // normal not found
-        break;
+        case 0:
+          CheckEqual(NULL, vals[i], vals_sizes[i]);  // wrong cf
+          break;
+        case 1:
+          CheckEqual("c", vals[i], vals_sizes[i]);  // bingo
+          break;
+        case 2:
+          CheckEqual(NULL, vals[i], vals_sizes[i]);  // normal not found
+          break;
      }
      Free(&vals[i]);
    }
@@ -1592,7 +1579,8 @@ int main(int argc, char** argv) {
      }
    }

-    rocksdb_iterator_t* iter = rocksdb_create_iterator_cf(db, roptions, handles[1]);
+    rocksdb_iterator_t* iter =
+        rocksdb_create_iterator_cf(db, roptions, handles[1]);
    CheckCondition(!rocksdb_iter_valid(iter));
    rocksdb_iter_seek_to_first(iter);
    CheckCondition(rocksdb_iter_valid(iter));
@@ -1605,9 +1593,11 @@ int main(int argc, char** argv) {
    CheckNoError(err);
    rocksdb_iter_destroy(iter);

-    rocksdb_column_family_handle_t* iters_cf_handles[2] = { handles[0], handles[1] };
+    rocksdb_column_family_handle_t* iters_cf_handles[2] = {handles[0],
+                                                           handles[1]};
    rocksdb_iterator_t* iters_handles[2];
-    rocksdb_create_iterators(db, roptions, iters_cf_handles, iters_handles, 2, &err);
+    rocksdb_create_iterators(db, roptions, iters_cf_handles, iters_handles, 2,
+                             &err);
    CheckNoError(err);

    iter = iters_handles[0];
@@ -1652,7 +1642,8 @@ int main(int argc, char** argv) {
  {
    // Create new database
    rocksdb_options_set_allow_mmap_reads(options, 1);
-    rocksdb_options_set_prefix_extractor(options, rocksdb_slicetransform_create_fixed_prefix(3));
+    rocksdb_options_set_prefix_extractor(
+        options, rocksdb_slicetransform_create_fixed_prefix(3));
    rocksdb_options_set_hash_skip_list_rep(options, 5000, 4, 4);
    rocksdb_options_set_plain_table_factory(options, 4, 10, 0.75, 16);
    rocksdb_options_set_allow_concurrent_memtable_write(options, 0);
@@ -1747,8 +1738,9 @@ int main(int argc, char** argv) {
    // amount of memory used within memtables should grow
    CheckCondition(rocksdb_approximate_memory_usage_get_mem_table_total(mu2) >=
                   rocksdb_approximate_memory_usage_get_mem_table_total(mu1));
-    CheckCondition(rocksdb_approximate_memory_usage_get_mem_table_unflushed(mu2) >=
-                   rocksdb_approximate_memory_usage_get_mem_table_unflushed(mu1));
+    CheckCondition(
+        rocksdb_approximate_memory_usage_get_mem_table_unflushed(mu2) >=
+        rocksdb_approximate_memory_usage_get_mem_table_unflushed(mu1));

    rocksdb_memory_consumers_destroy(consumers);
    rocksdb_approximate_memory_usage_destroy(mu1);
@@ -2578,6 +2570,9 @@ int main(int argc, char** argv) {
    rocksdb_readoptions_set_io_timeout(ro, 400);
    CheckCondition(400 == rocksdb_readoptions_get_io_timeout(ro));

+    rocksdb_readoptions_set_async_io(ro, 1);
+    CheckCondition(1 == rocksdb_readoptions_get_async_io(ro));
+
    rocksdb_readoptions_destroy(ro);
  }

@@ -2839,53 +2834,57 @@ int main(int argc, char** argv) {
    db = rocksdb_open(options, dbname, &err);
    CheckNoError(err);

-    rocksdb_put(db, woptions, "a",    1, "0",    1, &err); CheckNoError(err);
-    rocksdb_put(db, woptions, "foo",  3, "bar",  3, &err); CheckNoError(err);
-    rocksdb_put(db, woptions, "foo1", 4, "bar1", 4, &err); CheckNoError(err);
-    rocksdb_put(db, woptions, "g1",   2, "0",    1, &err); CheckNoError(err);
+    rocksdb_put(db, woptions, "a", 1, "0", 1, &err);
+    CheckNoError(err);
+    rocksdb_put(db, woptions, "foo", 3, "bar", 3, &err);
+    CheckNoError(err);
+    rocksdb_put(db, woptions, "foo1", 4, "bar1", 4, &err);
+    CheckNoError(err);
+    rocksdb_put(db, woptions, "g1", 2, "0", 1, &err);
+    CheckNoError(err);

    // testing basic case with no iterate_upper_bound and no prefix_extractor
    {
-       rocksdb_readoptions_set_iterate_upper_bound(roptions, NULL, 0);
-       rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);
+      rocksdb_readoptions_set_iterate_upper_bound(roptions, NULL, 0);
+      rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);

-       rocksdb_iter_seek(iter, "foo", 3);
-       CheckCondition(rocksdb_iter_valid(iter));
-       CheckIter(iter, "foo", "bar");
+      rocksdb_iter_seek(iter, "foo", 3);
+      CheckCondition(rocksdb_iter_valid(iter));
+      CheckIter(iter, "foo", "bar");

-       rocksdb_iter_next(iter);
-       CheckCondition(rocksdb_iter_valid(iter));
-       CheckIter(iter, "foo1", "bar1");
+      rocksdb_iter_next(iter);
+      CheckCondition(rocksdb_iter_valid(iter));
+      CheckIter(iter, "foo1", "bar1");

-       rocksdb_iter_next(iter);
-       CheckCondition(rocksdb_iter_valid(iter));
-       CheckIter(iter, "g1", "0");
+      rocksdb_iter_next(iter);
+      CheckCondition(rocksdb_iter_valid(iter));
+      CheckIter(iter, "g1", "0");

-       rocksdb_iter_destroy(iter);
+      rocksdb_iter_destroy(iter);
    }

    // testing iterate_upper_bound and forward iterator
    // to make sure it stops at bound
    {
-       // iterate_upper_bound points beyond the last expected entry
-       rocksdb_readoptions_set_iterate_upper_bound(roptions, "foo2", 4);
+      // iterate_upper_bound points beyond the last expected entry
+      rocksdb_readoptions_set_iterate_upper_bound(roptions, "foo2", 4);

-       rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);
+      rocksdb_iterator_t* iter = rocksdb_create_iterator(db, roptions);

-       rocksdb_iter_seek(iter, "foo", 3);
-       CheckCondition(rocksdb_iter_valid(iter));
-       CheckIter(iter, "foo", "bar");
+      rocksdb_iter_seek(iter, "foo", 3);
+      CheckCondition(rocksdb_iter_valid(iter));
+      CheckIter(iter, "foo", "bar");

-       rocksdb_iter_next(iter);
-       CheckCondition(rocksdb_iter_valid(iter));
-       CheckIter(iter, "foo1", "bar1");
+      rocksdb_iter_next(iter);
+      CheckCondition(rocksdb_iter_valid(iter));
+      CheckIter(iter, "foo1", "bar1");

-       rocksdb_iter_next(iter);
-       // should stop here...
-       CheckCondition(!rocksdb_iter_valid(iter));
+      rocksdb_iter_next(iter);
+      // should stop here...
+      CheckCondition(!rocksdb_iter_valid(iter));

-       rocksdb_iter_destroy(iter);
-       rocksdb_readoptions_set_iterate_upper_bound(roptions, NULL, 0);
+      rocksdb_iter_destroy(iter);
+      rocksdb_readoptions_set_iterate_upper_bound(roptions, NULL, 0);
    }
  }

@@ -3009,7 +3008,7 @@ int main(int argc, char** argv) {
    snapshot = rocksdb_transactiondb_create_snapshot(txn_db);
    rocksdb_readoptions_set_snapshot(roptions, snapshot);

-    rocksdb_transactiondb_put(txn_db, woptions, "foo", 3, "hey", 3,  &err);
+    rocksdb_transactiondb_put(txn_db, woptions, "foo", 3, "hey", 3, &err);
    CheckNoError(err);

    CheckTxnDBGet(txn_db, roptions, "foo", "hello");
@@ -3021,7 +3020,8 @@ int main(int argc, char** argv) {

    // iterate
    rocksdb_transaction_put(txn, "bar", 3, "hi", 2, &err);
-    rocksdb_iterator_t* iter = rocksdb_transaction_create_iterator(txn, roptions);
+    rocksdb_iterator_t* iter =
+        rocksdb_transaction_create_iterator(txn, roptions);
    CheckCondition(!rocksdb_iter_valid(iter));
    rocksdb_iter_seek_to_first(iter);
    CheckCondition(rocksdb_iter_valid(iter));
@@ -3466,12 +3466,3 @@ int main(int argc, char** argv) {
  fprintf(stderr, "PASS\n");
  return 0;
 }
-
-#else
-
-int main(void) {
-  fprintf(stderr, "SKIPPED\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE
@@ -53,11 +53,9 @@ ColumnFamilyHandleImpl::ColumnFamilyHandleImpl(

 ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
  if (cfd_ != nullptr) {
-#ifndef ROCKSDB_LITE
    for (auto& listener : cfd_->ioptions()->listeners) {
      listener->OnColumnFamilyHandleDeletionStarted(this);
    }
-#endif  // ROCKSDB_LITE
    // Job id == 0 means that this is not our background process, but rather
    // user thread
    // Need to hold some shared pointers owned by the initial_cf_options
@@ -88,15 +86,10 @@ const std::string& ColumnFamilyHandleImpl::GetName() const {
 }

 Status ColumnFamilyHandleImpl::GetDescriptor(ColumnFamilyDescriptor* desc) {
-#ifndef ROCKSDB_LITE
  // accessing mutable cf-options requires db mutex.
  InstrumentedMutexLock l(mutex_);
  *desc = ColumnFamilyDescriptor(cfd()->GetName(), cfd()->GetLatestCFOptions());
  return Status::OK();
-#else
-  (void)desc;
-  return Status::NotSupported();
-#endif  // !ROCKSDB_LITE
 }

 const Comparator* ColumnFamilyHandleImpl::GetComparator() const {
@@ -192,8 +185,7 @@ Status CheckCFPathsSupported(const DBOptions& db_options,
      return Status::NotSupported(
          "More than one CF paths are only supported in "
          "universal and level compaction styles. ");
-    } else if (cf_options.cf_paths.empty() &&
-               db_options.db_paths.size() > 1) {
+    } else if (cf_options.cf_paths.empty() && db_options.db_paths.size() > 1) {
      return Status::NotSupported(
          "More than one DB paths are only supported in "
          "universal and level compaction styles. ");
@@ -205,7 +197,7 @@ Status CheckCFPathsSupported(const DBOptions& db_options,
 namespace {
 const uint64_t kDefaultTtl = 0xfffffffffffffffe;
 const uint64_t kDefaultPeriodicCompSecs = 0xfffffffffffffffe;
-}  // namespace
+}  // anonymous namespace

 ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
                                    const ColumnFamilyOptions& src) {
@@ -348,18 +340,17 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
        result.hard_pending_compaction_bytes_limit;
  }

-#ifndef ROCKSDB_LITE
  // When the DB is stopped, it's possible that there are some .trash files that
  // were not deleted yet, when we open the DB we will find these .trash files
  // and schedule them to be deleted (or delete immediately if SstFileManager
  // was not used)
-  auto sfm = static_cast<SstFileManagerImpl*>(db_options.sst_file_manager.get());
+  auto sfm =
+      static_cast<SstFileManagerImpl*>(db_options.sst_file_manager.get());
  for (size_t i = 0; i < result.cf_paths.size(); i++) {
    DeleteScheduler::CleanupDirectory(db_options.env, sfm,
                                      result.cf_paths[i].path)
        .PermitUncheckedError();
  }
-#endif

  if (result.cf_paths.empty()) {
    result.cf_paths = db_options.db_paths;
@@ -557,7 +548,6 @@ ColumnFamilyData::ColumnFamilyData(
      next_(nullptr),
      prev_(nullptr),
      log_number_(0),
-      flush_reason_(FlushReason::kOthers),
      column_family_set_(column_family_set),
      queued_for_flush_(false),
      queued_for_compaction_(false),
@@ -565,7 +555,8 @@ ColumnFamilyData::ColumnFamilyData(
      allow_2pc_(db_options.allow_2pc),
      last_memtable_id_(0),
      db_paths_registered_(false),
-      mempurge_used_(false) {
+      mempurge_used_(false),
+      next_epoch_number_(1) {
  if (id_ != kDummyColumnFamilyDataId) {
    // TODO(cc): RegisterDbPaths can be expensive, considering moving it
    // outside of this constructor which might be called with db mutex held.
@@ -602,7 +593,6 @@ ColumnFamilyData::ColumnFamilyData(
    if (ioptions_.compaction_style == kCompactionStyleLevel) {
      compaction_picker_.reset(
          new LevelCompactionPicker(ioptions_, &internal_comparator_));
-#ifndef ROCKSDB_LITE
    } else if (ioptions_.compaction_style == kCompactionStyleUniversal) {
      compaction_picker_.reset(
          new UniversalCompactionPicker(ioptions_, &internal_comparator_));
@@ -610,13 +600,12 @@ ColumnFamilyData::ColumnFamilyData(
      compaction_picker_.reset(
          new FIFOCompactionPicker(ioptions_, &internal_comparator_));
    } else if (ioptions_.compaction_style == kCompactionStyleNone) {
-      compaction_picker_.reset(new NullCompactionPicker(
-          ioptions_, &internal_comparator_));
+      compaction_picker_.reset(
+          new NullCompactionPicker(ioptions_, &internal_comparator_));
      ROCKS_LOG_WARN(ioptions_.logger,
                     "Column family %s does not use any background compaction. "
                     "Compactions can only be done via CompactFiles\n",
                     GetName().c_str());
-#endif  // !ROCKSDB_LITE
    } else {
      ROCKS_LOG_ERROR(ioptions_.logger,
                      "Unable to recognize the specified compaction style %d. "
@@ -878,7 +867,7 @@ int GetL0ThresholdSpeedupCompaction(int level0_file_num_compaction_trigger,
    return static_cast<int>(res);
  }
 }
-}  // namespace
+}  // anonymous namespace

 std::pair<WriteStallCondition, ColumnFamilyData::WriteStallCause>
 ColumnFamilyData::GetWriteStallConditionAndCause(
@@ -919,7 +908,7 @@ ColumnFamilyData::GetWriteStallConditionAndCause(
 }

 WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
-      const MutableCFOptions& mutable_cf_options) {
+    const MutableCFOptions& mutable_cf_options) {
  auto write_stall_condition = WriteStallCondition::kNormal;
  if (current_ != nullptr) {
    auto* vstorage = current_->storage_info();
@@ -1012,7 +1001,8 @@ WriteStallCondition ColumnFamilyData::RecalculateWriteStallConditions(
          mutable_cf_options.hard_pending_compaction_bytes_limit > 0 &&
          (compaction_needed_bytes -
           mutable_cf_options.soft_pending_compaction_bytes_limit) >
-              3 * (mutable_cf_options.hard_pending_compaction_bytes_limit -
+              3 *
+                  (mutable_cf_options.hard_pending_compaction_bytes_limit -
                   mutable_cf_options.soft_pending_compaction_bytes_limit) /
                  4;

@@ -1127,12 +1117,9 @@ bool ColumnFamilyData::NeedsCompaction() const {
 Compaction* ColumnFamilyData::PickCompaction(
    const MutableCFOptions& mutable_options,
    const MutableDBOptions& mutable_db_options, LogBuffer* log_buffer) {
-  SequenceNumber earliest_mem_seqno =
-      std::min(mem_->GetEarliestSequenceNumber(),
-               imm_.current()->GetEarliestSequenceNumber(false));
  auto* result = compaction_picker_->PickCompaction(
      GetName(), mutable_options, mutable_db_options, current_->storage_info(),
-      log_buffer, earliest_mem_seqno);
+      log_buffer);
  if (result != nullptr) {
    result->SetInputVersion(current_);
  }
@@ -1219,6 +1206,7 @@ Compaction* ColumnFamilyData::CompactRange(
  if (result != nullptr) {
    result->SetInputVersion(current_);
  }
+  TEST_SYNC_POINT("ColumnFamilyData::CompactRange:Return");
  return result;
 }

@@ -1302,8 +1290,8 @@ bool ColumnFamilyData::ReturnThreadLocalSuperVersion(SuperVersion* sv) {
  return false;
 }

-void ColumnFamilyData::InstallSuperVersion(
-    SuperVersionContext* sv_context, InstrumentedMutex* db_mutex) {
+void ColumnFamilyData::InstallSuperVersion(SuperVersionContext* sv_context,
+                                           InstrumentedMutex* db_mutex) {
  db_mutex->AssertHeld();
  return InstallSuperVersion(sv_context, mutable_cf_options_);
 }
@@ -1441,7 +1429,6 @@ Status ColumnFamilyData::ValidateOptions(
  return s;
 }

-#ifndef ROCKSDB_LITE
 Status ColumnFamilyData::SetOptions(
    const DBOptions& db_opts,
    const std::unordered_map<std::string, std::string>& options_map) {
@@ -1460,7 +1447,6 @@ Status ColumnFamilyData::SetOptions(
  }
  return s;
 }
-#endif  // ROCKSDB_LITE

 // REQUIRES: DB mutex held
 Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
@@ -1480,8 +1466,8 @@ Env::WriteLifeTimeHint ColumnFamilyData::CalculateSSTWriteHint(int level) {
    // than base_level.
    return Env::WLTH_MEDIUM;
  }
-  return static_cast<Env::WriteLifeTimeHint>(level - base_level +
-                            static_cast<int>(Env::WLTH_MEDIUM));
+  return static_cast<Env::WriteLifeTimeHint>(
+      level - base_level + static_cast<int>(Env::WLTH_MEDIUM));
 }

 Status ColumnFamilyData::AddDirectories(
@@ -1519,6 +1505,13 @@ FSDirectory* ColumnFamilyData::GetDataDir(size_t path_id) const {
  return data_dirs_[path_id].get();
 }

+void ColumnFamilyData::RecoverEpochNumbers() {
+  assert(current_);
+  auto* vstorage = current_->storage_info();
+  assert(vstorage);
+  vstorage->RecoverEpochNumbers(this);
+}
+
 ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
                                 const ImmutableDBOptions* db_options,
                                 const FileOptions& file_options,
@@ -1577,8 +1570,8 @@ ColumnFamilyData* ColumnFamilySet::GetColumnFamily(uint32_t id) const {
  }
 }

-ColumnFamilyData* ColumnFamilySet::GetColumnFamily(const std::string& name)
-    const {
+ColumnFamilyData* ColumnFamilySet::GetColumnFamily(
+    const std::string& name) const {
  auto cfd_iter = column_families_.find(name);
  if (cfd_iter != column_families_.end()) {
    auto cfd = GetColumnFamily(cfd_iter->second);
@@ -163,8 +163,8 @@ extern const double kIncSlowdownRatio;
 class ColumnFamilyHandleImpl : public ColumnFamilyHandle {
 public:
  // create while holding the mutex
-  ColumnFamilyHandleImpl(
-      ColumnFamilyData* cfd, DBImpl* db, InstrumentedMutex* mutex);
+  ColumnFamilyHandleImpl(ColumnFamilyData* cfd, DBImpl* db,
+                         InstrumentedMutex* mutex);
  // destroy without mutex
  virtual ~ColumnFamilyHandleImpl();
  virtual ColumnFamilyData* cfd() const { return cfd_; }
@@ -189,7 +189,8 @@ class ColumnFamilyHandleImpl : public ColumnFamilyHandle {
 class ColumnFamilyHandleInternal : public ColumnFamilyHandleImpl {
 public:
  ColumnFamilyHandleInternal()
-      : ColumnFamilyHandleImpl(nullptr, nullptr, nullptr), internal_cfd_(nullptr) {}
+      : ColumnFamilyHandleImpl(nullptr, nullptr, nullptr),
+        internal_cfd_(nullptr) {}

  void SetCFD(ColumnFamilyData* _cfd) { internal_cfd_ = _cfd; }
  virtual ColumnFamilyData* cfd() const override { return internal_cfd_; }
@@ -309,10 +310,6 @@ class ColumnFamilyData {
  void SetLogNumber(uint64_t log_number) { log_number_ = log_number; }
  uint64_t GetLogNumber() const { return log_number_; }

-  void SetFlushReason(FlushReason flush_reason) {
-    flush_reason_ = flush_reason;
-  }
-  FlushReason GetFlushReason() const { return flush_reason_; }
  // thread-safe
  const FileOptions* soptions() const;
  const ImmutableOptions* ioptions() const { return &ioptions_; }
@@ -338,12 +335,10 @@ class ColumnFamilyData {
  // Validate CF options against DB options
  static Status ValidateOptions(const DBOptions& db_options,
                                const ColumnFamilyOptions& cf_options);
-#ifndef ROCKSDB_LITE
  // REQUIRES: DB mutex held
  Status SetOptions(
      const DBOptions& db_options,
      const std::unordered_map<std::string, std::string>& options_map);
-#endif  // ROCKSDB_LITE

  InternalStats* internal_stats() { return internal_stats_.get(); }

@@ -357,7 +352,7 @@ class ColumnFamilyData {
  Version* current() { return current_; }
  Version* dummy_versions() { return dummy_versions_; }
  void SetCurrent(Version* _current);
-  uint64_t GetNumLiveVersions() const;  // REQUIRE: DB mutex held
+  uint64_t GetNumLiveVersions() const;    // REQUIRE: DB mutex held
  uint64_t GetTotalSstFilesSize() const;  // REQUIRE: DB mutex held
  uint64_t GetLiveSstFilesSize() const;   // REQUIRE: DB mutex held
  uint64_t GetTotalBlobFileSize() const;  // REQUIRE: DB mutex held
@@ -532,6 +527,24 @@ class ColumnFamilyData {
  void SetMempurgeUsed() { mempurge_used_ = true; }
  bool GetMempurgeUsed() { return mempurge_used_; }

+  // Allocate and return a new epoch number
+  uint64_t NewEpochNumber() { return next_epoch_number_.fetch_add(1); }
+
+  // Get the next epoch number to be assigned
+  uint64_t GetNextEpochNumber() const { return next_epoch_number_.load(); }
+
+  // Set the next epoch number to be assigned
+  void SetNextEpochNumber(uint64_t next_epoch_number) {
+    next_epoch_number_.store(next_epoch_number);
+  }
+
+  // Reset the next epoch number to be assigned
+  void ResetNextEpochNumber() { next_epoch_number_.store(1); }
+
+  // Recover the next epoch number of this CF and epoch number
+  // of its files (if missing)
+  void RecoverEpochNumbers();
+
 private:
  friend class ColumnFamilySet;
  ColumnFamilyData(uint32_t id, const std::string& name,
@@ -552,7 +565,7 @@ class ColumnFamilyData {
  Version* dummy_versions_;  // Head of circular doubly-linked list of versions.
  Version* current_;         // == dummy_versions->prev_

-  std::atomic<int> refs_;      // outstanding references to ColumnFamilyData
+  std::atomic<int> refs_;  // outstanding references to ColumnFamilyData
  std::atomic<bool> initialized_;
  std::atomic<bool> dropped_;  // true if client dropped it

@@ -597,8 +610,6 @@ class ColumnFamilyData {
  // recovered from
  uint64_t log_number_;

-  std::atomic<FlushReason> flush_reason_;
-
  // An object that keeps all the compaction stats
  // and picks the next compaction
  std::unique_ptr<CompactionPicker> compaction_picker_;
@@ -633,6 +644,8 @@ class ColumnFamilyData {
  // a Version associated with this CFD
  std::shared_ptr<CacheReservationManager> file_metadata_cache_res_mgr_;
  bool mempurge_used_;
+
+  std::atomic<uint64_t> next_epoch_number_;
 };

 // ColumnFamilySet has interesting thread-safety requirements
@@ -656,8 +669,7 @@ class ColumnFamilySet {
  // ColumnFamilySet supports iteration
  class iterator {
   public:
-    explicit iterator(ColumnFamilyData* cfd)
-        : current_(cfd) {}
+    explicit iterator(ColumnFamilyData* cfd) : current_(cfd) {}
    // NOTE: minimum operators for for-loop iteration
    iterator& operator++() {
      current_ = current_->next_;
@@ -39,9 +39,7 @@ class EnvCounter : public SpecialEnv {
 public:
  explicit EnvCounter(Env* base)
      : SpecialEnv(base), num_new_writable_file_(0) {}
-  int GetNumberOfNewWritableFileCalls() {
-    return num_new_writable_file_;
-  }
+  int GetNumberOfNewWritableFileCalls() { return num_new_writable_file_; }
  Status NewWritableFile(const std::string& f, std::unique_ptr<WritableFile>* r,
                         const EnvOptions& soptions) override {
    ++num_new_writable_file_;
@@ -73,11 +71,7 @@ class ColumnFamilyTestBase : public testing::Test {
    for (auto h : handles_) {
      ColumnFamilyDescriptor cfdescriptor;
      Status s = h->GetDescriptor(&cfdescriptor);
-#ifdef ROCKSDB_LITE
-      EXPECT_TRUE(s.IsNotSupported());
-#else
      EXPECT_OK(s);
-#endif  // ROCKSDB_LITE
      column_families.push_back(cfdescriptor);
    }
    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
@@ -187,7 +181,7 @@ class ColumnFamilyTestBase : public testing::Test {
  }

  Status OpenReadOnly(std::vector<std::string> cf,
-                         std::vector<ColumnFamilyOptions> options = {}) {
+                      std::vector<ColumnFamilyOptions> options = {}) {
    std::vector<ColumnFamilyDescriptor> column_families;
    names_.clear();
    for (size_t i = 0; i < cf.size(); ++i) {
@@ -199,22 +193,17 @@ class ColumnFamilyTestBase : public testing::Test {
                               &db_);
  }

-#ifndef ROCKSDB_LITE  // ReadOnlyDB is not supported
  void AssertOpenReadOnly(std::vector<std::string> cf,
-                    std::vector<ColumnFamilyOptions> options = {}) {
+                          std::vector<ColumnFamilyOptions> options = {}) {
    ASSERT_OK(OpenReadOnly(cf, options));
  }
-#endif  // !ROCKSDB_LITE
-

  void Open(std::vector<std::string> cf,
            std::vector<ColumnFamilyOptions> options = {}) {
    ASSERT_OK(TryOpen(cf, options));
  }

-  void Open() {
-    Open({"default"});
-  }
+  void Open() { Open({"default"}); }

  DBImpl* dbfull() { return static_cast_with_check<DBImpl>(db_); }

@@ -229,31 +218,20 @@ class ColumnFamilyTestBase : public testing::Test {
  }

  bool IsDbWriteStopped() {
-#ifndef ROCKSDB_LITE
    uint64_t v;
    EXPECT_TRUE(dbfull()->GetIntProperty("rocksdb.is-write-stopped", &v));
    return (v == 1);
-#else
-    return dbfull()->TEST_write_controler().IsStopped();
-#endif  // !ROCKSDB_LITE
  }

  uint64_t GetDbDelayedWriteRate() {
-#ifndef ROCKSDB_LITE
    uint64_t v;
    EXPECT_TRUE(
        dbfull()->GetIntProperty("rocksdb.actual-delayed-write-rate", &v));
    return v;
-#else
-    if (!dbfull()->TEST_write_controler().NeedsDelay()) {
-      return 0;
-    }
-    return dbfull()->TEST_write_controler().delayed_write_rate();
-#endif  // !ROCKSDB_LITE
  }

  void Destroy(const std::vector<ColumnFamilyDescriptor>& column_families =
-                  std::vector<ColumnFamilyDescriptor>()) {
+                   std::vector<ColumnFamilyDescriptor>()) {
    Close();
    ASSERT_OK(DestroyDB(dbname_, Options(db_options_, column_family_options_),
                        column_families));
@@ -272,7 +250,6 @@ class ColumnFamilyTestBase : public testing::Test {
          db_->CreateColumnFamily(current_cf_opt, cfs[i], &handles_[cfi]));
      names_[cfi] = cfs[i];

-#ifndef ROCKSDB_LITE  // RocksDBLite does not support GetDescriptor
      // Verify the CF options of the returned CF handle.
      ColumnFamilyDescriptor desc;
      ASSERT_OK(handles_[cfi]->GetDescriptor(&desc));
@@ -281,7 +258,6 @@ class ColumnFamilyTestBase : public testing::Test {
      ASSERT_OK(RocksDBOptionsParser::VerifyCFOptions(
          ConfigOptions(), desc.options,
          SanitizeOptions(dbfull()->immutable_db_options(), current_cf_opt)));
-#endif  // !ROCKSDB_LITE
      cfi++;
    }
  }
@@ -330,14 +306,11 @@ class ColumnFamilyTestBase : public testing::Test {
    ASSERT_OK(db_->FlushWAL(/*sync=*/false));
  }

-#ifndef ROCKSDB_LITE  // TEST functions in DB are not supported in lite
  void WaitForFlush(int cf) {
    ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable(handles_[cf]));
  }

-  void WaitForCompaction() {
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-  }
+  void WaitForCompaction() { ASSERT_OK(dbfull()->TEST_WaitForCompact()); }

  uint64_t MaxTotalInMemoryState() {
    return dbfull()->TEST_MaxTotalInMemoryState();
@@ -346,7 +319,6 @@ class ColumnFamilyTestBase : public testing::Test {
  void AssertMaxTotalInMemoryState(uint64_t value) {
    ASSERT_EQ(value, MaxTotalInMemoryState());
  }
-#endif  // !ROCKSDB_LITE

  Status Put(int cf, const std::string& key, const std::string& value) {
    return db_->Put(WriteOptions(), handles_[cf], Slice(key), Slice(value));
@@ -354,9 +326,7 @@ class ColumnFamilyTestBase : public testing::Test {
  Status Merge(int cf, const std::string& key, const std::string& value) {
    return db_->Merge(WriteOptions(), handles_[cf], Slice(key), Slice(value));
  }
-  Status Flush(int cf) {
-    return db_->Flush(FlushOptions(), handles_[cf]);
-  }
+  Status Flush(int cf) { return db_->Flush(FlushOptions(), handles_[cf]); }

  std::string Get(int cf, const std::string& key) {
    ReadOptions options;
@@ -386,7 +356,6 @@ class ColumnFamilyTestBase : public testing::Test {
                       "rocksdb.num-files-at-level" + std::to_string(level));
  }

-#ifndef ROCKSDB_LITE
  // Return spread of files per level
  std::string FilesPerLevel(int cf) {
    std::string result;
@@ -403,31 +372,19 @@ class ColumnFamilyTestBase : public testing::Test {
    result.resize(last_non_zero_offset);
    return result;
  }
-#endif

  void AssertFilesPerLevel(const std::string& value, int cf) {
-#ifndef ROCKSDB_LITE
    ASSERT_EQ(value, FilesPerLevel(cf));
-#else
-    (void) value;
-    (void) cf;
-#endif
  }

-#ifndef ROCKSDB_LITE  // GetLiveFilesMetaData is not supported
  int CountLiveFiles() {
    std::vector<LiveFileMetaData> metadata;
    db_->GetLiveFilesMetaData(&metadata);
    return static_cast<int>(metadata.size());
  }
-#endif  // !ROCKSDB_LITE

  void AssertCountLiveFiles(int expected_value) {
-#ifndef ROCKSDB_LITE
    ASSERT_EQ(expected_value, CountLiveFiles());
-#else
-    (void) expected_value;
-#endif
  }

  // Do n memtable flushes, each of which produces an sstable
@@ -441,7 +398,6 @@ class ColumnFamilyTestBase : public testing::Test {
    }
  }

-#ifndef ROCKSDB_LITE  // GetSortedWalFiles is not supported
  int CountLiveLogFiles() {
    int micros_wait_for_log_deletion = 20000;
    env_->SleepForMicroseconds(micros_wait_for_log_deletion);
@@ -470,25 +426,18 @@ class ColumnFamilyTestBase : public testing::Test {
    return ret;
    return 0;
  }
-#endif  // !ROCKSDB_LITE

  void AssertCountLiveLogFiles(int value) {
-#ifndef ROCKSDB_LITE  // GetSortedWalFiles is not supported
    ASSERT_EQ(value, CountLiveLogFiles());
-#else
-    (void) value;
-#endif  // !ROCKSDB_LITE
  }

  void AssertNumberOfImmutableMemtables(std::vector<int> num_per_cf) {
    assert(num_per_cf.size() == handles_.size());

-#ifndef ROCKSDB_LITE  // GetProperty is not supported in lite
    for (size_t i = 0; i < num_per_cf.size(); ++i) {
      ASSERT_EQ(num_per_cf[i], GetProperty(static_cast<int>(i),
                                           "rocksdb.num-immutable-mem-table"));
    }
-#endif  // !ROCKSDB_LITE
  }

  void CopyFile(const std::string& source, const std::string& destination,
@@ -521,14 +470,14 @@ class ColumnFamilyTestBase : public testing::Test {
    return static_cast<int>(files.size());
  }

-  void RecalculateWriteStallConditions(ColumnFamilyData* cfd,
-      const MutableCFOptions& mutable_cf_options)  {
+  void RecalculateWriteStallConditions(
+      ColumnFamilyData* cfd, const MutableCFOptions& mutable_cf_options) {
    // add lock to avoid race condition between
    // `RecalculateWriteStallConditions` which writes to CFStats and
    // background `DBImpl::DumpStats()` threads which read CFStats
    dbfull()->TEST_LockMutex();
    cfd->RecalculateWriteStallConditions(mutable_cf_options);
-    dbfull()-> TEST_UnlockMutex();
+    dbfull()->TEST_UnlockMutex();
  }

  std::vector<ColumnFamilyHandle*> handles_;
@@ -584,7 +533,6 @@ TEST_P(ColumnFamilyTest, DontReuseColumnFamilyID) {
  }
 }

-#ifndef ROCKSDB_LITE
 TEST_P(ColumnFamilyTest, CreateCFRaceWithGetAggProperty) {
  Open();

@@ -607,7 +555,6 @@ TEST_P(ColumnFamilyTest, CreateCFRaceWithGetAggProperty) {

  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 }
-#endif  // !ROCKSDB_LITE

 class FlushEmptyCFTestWithParam
    : public ColumnFamilyTestBase,
@@ -951,7 +898,6 @@ TEST_P(ColumnFamilyTest, IgnoreRecoveredLog) {
  }
 }

-#ifndef ROCKSDB_LITE  // TEST functions used are not supported
 TEST_P(ColumnFamilyTest, FlushTest) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two"});
@@ -970,8 +916,7 @@ TEST_P(ColumnFamilyTest, FlushTest) {
    }

    for (int i = 0; i < 3; ++i) {
-      uint64_t max_total_in_memory_state =
-          MaxTotalInMemoryState();
+      uint64_t max_total_in_memory_state = MaxTotalInMemoryState();
      ASSERT_OK(Flush(i));
      AssertMaxTotalInMemoryState(max_total_in_memory_state);
    }
@@ -1067,7 +1012,6 @@ TEST_P(ColumnFamilyTest, LogDeletionTest) {
  AssertCountLiveLogFiles(4);
  Close();
 }
-#endif  // !ROCKSDB_LITE

 TEST_P(ColumnFamilyTest, CrashAfterFlush) {
  std::unique_ptr<FaultInjectionTestEnv> fault_env(
@@ -1107,7 +1051,6 @@ TEST_P(ColumnFamilyTest, OpenNonexistentColumnFamily) {
  ASSERT_TRUE(TryOpen({"default", "dne"}).IsInvalidArgument());
 }

-#ifndef ROCKSDB_LITE  // WaitForFlush() is not supported
 // Makes sure that obsolete log files get deleted
 TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
  // disable flushing stale column families
@@ -1209,20 +1152,18 @@ TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
  WaitForFlush(2);
  AssertNumberOfImmutableMemtables({0, 0, 0, 0});
  AssertCountLiveLogFiles(12);
-  PutRandomData(1, 2*200, 1000);
+  PutRandomData(1, 2 * 200, 1000);
  WaitForFlush(1);
  AssertNumberOfImmutableMemtables({0, 0, 0, 0});
  AssertCountLiveLogFiles(7);
  Close();
 }
-#endif  // !ROCKSDB_LITE

 // The test is commented out because we want to test that snapshot is
 // not created for memtables not supported it, but There isn't a memtable
 // that doesn't support snapshot right now. If we have one later, we can
 // re-enable the test.
 //
-// #ifndef ROCKSDB_LITE  // Cuckoo is not supported in lite
 //   TEST_P(ColumnFamilyTest, MemtableNotSupportSnapshot) {
 //   db_options_.allow_concurrent_memtable_write = false;
 //   Open();
@@ -1242,7 +1183,6 @@ TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
 //   {second}); auto* s3 = dbfull()->GetSnapshot(); ASSERT_TRUE(s3 == nullptr);
 //   Close();
 // }
-// #endif  // !ROCKSDB_LITE

 class TestComparator : public Comparator {
  int Compare(const ROCKSDB_NAMESPACE::Slice& /*a*/,
@@ -1309,7 +1249,6 @@ TEST_P(ColumnFamilyTest, DifferentMergeOperators) {
  Close();
 }

-#ifndef ROCKSDB_LITE  // WaitForFlush() is not supported
 TEST_P(ColumnFamilyTest, DifferentCompactionStyles) {
  Open();
  CreateColumnFamilies({"one", "two"});
@@ -1377,9 +1316,7 @@ TEST_P(ColumnFamilyTest, DifferentCompactionStyles) {

  Close();
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE
 // Sync points not supported in RocksDB Lite

 TEST_P(ColumnFamilyTest, MultipleManualCompactions) {
@@ -2043,9 +1980,7 @@ TEST_P(ColumnFamilyTest, SameCFAutomaticManualCompactions) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  // Tailing iterator not supported
 namespace {
 std::string IterStatus(Iterator* iter) {
  std::string result;
@@ -2103,9 +2038,7 @@ TEST_P(ColumnFamilyTest, NewIteratorsTest) {
    Destroy();
  }
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  // ReadOnlyDB is not supported
 TEST_P(ColumnFamilyTest, ReadOnlyDBTest) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two", "three", "four"});
@@ -2123,7 +2056,6 @@ TEST_P(ColumnFamilyTest, ReadOnlyDBTest) {
  ASSERT_EQ("bla", Get(1, "foo"));
  ASSERT_EQ("blablablabla", Get(2, "foo"));

-
  // test newiterators
  {
    std::vector<Iterator*> iterators;
@@ -2155,9 +2087,7 @@ TEST_P(ColumnFamilyTest, ReadOnlyDBTest) {
  s = OpenReadOnly({"one", "four"});
  ASSERT_TRUE(!s.ok());
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  //  WaitForFlush() is not supported in lite
 TEST_P(ColumnFamilyTest, DontRollEmptyLogs) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two", "three", "four"});
@@ -2179,9 +2109,7 @@ TEST_P(ColumnFamilyTest, DontRollEmptyLogs) {
  ASSERT_EQ(static_cast<size_t>(total_new_writable_files), handles_.size() + 1);
  Close();
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  //  WaitForCompaction() is not supported in lite
 TEST_P(ColumnFamilyTest, FlushStaleColumnFamilies) {
  Open();
  CreateColumnFamilies({"one", "two"});
@@ -2228,7 +2156,6 @@ TEST_P(ColumnFamilyTest, FlushStaleColumnFamilies) {
  ASSERT_EQ(0, dbfull()->TEST_total_log_size());
  Close();
 }
-#endif  // !ROCKSDB_LITE

 TEST_P(ColumnFamilyTest, CreateMissingColumnFamilies) {
  Status s = TryOpen({"one", "two"});
@@ -2468,8 +2395,6 @@ TEST_P(ColumnFamilyTest, FlushAndDropRaceCondition) {
  Destroy();
 }

-#ifndef ROCKSDB_LITE
-// skipped as persisting options is not supported in ROCKSDB_LITE
 namespace {
 std::atomic<int> test_stage(0);
 std::atomic<bool> ordered_by_writethread(false);
@@ -2488,7 +2413,7 @@ void DropSingleColumnFamily(ColumnFamilyTest* cf_test, int cf_id,
  }
  test_stage = kChildThreadFinishDroppingColumnFamily;
 }
-}  // namespace
+}  // anonymous namespace

 TEST_P(ColumnFamilyTest, CreateAndDropRace) {
  const int kCfCount = 5;
@@ -2551,7 +2476,6 @@ TEST_P(ColumnFamilyTest, CreateAndDropRace) {
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
 }
-#endif  // !ROCKSDB_LITE

 TEST_P(ColumnFamilyTest, WriteStallSingleColumnFamily) {
  const uint64_t kBaseRate = 800000u;
@@ -2961,7 +2885,6 @@ TEST_P(ColumnFamilyTest, CreateDropAndDestroy) {
  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
 }

-#ifndef ROCKSDB_LITE
 TEST_P(ColumnFamilyTest, CreateDropAndDestroyWithoutFileDeletion) {
  ColumnFamilyHandle* cfh;
  Open();
@@ -3016,9 +2939,7 @@ TEST_P(ColumnFamilyTest, FlushCloseWALFiles) {
  db_options_.env = env_;
  Close();
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  // WaitForFlush() is not supported
 TEST_P(ColumnFamilyTest, IteratorCloseWALFile1) {
  SpecialEnv env(Env::Default());
  db_options_.env = &env;
@@ -3125,9 +3046,7 @@ TEST_P(ColumnFamilyTest, IteratorCloseWALFile2) {
  db_options_.env = env_;
  Close();
 }
-#endif  // !ROCKSDB_LITE

-#ifndef ROCKSDB_LITE  // TEST functions are not supported in lite
 TEST_P(ColumnFamilyTest, ForwardIteratorCloseWALFile) {
  SpecialEnv env(Env::Default());
  // Allow both of flush and purge job to schedule.
@@ -3203,7 +3122,6 @@ TEST_P(ColumnFamilyTest, ForwardIteratorCloseWALFile) {
  db_options_.env = env_;
  Close();
 }
-#endif  // !ROCKSDB_LITE

 // Disable on windows because SyncWAL requires env->IsSyncThreadSafe()
 // to return true which is not so in unbuffered mode.
@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

-#ifndef ROCKSDB_LITE

 #include <mutex>
 #include <string>
@@ -348,9 +347,7 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
      return true;
    }

-    void SetDB(DB* db) {
-      db_ = db;
-    }
+    void SetDB(DB* db) { db_ = db; }

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

@@ -358,7 +355,6 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
    DB* db_;
  };

-
  std::shared_ptr<FilterWithGet> cf(new FilterWithGet());

  Options options;
@@ -385,7 +381,6 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
        db->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), {fname}, 0));
  }

-
  delete db;
 }

@@ -400,10 +395,9 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
  }
  // Check that passing `CompressionType::kDisableCompressionOption` to
  // `CompactFiles` causes it to use the column family compression options.
-  for (auto compaction_style :
-       {CompactionStyle::kCompactionStyleLevel,
-        CompactionStyle::kCompactionStyleUniversal,
-        CompactionStyle::kCompactionStyleNone}) {
+  for (auto compaction_style : {CompactionStyle::kCompactionStyleLevel,
+                                CompactionStyle::kCompactionStyleUniversal,
+                                CompactionStyle::kCompactionStyleNone}) {
    ASSERT_OK(DestroyDB(db_name_, Options()));
    Options options;
    options.compaction_style = compaction_style;
@@ -495,13 +489,3 @@ int main(int argc, char** argv) {
  return RUN_ALL_TESTS();
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr,
-          "SKIPPED as DBImpl::CompactFiles is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE
@@ -238,12 +238,19 @@ Compaction::Compaction(
      inputs_(PopulateWithAtomicBoundaries(vstorage, std::move(_inputs))),
      grandparents_(std::move(_grandparents)),
      score_(_score),
-      bottommost_level_(IsBottommostLevel(output_level_, vstorage, inputs_)),
+      bottommost_level_(
+          // For simplicity, we don't support the concept of "bottommost level"
+          // with
+          // `CompactionReason::kExternalSstIngestion` and
+          // `CompactionReason::kRefitLevel`
+          (_compaction_reason == CompactionReason::kExternalSstIngestion ||
+           _compaction_reason == CompactionReason::kRefitLevel)
+              ? false
+              : IsBottommostLevel(output_level_, vstorage, inputs_)),
      is_full_compaction_(IsFullCompaction(vstorage, inputs_)),
      is_manual_compaction_(_manual_compaction),
      trim_ts_(_trim_ts),
      is_trivial_move_(false),
-
      compaction_reason_(_compaction_reason),
      notify_on_compaction_completion_(false),
      enable_blob_garbage_collection_(
@@ -258,8 +265,15 @@ Compaction::Compaction(
                  _blob_garbage_collection_age_cutoff > 1
              ? mutable_cf_options()->blob_garbage_collection_age_cutoff
              : _blob_garbage_collection_age_cutoff),
-      penultimate_level_(EvaluatePenultimateLevel(
-          vstorage, immutable_options_, start_level_, output_level_)) {
+      penultimate_level_(
+          // For simplicity, we don't support the concept of "penultimate level"
+          // with `CompactionReason::kExternalSstIngestion` and
+          // `CompactionReason::kRefitLevel`
+          _compaction_reason == CompactionReason::kExternalSstIngestion ||
+                  _compaction_reason == CompactionReason::kRefitLevel
+              ? Compaction::kInvalidLevel
+              : EvaluatePenultimateLevel(vstorage, immutable_options_,
+                                         start_level_, output_level_)) {
  MarkFilesBeingCompacted(true);
  if (is_manual_compaction_) {
    compaction_reason_ = CompactionReason::kManualCompaction;
@@ -332,6 +346,7 @@ void Compaction::PopulatePenultimateLevelOutputRange() {
  // the case that the penultimate level is empty).
  if (immutable_options_.compaction_style == kCompactionStyleUniversal) {
    exclude_level = kInvalidLevel;
+    penultimate_output_range_type_ = PenultimateOutputRangeType::kFullRange;
    std::set<uint64_t> penultimate_inputs;
    for (const auto& input_lvl : inputs_) {
      if (input_lvl.level == penultimate_level_) {
@@ -345,7 +360,8 @@ void Compaction::PopulatePenultimateLevelOutputRange() {
      if (penultimate_inputs.find(file->fd.GetNumber()) ==
          penultimate_inputs.end()) {
        exclude_level = number_levels_ - 1;
-        penultimate_output_range_type_ = PenultimateOutputRangeType::kFullRange;
+        penultimate_output_range_type_ =
+            PenultimateOutputRangeType::kNonLastRange;
        break;
      }
    }
@@ -354,35 +370,6 @@ void Compaction::PopulatePenultimateLevelOutputRange() {
  GetBoundaryKeys(input_vstorage_, inputs_,
                  &penultimate_level_smallest_user_key_,
                  &penultimate_level_largest_user_key_, exclude_level);
-
-  // If there's a case that the penultimate level output range is overlapping
-  // with the existing files, disable the penultimate level output by setting
-  // the range to empty. One example is the range delete could have overlap
-  // boundary with the next file. (which is actually a false overlap)
-  // TODO: Exclude such false overlap, so it won't disable the penultimate
-  //  output.
-  std::set<uint64_t> penultimate_inputs;
-  for (const auto& input_lvl : inputs_) {
-    if (input_lvl.level == penultimate_level_) {
-      for (const auto& file : input_lvl.files) {
-        penultimate_inputs.emplace(file->fd.GetNumber());
-      }
-    }
-  }
-
-  auto penultimate_files = input_vstorage_->LevelFiles(penultimate_level_);
-  for (const auto& file : penultimate_files) {
-    if (penultimate_inputs.find(file->fd.GetNumber()) ==
-            penultimate_inputs.end() &&
-        OverlapPenultimateLevelOutputRange(file->smallest.user_key(),
-                                           file->largest.user_key())) {
-      // basically disable the penultimate range output. which should be rare
-      // or a false overlap caused by range del
-      penultimate_level_smallest_user_key_ = "";
-      penultimate_level_largest_user_key_ = "";
-      penultimate_output_range_type_ = PenultimateOutputRangeType::kDisabled;
-    }
-  }
 }

 Compaction::~Compaction() {
@@ -807,6 +794,16 @@ uint64_t Compaction::MinInputFileOldestAncesterTime(
  return min_oldest_ancester_time;
 }

+uint64_t Compaction::MinInputFileEpochNumber() const {
+  uint64_t min_epoch_number = std::numeric_limits<uint64_t>::max();
+  for (const auto& inputs_per_level : inputs_) {
+    for (const auto& file : inputs_per_level.files) {
+      min_epoch_number = std::min(min_epoch_number, file->epoch_number);
+    }
+  }
+  return min_epoch_number;
+}
+
 int Compaction::EvaluatePenultimateLevel(
    const VersionStorageInfo* vstorage,
    const ImmutableOptions& immutable_options, const int start_level,
@@ -378,6 +378,9 @@ class Compaction {
  // This is used to filter out some input files' ancester's time range.
  uint64_t MinInputFileOldestAncesterTime(const InternalKey* start,
                                          const InternalKey* end) const;
+  // Return the minimum epoch number among
+  // input files' associated with this compaction
+  uint64_t MinInputFileEpochNumber() const;

  // Called by DBImpl::NotifyOnCompactionCompleted to make sure number of
  // compaction begin and compaction completion callbacks match.
@@ -124,6 +124,9 @@ CompactionIterator::CompactionIterator(
         timestamp_size_ == full_history_ts_low_->size());
 #endif
  input_.SetPinnedItersMgr(&pinned_iters_mgr_);
+  // The default `merge_until_status_` does not need to be checked since it is
+  // overwritten as soon as `MergeUntil()` is called
+  merge_until_status_.PermitUncheckedError();
  TEST_SYNC_POINT_CALLBACK("CompactionIterator:AfterInit", compaction_.get());
 }

@@ -168,11 +171,30 @@ void CompactionIterator::Next() {
      }

      // Keep current_key_ in sync.
-      current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
+      if (0 == timestamp_size_) {
+        current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
+      } else {
+        Slice ts = ikey_.GetTimestamp(timestamp_size_);
+        current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type, &ts);
+      }
      key_ = current_key_.GetInternalKey();
      ikey_.user_key = current_key_.GetUserKey();
      validity_info_.SetValid(ValidContext::kMerge1);
    } else {
+      if (merge_until_status_.IsMergeInProgress()) {
+        // `Status::MergeInProgress()` tells us that the previous `MergeUntil()`
+        // produced only merge operands. Those merge operands were accessed and
+        // written out using `merge_out_iter_`. Since `merge_out_iter_` is
+        // exhausted at this point, all merge operands have been written out.
+        //
+        // Still, there may be a base value (PUT, DELETE, SINGLEDEL, etc.) that
+        // needs to be written out. Normally, `CompactionIterator` would skip it
+        // on the basis that it has already output something in the same
+        // snapshot stripe. To prevent this, we reset `has_current_user_key_` to
+        // trick the future iteration from finding out the snapshot stripe is
+        // unchanged.
+        has_current_user_key_ = false;
+      }
      // We consumed all pinned merge operands, release pinned iterators
      pinned_iters_mgr_.ReleasePinnedData();
      // MergeHelper moves the iterator to the first record after the merged
@@ -199,39 +221,43 @@ void CompactionIterator::Next() {

 bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
                                              Slice* skip_until) {
-  // TODO: support compaction filter for wide-column entities
-  if (!compaction_filter_ ||
-      (ikey_.type != kTypeValue && ikey_.type != kTypeBlobIndex)) {
+  if (!compaction_filter_) {
    return true;
  }
-  bool error = false;
-  // If the user has specified a compaction filter and the sequence
-  // number is greater than any external snapshot, then invoke the
-  // filter. If the return value of the compaction filter is true,
-  // replace the entry with a deletion marker.
-  CompactionFilter::Decision filter = CompactionFilter::Decision::kUndetermined;
-  compaction_filter_value_.clear();
-  compaction_filter_skip_until_.Clear();
+
+  // TODO: support compaction filter for wide-column entities
+  if (ikey_.type != kTypeValue && ikey_.type != kTypeBlobIndex) {
+    return true;
+  }
+
+  CompactionFilter::Decision decision =
+      CompactionFilter::Decision::kUndetermined;
  CompactionFilter::ValueType value_type =
      ikey_.type == kTypeValue ? CompactionFilter::ValueType::kValue
                               : CompactionFilter::ValueType::kBlobIndex;
+
  // Hack: pass internal key to BlobIndexCompactionFilter since it needs
  // to get sequence number.
  assert(compaction_filter_);
-  Slice& filter_key =
-      (ikey_.type == kTypeValue ||
+  const Slice& filter_key =
+      (ikey_.type != kTypeBlobIndex ||
       !compaction_filter_->IsStackedBlobDbInternalCompactionFilter())
          ? ikey_.user_key
          : key_;
+
+  compaction_filter_value_.clear();
+  compaction_filter_skip_until_.Clear();
+
  {
    StopWatchNano timer(clock_, report_detailed_time_);
-    if (kTypeBlobIndex == ikey_.type) {
-      filter = compaction_filter_->FilterBlobByKey(
+
+    if (ikey_.type == kTypeBlobIndex) {
+      decision = compaction_filter_->FilterBlobByKey(
          level_, filter_key, &compaction_filter_value_,
          compaction_filter_skip_until_.rep());
-      if (CompactionFilter::Decision::kUndetermined == filter &&
+      if (decision == CompactionFilter::Decision::kUndetermined &&
          !compaction_filter_->IsStackedBlobDbInternalCompactionFilter()) {
-        if (compaction_ == nullptr) {
+        if (!compaction_) {
          status_ =
              Status::Corruption("Unexpected blob index outside of compaction");
          validity_info_.Invalidate();
@@ -277,17 +303,18 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
        value_type = CompactionFilter::ValueType::kValue;
      }
    }
-    if (CompactionFilter::Decision::kUndetermined == filter) {
-      filter = compaction_filter_->FilterV2(
+    if (decision == CompactionFilter::Decision::kUndetermined) {
+      decision = compaction_filter_->FilterV2(
          level_, filter_key, value_type,
          blob_value_.empty() ? value_ : blob_value_, &compaction_filter_value_,
          compaction_filter_skip_until_.rep());
    }
+
    iter_stats_.total_filter_time +=
        env_ != nullptr && report_detailed_time_ ? timer.ElapsedNanos() : 0;
  }

-  if (CompactionFilter::Decision::kUndetermined == filter) {
+  if (decision == CompactionFilter::Decision::kUndetermined) {
    // Should not reach here, since FilterV2 should never return kUndetermined.
    status_ =
        Status::NotSupported("FilterV2() should never return kUndetermined");
@@ -295,15 +322,15 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
    return false;
  }

-  if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil &&
+  if (decision == CompactionFilter::Decision::kRemoveAndSkipUntil &&
      cmp_->Compare(*compaction_filter_skip_until_.rep(), ikey_.user_key) <=
          0) {
    // Can't skip to a key smaller than the current one.
    // Keep the key as per FilterV2 documentation.
-    filter = CompactionFilter::Decision::kKeep;
+    decision = CompactionFilter::Decision::kKeep;
  }

-  if (filter == CompactionFilter::Decision::kRemove) {
+  if (decision == CompactionFilter::Decision::kRemove) {
    // convert the current key to a delete; key_ is pointing into
    // current_key_ at this point, so updating current_key_ updates key()
    ikey_.type = kTypeDeletion;
@@ -311,7 +338,7 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
    // no value associated with delete
    value_.clear();
    iter_stats_.num_record_drop_user++;
-  } else if (filter == CompactionFilter::Decision::kPurge) {
+  } else if (decision == CompactionFilter::Decision::kPurge) {
    // convert the current key to a single delete; key_ is pointing into
    // current_key_ at this point, so updating current_key_ updates key()
    ikey_.type = kTypeSingleDeletion;
@@ -319,19 +346,19 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
    // no value associated with single delete
    value_.clear();
    iter_stats_.num_record_drop_user++;
-  } else if (filter == CompactionFilter::Decision::kChangeValue) {
-    if (ikey_.type == kTypeBlobIndex) {
-      // value transfer from blob file to inlined data
+  } else if (decision == CompactionFilter::Decision::kChangeValue) {
+    if (ikey_.type != kTypeValue) {
      ikey_.type = kTypeValue;
-      current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
+      current_key_.UpdateInternalKey(ikey_.sequence, kTypeValue);
    }
+
    value_ = compaction_filter_value_;
-  } else if (filter == CompactionFilter::Decision::kRemoveAndSkipUntil) {
+  } else if (decision == CompactionFilter::Decision::kRemoveAndSkipUntil) {
    *need_skip = true;
    compaction_filter_skip_until_.ConvertFromUserKey(kMaxSequenceNumber,
                                                     kValueTypeForSeek);
    *skip_until = compaction_filter_skip_until_.Encode();
-  } else if (filter == CompactionFilter::Decision::kChangeBlobIndex) {
+  } else if (decision == CompactionFilter::Decision::kChangeBlobIndex) {
    // Only the StackableDB-based BlobDB impl's compaction filter should return
    // kChangeBlobIndex. Decision about rewriting blob and changing blob index
    // in the integrated BlobDB impl is made in subsequent call to
@@ -343,23 +370,27 @@ bool CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
      validity_info_.Invalidate();
      return false;
    }
-    if (ikey_.type == kTypeValue) {
-      // value transfer from inlined data to blob file
+
+    if (ikey_.type != kTypeBlobIndex) {
      ikey_.type = kTypeBlobIndex;
-      current_key_.UpdateInternalKey(ikey_.sequence, ikey_.type);
+      current_key_.UpdateInternalKey(ikey_.sequence, kTypeBlobIndex);
    }
+
    value_ = compaction_filter_value_;
-  } else if (filter == CompactionFilter::Decision::kIOError) {
+  } else if (decision == CompactionFilter::Decision::kIOError) {
    if (!compaction_filter_->IsStackedBlobDbInternalCompactionFilter()) {
      status_ = Status::NotSupported(
          "CompactionFilter for integrated BlobDB should not return kIOError");
      validity_info_.Invalidate();
      return false;
    }
+
    status_ = Status::IOError("Failed to access blob during compaction filter");
-    error = true;
+    validity_info_.Invalidate();
+    return false;
  }
-  return !error;
+
+  return true;
 }

 void CompactionIterator::NextFromInput() {
@@ -825,8 +856,8 @@ void CompactionIterator::NextFromInput() {
                 cmp_with_history_ts_low_ < 0)) &&
               bottommost_level_) {
      // Handle the case where we have a delete key at the bottom most level
-      // We can skip outputting the key iff there are no subsequent puts for this
-      // key
+      // We can skip outputting the key iff there are no subsequent puts for
+      // this key
      assert(!compaction_ || compaction_->KeyNotExistsBeyondOutputLevel(
                                 ikey_.user_key, &level_ptrs_));
      ParsedInternalKey next_ikey;
@@ -853,8 +884,8 @@ void CompactionIterator::NextFromInput() {
              DefinitelyNotInSnapshot(next_ikey.sequence, prev_snapshot))) {
        AdvanceInputIter();
      }
-      // If you find you still need to output a row with this key, we need to output the
-      // delete too
+      // If you find you still need to output a row with this key, we need to
+      // output the delete too
      if (input_.Valid() &&
          (ParseInternalKey(input_.key(), &next_ikey, allow_data_in_errors_)
               .ok()) &&
@@ -875,14 +906,15 @@ void CompactionIterator::NextFromInput() {
      // have hit (A)
      // We encapsulate the merge related state machine in a different
      // object to minimize change to the existing flow.
-      Status s = merge_helper_->MergeUntil(
+      merge_until_status_ = merge_helper_->MergeUntil(
          &input_, range_del_agg_, prev_snapshot, bottommost_level_,
-          allow_data_in_errors_, blob_fetcher_.get(), prefetch_buffers_.get(),
-          &iter_stats_);
+          allow_data_in_errors_, blob_fetcher_.get(), full_history_ts_low_,
+          prefetch_buffers_.get(), &iter_stats_);
      merge_out_iter_.SeekToFirst();

-      if (!s.ok() && !s.IsMergeInProgress()) {
-        status_ = s;
+      if (!merge_until_status_.ok() &&
+          !merge_until_status_.IsMergeInProgress()) {
+        status_ = merge_until_status_;
        return;
      } else if (merge_out_iter_.Valid()) {
        // NOTE: key, value, and ikey_ refer to old entries.
@@ -1214,8 +1246,8 @@ inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
    ROCKS_LOG_FATAL(info_log_,
                    "No snapshot left in findEarliestVisibleSnapshot");
  }
-  auto snapshots_iter = std::lower_bound(
-      snapshots_->begin(), snapshots_->end(), in);
+  auto snapshots_iter =
+      std::lower_bound(snapshots_->begin(), snapshots_->end(), in);
  assert(prev_snapshot != nullptr);
  if (snapshots_iter == snapshots_->begin()) {
    *prev_snapshot = 0;
@@ -1230,8 +1262,8 @@ inline SequenceNumber CompactionIterator::findEarliestVisibleSnapshot(
    }
  }
  if (snapshot_checker_ == nullptr) {
-    return snapshots_iter != snapshots_->end()
-      ? *snapshots_iter : kMaxSequenceNumber;
+    return snapshots_iter != snapshots_->end() ? *snapshots_iter
+                                               : kMaxSequenceNumber;
  }
  bool has_released_snapshot = !released_snapshots_.empty();
  for (; snapshots_iter != snapshots_->end(); ++snapshots_iter) {
@@ -432,6 +432,7 @@ class CompactionIterator {
  bool clear_and_output_next_key_ = false;

  MergeOutputIterator merge_out_iter_;
+  Status merge_until_status_;
  // PinnedIteratorsManager used to pin input_ Iterator blocks while reading
  // merge operands and then releasing them after consuming them.
  PinnedIteratorsManager pinned_iters_mgr_;
@@ -203,7 +203,8 @@ class TestSnapshotChecker : public SnapshotChecker {
 public:
  explicit TestSnapshotChecker(
      SequenceNumber last_committed_sequence,
-      const std::unordered_map<SequenceNumber, SequenceNumber>& snapshots = {{}})
+      const std::unordered_map<SequenceNumber, SequenceNumber>& snapshots =
+          {{}})
      : last_committed_sequence_(last_committed_sequence),
        snapshots_(snapshots) {}

@@ -811,6 +812,8 @@ TEST_P(PerKeyPlacementCompIteratorTest, SplitLastLevelData) {
  c_iter_->Next();
  ASSERT_OK(c_iter_->status());
  ASSERT_FALSE(c_iter_->Valid());
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

 TEST_P(PerKeyPlacementCompIteratorTest, SnapshotData) {
@@ -876,6 +879,8 @@ TEST_P(PerKeyPlacementCompIteratorTest, ConflictWithSnapshot) {
  // output_to_penultimate_level.
  c_iter_->Next();
  ASSERT_TRUE(c_iter_->status().IsCorruption());
+  SyncPoint::GetInstance()->DisableProcessing();
+  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

 INSTANTIATE_TEST_CASE_P(PerKeyPlacementCompIteratorTest,
@@ -1038,7 +1043,7 @@ TEST_F(CompactionIteratorWithSnapshotCheckerTest,

 TEST_F(CompactionIteratorWithSnapshotCheckerTest,
       NotRemoveDeletionIfValuePresentToEarlierSnapshot) {
-  AddSnapshot(2,1);
+  AddSnapshot(2, 1);
  RunTest({test::KeyStr("a", 4, kTypeDeletion),
           test::KeyStr("a", 1, kTypeValue), test::KeyStr("b", 3, kTypeValue)},
          {"", "", ""},
@@ -1250,6 +1255,31 @@ TEST_P(CompactionIteratorTsGcTest, NoKeyEligibleForGC) {
  }
 }

+TEST_P(CompactionIteratorTsGcTest, NoMergeEligibleForGc) {
+  constexpr char user_key[] = "a";
+  const std::vector<std::string> input_keys = {
+      test::KeyStr(10002, user_key, 102, kTypeMerge),
+      test::KeyStr(10001, user_key, 101, kTypeMerge),
+      test::KeyStr(10000, user_key, 100, kTypeValue)};
+  const std::vector<std::string> input_values = {"2", "1", "a0"};
+  std::shared_ptr<MergeOperator> merge_op =
+      MergeOperators::CreateStringAppendTESTOperator();
+  const std::vector<std::string>& expected_keys = input_keys;
+  const std::vector<std::string>& expected_values = input_values;
+  const std::vector<std::pair<bool, bool>> params = {
+      {false, false}, {false, true}, {true, true}};
+  for (const auto& param : params) {
+    const bool bottommost_level = param.first;
+    const bool key_not_exists_beyond_output_level = param.second;
+    RunTest(input_keys, input_values, expected_keys, expected_values,
+            /*last_committed_seq=*/kMaxSequenceNumber, merge_op.get(),
+            /*compaction_filter=*/nullptr, bottommost_level,
+            /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
+            key_not_exists_beyond_output_level,
+            /*full_history_ts_low=*/nullptr);
+  }
+}
+
 TEST_P(CompactionIteratorTsGcTest, AllKeysOlderThanThreshold) {
  constexpr char user_key[][2] = {{'a', '\0'}, {'b', '\0'}};
  const std::vector<std::string> input_keys = {
@@ -1303,6 +1333,91 @@ TEST_P(CompactionIteratorTsGcTest, AllKeysOlderThanThreshold) {
  }
 }

+TEST_P(CompactionIteratorTsGcTest, SomeMergesOlderThanThreshold) {
+  constexpr char user_key[][2] = {"a", "f"};
+  const std::vector<std::string> input_keys = {
+      test::KeyStr(/*ts=*/25000, user_key[0], /*seq=*/2500, kTypeMerge),
+      test::KeyStr(/*ts=*/19000, user_key[0], /*seq=*/2300, kTypeMerge),
+      test::KeyStr(/*ts=*/18000, user_key[0], /*seq=*/1800, kTypeMerge),
+      test::KeyStr(/*ts=*/16000, user_key[0], /*seq=*/1600, kTypeValue),
+      test::KeyStr(/*ts=*/19000, user_key[1], /*seq=*/2000, kTypeMerge),
+      test::KeyStr(/*ts=*/17000, user_key[1], /*seq=*/1700, kTypeMerge),
+      test::KeyStr(/*ts=*/15000, user_key[1], /*seq=*/1600,
+                   kTypeDeletionWithTimestamp)};
+  const std::vector<std::string> input_values = {"25", "19", "18", "16",
+                                                 "19", "17", ""};
+  std::shared_ptr<MergeOperator> merge_op =
+      MergeOperators::CreateStringAppendTESTOperator();
+  std::string full_history_ts_low;
+  PutFixed64(&full_history_ts_low, 20000);
+
+  const std::vector<std::pair<bool, bool>> params = {
+      {false, false}, {false, true}, {true, true}};
+
+  {
+    AddSnapshot(1600);
+    AddSnapshot(1900);
+    const std::vector<std::string> expected_keys = {
+        test::KeyStr(/*ts=*/25000, user_key[0], /*seq=*/2500, kTypeMerge),
+        test::KeyStr(/*ts=*/19000, user_key[0], /*seq=*/2300, kTypeMerge),
+        test::KeyStr(/*ts=*/18000, user_key[0], /*seq=*/1800, kTypeMerge),
+        test::KeyStr(/*ts=*/16000, user_key[0], /*seq=*/1600, kTypeValue),
+        test::KeyStr(/*ts=*/19000, user_key[1], /*seq=*/2000, kTypeMerge),
+        test::KeyStr(/*ts=*/17000, user_key[1], /*seq=*/1700, kTypeMerge),
+        test::KeyStr(/*ts=*/15000, user_key[1], /*seq=*/1600,
+                     kTypeDeletionWithTimestamp)};
+    const std::vector<std::string> expected_values = {"25", "19", "18", "16",
+                                                      "19", "17", ""};
+    for (const auto& param : params) {
+      const bool bottommost_level = param.first;
+      const bool key_not_exists_beyond_output_level = param.second;
+      auto expected_keys_copy = expected_keys;
+      auto expected_values_copy = expected_values;
+      if (bottommost_level || key_not_exists_beyond_output_level) {
+        // the kTypeDeletionWithTimestamp will be dropped
+        expected_keys_copy.pop_back();
+        expected_values_copy.pop_back();
+        if (bottommost_level) {
+          // seq zero
+          expected_keys_copy[3] =
+              test::KeyStr(/*ts=*/0, user_key[0], /*seq=*/0, kTypeValue);
+        }
+      }
+      RunTest(input_keys, input_values, expected_keys_copy,
+              expected_values_copy,
+              /*last_committed_seq=*/kMaxSequenceNumber, merge_op.get(),
+              /*compaction_filter=*/nullptr, bottommost_level,
+              /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
+              key_not_exists_beyond_output_level, &full_history_ts_low);
+    }
+    ClearSnapshots();
+  }
+
+  // No snapshots
+  {
+    const std::vector<std::string> expected_keys = {
+        test::KeyStr(/*ts=*/25000, user_key[0], /*seq=*/2500, kTypeValue),
+        test::KeyStr(/*ts=*/19000, user_key[1], /*seq=*/2000, kTypeValue)};
+    const std::vector<std::string> expected_values = {"16,18,19,25", "17,19"};
+    for (const auto& param : params) {
+      const bool bottommost_level = param.first;
+      const bool key_not_exists_beyond_output_level = param.second;
+      auto expected_keys_copy = expected_keys;
+      auto expected_values_copy = expected_values;
+      if (bottommost_level) {
+        expected_keys_copy[1] =
+            test::KeyStr(/*ts=*/0, user_key[1], /*seq=*/0, kTypeValue);
+      }
+      RunTest(input_keys, input_values, expected_keys_copy,
+              expected_values_copy,
+              /*last_committed_seq=*/kMaxSequenceNumber, merge_op.get(),
+              /*compaction_filter=*/nullptr, bottommost_level,
+              /*earliest_write_conflict_snapshot=*/kMaxSequenceNumber,
+              key_not_exists_beyond_output_level, &full_history_ts_low);
+    }
+  }
+}
+
 TEST_P(CompactionIteratorTsGcTest, NewHidesOldSameSnapshot) {
  constexpr char user_key[] = "a";
  const std::vector<std::string> input_keys = {
@@ -99,6 +99,8 @@ const char* GetCompactionReasonString(CompactionReason compaction_reason) {
      return "ForcedBlobGC";
    case CompactionReason::kRoundRobinTtl:
      return "RoundRobinTtl";
+    case CompactionReason::kRefitLevel:
+      return "RefitLevel";
    case CompactionReason::kNumOfReasons:
      // fall through
    default:
@@ -714,11 +716,12 @@ Status CompactionJob::Run() {
          break;
        }
        // Verify that the table is usable
-        // We set for_compaction to false and don't OptimizeForCompactionTableRead
-        // here because this is a special case after we finish the table building
-        // No matter whether use_direct_io_for_flush_and_compaction is true,
-        // we will regard this verification as user reads since the goal is
-        // to cache it here for further user reads
+        // We set for_compaction to false and don't
+        // OptimizeForCompactionTableRead here because this is a special case
+        // after we finish the table building No matter whether
+        // use_direct_io_for_flush_and_compaction is true, we will regard this
+        // verification as user reads since the goal is to cache it here for
+        // further user reads
        ReadOptions read_options;
        InternalIterator* iter = cfd->table_cache()->NewIterator(
            read_options, file_options_, cfd->internal_comparator(),
@@ -764,8 +767,8 @@ Status CompactionJob::Run() {
      }
    };
    for (size_t i = 1; i < compact_->sub_compact_states.size(); i++) {
-      thread_pool.emplace_back(verify_table,
-                               std::ref(compact_->sub_compact_states[i].status));
+      thread_pool.emplace_back(
+          verify_table, std::ref(compact_->sub_compact_states[i].status));
    }
    verify_table(compact_->sub_compact_states[0].status);
    for (auto& thread : thread_pool) {
@@ -975,7 +978,6 @@ Status CompactionJob::Install(const MutableCFOptions& mutable_cf_options) {

 void CompactionJob::NotifyOnSubcompactionBegin(
    SubcompactionState* sub_compact) {
-#ifndef ROCKSDB_LITE
  Compaction* c = compact_->compaction;

  if (db_options_.listeners.empty()) {
@@ -1001,14 +1003,10 @@ void CompactionJob::NotifyOnSubcompactionBegin(
  }
  info.status.PermitUncheckedError();

-#else
-  (void)sub_compact;
-#endif  // ROCKSDB_LITE
 }

 void CompactionJob::NotifyOnSubcompactionCompleted(
    SubcompactionState* sub_compact) {
-#ifndef ROCKSDB_LITE

  if (db_options_.listeners.empty()) {
    return;
@@ -1029,16 +1027,12 @@ void CompactionJob::NotifyOnSubcompactionCompleted(
  for (const auto& listener : db_options_.listeners) {
    listener->OnSubcompactionCompleted(info);
  }
-#else
-  (void)sub_compact;
-#endif  // ROCKSDB_LITE
 }

 void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
  assert(sub_compact);
  assert(sub_compact->compaction);

-#ifndef ROCKSDB_LITE
  if (db_options_.compaction_service) {
    CompactionServiceJobStatus comp_status =
        ProcessKeyValueCompactionWithCompactionService(sub_compact);
@@ -1049,7 +1043,6 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
    // fallback to local compaction
    assert(comp_status == CompactionServiceJobStatus::kUseLocal);
  }
-#endif  // !ROCKSDB_LITE

  uint64_t prev_cpu_micros = db_options_.clock->CPUMicros();

@@ -1612,7 +1605,6 @@ Status CompactionJob::FinishCompactionOutputFile(
      TableFileCreationReason::kCompaction, status_for_listener, file_checksum,
      file_checksum_func_name);

-#ifndef ROCKSDB_LITE
  // Report new file to SstFileManagerImpl
  auto sfm =
      static_cast<SstFileManagerImpl*>(db_options_.sst_file_manager.get());
@@ -1631,7 +1623,6 @@ Status CompactionJob::FinishCompactionOutputFile(
      db_error_handler_->SetBGError(s, BackgroundErrorReason::kCompaction);
    }
  }
-#endif

  outputs.ResetBuilder();
  return s;
@@ -1756,11 +1747,9 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
  std::string fname = GetTableFileName(file_number);
  // Fire events.
  ColumnFamilyData* cfd = sub_compact->compaction->column_family_data();
-#ifndef ROCKSDB_LITE
  EventHelpers::NotifyTableFileCreationStarted(
      cfd->ioptions()->listeners, dbname_, cfd->GetName(), fname, job_id_,
      TableFileCreationReason::kCompaction);
-#endif  // !ROCKSDB_LITE
  // Make the output file
  std::unique_ptr<FSWritableFile> writable_file;
 #ifndef NDEBUG
@@ -1833,12 +1822,14 @@ Status CompactionJob::OpenCompactionOutputFile(SubcompactionState* sub_compact,
  }

  // Initialize a SubcompactionState::Output and add it to sub_compact->outputs
+  uint64_t epoch_number = sub_compact->compaction->MinInputFileEpochNumber();
  {
    FileMetaData meta;
    meta.fd = FileDescriptor(file_number,
                             sub_compact->compaction->output_path_id(), 0);
    meta.oldest_ancester_time = oldest_ancester_time;
    meta.file_creation_time = current_time;
+    meta.epoch_number = epoch_number;
    meta.temperature = temperature;
    assert(!db_id_.empty());
    assert(!db_session_id_.empty());
@@ -1895,7 +1886,6 @@ void CompactionJob::CleanupCompaction() {
  compact_ = nullptr;
 }

-#ifndef ROCKSDB_LITE
 namespace {
 void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
  assert(prefix_length > 0);
@@ -1904,7 +1894,6 @@ void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
 }
 }  // namespace

-#endif  // !ROCKSDB_LITE

 void CompactionJob::UpdateCompactionStats() {
  assert(compact_);
@@ -1951,7 +1940,6 @@ void CompactionJob::UpdateCompactionInputStatsHelper(int* num_files,

 void CompactionJob::UpdateCompactionJobStats(
    const InternalStats::CompactionStats& stats) const {
-#ifndef ROCKSDB_LITE
  compaction_job_stats_->elapsed_micros = stats.micros;

  // input information
@@ -1978,9 +1966,6 @@ void CompactionJob::UpdateCompactionJobStats(
    CopyPrefix(compact_->LargestUserKey(), CompactionJobStats::kMaxPrefixLength,
               &compaction_job_stats_->largest_output_key_prefix);
  }
-#else
-  (void)stats;
-#endif  // !ROCKSDB_LITE
 }

 void CompactionJob::LogCompaction() {
@@ -261,12 +261,12 @@ class CompactionJob {
  Status OpenCompactionOutputFile(SubcompactionState* sub_compact,
                                  CompactionOutputs& outputs);
  void UpdateCompactionJobStats(
-    const InternalStats::CompactionStats& stats) const;
+      const InternalStats::CompactionStats& stats) const;
  void RecordDroppedKeys(const CompactionIterationStats& c_iter_stats,
                         CompactionJobStats* compaction_job_stats = nullptr);

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

  void NotifyOnSubcompactionBegin(SubcompactionState* sub_compact);

@@ -402,6 +402,7 @@ struct CompactionServiceOutputFile {
  std::string largest_internal_key;
  uint64_t oldest_ancester_time;
  uint64_t file_creation_time;
+  uint64_t epoch_number;
  uint64_t paranoid_hash;
  bool marked_for_compaction;
  UniqueId64x2 unique_id;
@@ -411,8 +412,8 @@ struct CompactionServiceOutputFile {
      const std::string& name, SequenceNumber smallest, SequenceNumber largest,
      std::string _smallest_internal_key, std::string _largest_internal_key,
      uint64_t _oldest_ancester_time, uint64_t _file_creation_time,
-      uint64_t _paranoid_hash, bool _marked_for_compaction,
-      UniqueId64x2 _unique_id)
+      uint64_t _epoch_number, uint64_t _paranoid_hash,
+      bool _marked_for_compaction, UniqueId64x2 _unique_id)
      : file_name(name),
        smallest_seqno(smallest),
        largest_seqno(largest),
@@ -420,6 +421,7 @@ struct CompactionServiceOutputFile {
        largest_internal_key(std::move(_largest_internal_key)),
        oldest_ancester_time(_oldest_ancester_time),
        file_creation_time(_file_creation_time),
+        epoch_number(_epoch_number),
        paranoid_hash(_paranoid_hash),
        marked_for_compaction(_marked_for_compaction),
        unique_id(std::move(_unique_id)) {}
@@ -59,7 +59,6 @@
 #include "utilities/merge_operators.h"

 #if !defined(IOS_CROSS_COMPILE)
-#ifndef ROCKSDB_LITE
 namespace ROCKSDB_NAMESPACE {

 static std::string RandomString(Random* rnd, int len, double ratio) {
@@ -155,9 +154,8 @@ class CompactionJobStatsTest : public testing::Test,
    ASSERT_OK(TryReopenWithColumnFamilies(cfs, options));
  }

-  Status TryReopenWithColumnFamilies(
-      const std::vector<std::string>& cfs,
-      const std::vector<Options>& options) {
+  Status TryReopenWithColumnFamilies(const std::vector<std::string>& cfs,
+                                     const std::vector<Options>& options) {
    Close();
    EXPECT_EQ(cfs.size(), options.size());
    std::vector<ColumnFamilyDescriptor> column_families;
@@ -175,9 +173,7 @@ class CompactionJobStatsTest : public testing::Test,
    return TryReopenWithColumnFamilies(cfs, v_opts);
  }

-  void Reopen(const Options& options) {
-    ASSERT_OK(TryReopen(options));
-  }
+  void Reopen(const Options& options) { ASSERT_OK(TryReopen(options)); }

  void Close() {
    for (auto h : handles_) {
@@ -226,9 +222,7 @@ class CompactionJobStatsTest : public testing::Test,
    return db_->Put(wo, handles_[cf], k, v);
  }

-  Status Delete(const std::string& k) {
-    return db_->Delete(WriteOptions(), k);
-  }
+  Status Delete(const std::string& k) { return db_->Delete(WriteOptions(), k); }

  Status Delete(int cf, const std::string& k) {
    return db_->Delete(WriteOptions(), handles_[cf], k);
@@ -338,21 +332,21 @@ class CompactionJobStatsTest : public testing::Test,
    }
  }

-  static void SetDeletionCompactionStats(
-      CompactionJobStats *stats, uint64_t input_deletions,
-      uint64_t expired_deletions, uint64_t records_replaced) {
+  static void SetDeletionCompactionStats(CompactionJobStats* stats,
+                                         uint64_t input_deletions,
+                                         uint64_t expired_deletions,
+                                         uint64_t records_replaced) {
    stats->num_input_deletion_records = input_deletions;
    stats->num_expired_deletion_records = expired_deletions;
    stats->num_records_replaced = records_replaced;
  }

-  void MakeTableWithKeyValues(
-    Random* rnd, uint64_t smallest, uint64_t largest,
-    int key_size, int value_size, uint64_t interval,
-    double ratio, int cf = 0) {
+  void MakeTableWithKeyValues(Random* rnd, uint64_t smallest, uint64_t largest,
+                              int key_size, int value_size, uint64_t interval,
+                              double ratio, int cf = 0) {
    for (auto key = smallest; key < largest; key += interval) {
      ASSERT_OK(Put(cf, Slice(Key(key, key_size)),
-                        Slice(RandomString(rnd, value_size, ratio))));
+                    Slice(RandomString(rnd, value_size, ratio))));
    }
    ASSERT_OK(Flush(cf));
  }
@@ -361,9 +355,9 @@ class CompactionJobStatsTest : public testing::Test,
  // rounds of keys are inserted into the database, as per the behavior
  // of the DeletionStatsTest.
  void SelectivelyDeleteKeys(uint64_t smallest, uint64_t largest,
-    uint64_t interval, int deletion_interval, int key_size,
-    uint64_t cutoff_key_num, CompactionJobStats* stats, int cf = 0) {
-
+                             uint64_t interval, int deletion_interval,
+                             int key_size, uint64_t cutoff_key_num,
+                             CompactionJobStats* stats, int cf = 0) {
    // interval needs to be >= 2 so that deletion entries can be inserted
    // that are intended to not result in an actual key deletion by using
    // an offset of 1 from another existing key
@@ -387,20 +381,19 @@ class CompactionJobStatsTest : public testing::Test,

    // Insert some deletions for keys that don't exist that
    // are both in and out of the key range
-    ASSERT_OK(Delete(cf, Key(smallest+1, key_size)));
+    ASSERT_OK(Delete(cf, Key(smallest + 1, key_size)));
    deletions_made++;

-    ASSERT_OK(Delete(cf, Key(smallest-1, key_size)));
+    ASSERT_OK(Delete(cf, Key(smallest - 1, key_size)));
    deletions_made++;
    num_expired++;

-    ASSERT_OK(Delete(cf, Key(smallest-9, key_size)));
+    ASSERT_OK(Delete(cf, Key(smallest - 9, key_size)));
    deletions_made++;
    num_expired++;

    ASSERT_OK(Flush(cf));
-    SetDeletionCompactionStats(stats, deletions_made, num_expired,
-      num_deleted);
+    SetDeletionCompactionStats(stats, deletions_made, num_expired, num_deleted);
  }
 };

@@ -440,25 +433,20 @@ class CompactionJobStatsChecker : public EventListener {
  // use ASSERT_GE and ASSERT_LE with a reasonable bias ---
  // 10% in uncompressed case and 20% when compression is used.
  virtual void Verify(const CompactionJobStats& current_stats,
-              const CompactionJobStats& stats) {
+                      const CompactionJobStats& stats) {
    // time
    ASSERT_GT(current_stats.elapsed_micros, 0U);

-    ASSERT_EQ(current_stats.num_input_records,
-        stats.num_input_records);
-    ASSERT_EQ(current_stats.num_input_files,
-        stats.num_input_files);
+    ASSERT_EQ(current_stats.num_input_records, stats.num_input_records);
+    ASSERT_EQ(current_stats.num_input_files, stats.num_input_files);
    ASSERT_EQ(current_stats.num_input_files_at_output_level,
-        stats.num_input_files_at_output_level);
+              stats.num_input_files_at_output_level);

-    ASSERT_EQ(current_stats.num_output_records,
-        stats.num_output_records);
-    ASSERT_EQ(current_stats.num_output_files,
-        stats.num_output_files);
+    ASSERT_EQ(current_stats.num_output_records, stats.num_output_records);
+    ASSERT_EQ(current_stats.num_output_files, stats.num_output_files);

    ASSERT_EQ(current_stats.is_full_compaction, stats.is_full_compaction);
-    ASSERT_EQ(current_stats.is_manual_compaction,
-        stats.is_manual_compaction);
+    ASSERT_EQ(current_stats.is_manual_compaction, stats.is_manual_compaction);

    // file size
    double kFileSizeBias = compression_enabled_ ? 0.20 : 0.10;
@@ -475,18 +463,14 @@ class CompactionJobStatsChecker : public EventListener {
    ASSERT_EQ(current_stats.total_input_raw_value_bytes,
              stats.total_input_raw_value_bytes);

-    ASSERT_EQ(current_stats.num_records_replaced,
-        stats.num_records_replaced);
+    ASSERT_EQ(current_stats.num_records_replaced, stats.num_records_replaced);

-    ASSERT_EQ(current_stats.num_corrupt_keys,
-        stats.num_corrupt_keys);
+    ASSERT_EQ(current_stats.num_corrupt_keys, stats.num_corrupt_keys);

-    ASSERT_EQ(
-        std::string(current_stats.smallest_output_key_prefix),
-        std::string(stats.smallest_output_key_prefix));
-    ASSERT_EQ(
-        std::string(current_stats.largest_output_key_prefix),
-        std::string(stats.largest_output_key_prefix));
+    ASSERT_EQ(std::string(current_stats.smallest_output_key_prefix),
+              std::string(stats.smallest_output_key_prefix));
+    ASSERT_EQ(std::string(current_stats.largest_output_key_prefix),
+              std::string(stats.largest_output_key_prefix));
  }

  // Add an expected compaction stats, which will be used to
@@ -497,9 +481,7 @@ class CompactionJobStatsChecker : public EventListener {
    expected_stats_.push(stats);
  }

-  void EnableCompression(bool flag) {
-    compression_enabled_ = flag;
-  }
+  void EnableCompression(bool flag) { compression_enabled_ = flag; }

  bool verify_next_comp_io_stats() const { return verify_next_comp_io_stats_; }

@@ -517,45 +499,37 @@ class CompactionJobDeletionStatsChecker : public CompactionJobStatsChecker {
  // Verifies whether two CompactionJobStats match.
  void Verify(const CompactionJobStats& current_stats,
              const CompactionJobStats& stats) override {
-    ASSERT_EQ(
-      current_stats.num_input_deletion_records,
-      stats.num_input_deletion_records);
-    ASSERT_EQ(
-        current_stats.num_expired_deletion_records,
-        stats.num_expired_deletion_records);
-    ASSERT_EQ(
-        current_stats.num_records_replaced,
-        stats.num_records_replaced);
+    ASSERT_EQ(current_stats.num_input_deletion_records,
+              stats.num_input_deletion_records);
+    ASSERT_EQ(current_stats.num_expired_deletion_records,
+              stats.num_expired_deletion_records);
+    ASSERT_EQ(current_stats.num_records_replaced, stats.num_records_replaced);

-    ASSERT_EQ(current_stats.num_corrupt_keys,
-        stats.num_corrupt_keys);
+    ASSERT_EQ(current_stats.num_corrupt_keys, stats.num_corrupt_keys);
  }
 };

 namespace {

-uint64_t EstimatedFileSize(
-    uint64_t num_records, size_t key_size, size_t value_size,
-    double compression_ratio = 1.0,
-    size_t block_size = 4096,
-    int bloom_bits_per_key = 10) {
+uint64_t EstimatedFileSize(uint64_t num_records, size_t key_size,
+                           size_t value_size, double compression_ratio = 1.0,
+                           size_t block_size = 4096,
+                           int bloom_bits_per_key = 10) {
  const size_t kPerKeyOverhead = 8;
  const size_t kFooterSize = 512;

-  uint64_t data_size =
-    static_cast<uint64_t>(
-      num_records * (key_size + value_size * compression_ratio +
-                     kPerKeyOverhead));
+  uint64_t data_size = static_cast<uint64_t>(
+      num_records *
+      (key_size + value_size * compression_ratio + kPerKeyOverhead));

-  return data_size + kFooterSize
-         + num_records * bloom_bits_per_key / 8      // filter block
+  return data_size + kFooterSize +
+         num_records * bloom_bits_per_key / 8        // filter block
         + data_size * (key_size + 8) / block_size;  // index block
 }

 namespace {

-void CopyPrefix(
-    const Slice& src, size_t prefix_length, std::string* dst) {
+void CopyPrefix(const Slice& src, size_t prefix_length, std::string* dst) {
  assert(prefix_length > 0);
  size_t length = src.size() > prefix_length ? prefix_length : src.size();
  dst->assign(src.data(), length);
@@ -581,28 +555,24 @@ CompactionJobStats NewManualCompactionJobStats(
  stats.num_output_files = num_output_files;

  stats.total_input_bytes =
-      EstimatedFileSize(
-          num_input_records / num_input_files,
-          key_size, value_size, compression_ratio) * num_input_files;
+      EstimatedFileSize(num_input_records / num_input_files, key_size,
+                        value_size, compression_ratio) *
+      num_input_files;
  stats.total_output_bytes =
-      EstimatedFileSize(
-          num_output_records / num_output_files,
-          key_size, value_size, compression_ratio) * num_output_files;
-  stats.total_input_raw_key_bytes =
-      num_input_records * (key_size + 8);
-  stats.total_input_raw_value_bytes =
-      num_input_records * value_size;
+      EstimatedFileSize(num_output_records / num_output_files, key_size,
+                        value_size, compression_ratio) *
+      num_output_files;
+  stats.total_input_raw_key_bytes = num_input_records * (key_size + 8);
+  stats.total_input_raw_value_bytes = num_input_records * value_size;

  stats.is_full_compaction = is_full;
  stats.is_manual_compaction = is_manual;

  stats.num_records_replaced = num_records_replaced;

-  CopyPrefix(smallest_key,
-             CompactionJobStats::kMaxPrefixLength,
+  CopyPrefix(smallest_key, CompactionJobStats::kMaxPrefixLength,
             &stats.smallest_output_key_prefix);
-  CopyPrefix(largest_key,
-             CompactionJobStats::kMaxPrefixLength,
+  CopyPrefix(largest_key, CompactionJobStats::kMaxPrefixLength,
             &stats.largest_output_key_prefix);

  return stats;
@@ -662,13 +632,11 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {

    // 1st Phase: generate "num_L0_files" L0 files.
    int num_L0_files = 0;
-    for (uint64_t start_key = key_base;
-                  start_key <= key_base * kTestScale;
-                  start_key += key_base) {
-      MakeTableWithKeyValues(
-          &rnd, start_key, start_key + key_base - 1,
-          kKeySize, kValueSize, key_interval,
-          compression_ratio, 1);
+    for (uint64_t start_key = key_base; start_key <= key_base * kTestScale;
+         start_key += key_base) {
+      MakeTableWithKeyValues(&rnd, start_key, start_key + key_base - 1,
+                             kKeySize, kValueSize, key_interval,
+                             compression_ratio, 1);
      snprintf(buf, kBufSize, "%d", ++num_L0_files);
      ASSERT_EQ(std::string(buf), FilesPerLevel(1));
    }
@@ -684,13 +652,9 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
         start_key += key_base, count++) {
      smallest_key = Key(start_key, 10);
      largest_key = Key(start_key + key_base - key_interval, 10);
-      stats_checker->AddExpectedStats(
-          NewManualCompactionJobStats(
-              smallest_key, largest_key,
-              1, 0, num_keys_per_L0_file,
-              kKeySize, kValueSize,
-              1, num_keys_per_L0_file,
-              compression_ratio, 0));
+      stats_checker->AddExpectedStats(NewManualCompactionJobStats(
+          smallest_key, largest_key, 1, 0, num_keys_per_L0_file, kKeySize,
+          kValueSize, 1, num_keys_per_L0_file, compression_ratio, 0));
      ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 1U);
      TEST_Compact(0, 1, smallest_key, largest_key);
      snprintf(buf, kBufSize, "%d,%d", num_L0_files - count, count);
@@ -701,14 +665,10 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
    int num_remaining_L0 = num_L0_files - L0_compaction_count;
    smallest_key = Key(key_base * (L0_compaction_count + 1), 10);
    largest_key = Key(key_base * (kTestScale + 1) - key_interval, 10);
-    stats_checker->AddExpectedStats(
-        NewManualCompactionJobStats(
-            smallest_key, largest_key,
-            num_remaining_L0,
-            0, num_keys_per_L0_file * num_remaining_L0,
-            kKeySize, kValueSize,
-            1, num_keys_per_L0_file * num_remaining_L0,
-            compression_ratio, 0));
+    stats_checker->AddExpectedStats(NewManualCompactionJobStats(
+        smallest_key, largest_key, num_remaining_L0, 0,
+        num_keys_per_L0_file * num_remaining_L0, kKeySize, kValueSize, 1,
+        num_keys_per_L0_file * num_remaining_L0, compression_ratio, 0));
    ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 1U);
    TEST_Compact(0, 1, smallest_key, largest_key);

@@ -719,13 +679,11 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {

    // 3rd Phase: generate sparse L0 files (wider key-range, same num of keys)
    int sparseness = 2;
-    for (uint64_t start_key = key_base;
-                  start_key <= key_base * kTestScale;
-                  start_key += key_base * sparseness) {
+    for (uint64_t start_key = key_base; start_key <= key_base * kTestScale;
+         start_key += key_base * sparseness) {
      MakeTableWithKeyValues(
-          &rnd, start_key, start_key + key_base * sparseness - 1,
-          kKeySize, kValueSize,
-          key_base * sparseness / num_keys_per_L0_file,
+          &rnd, start_key, start_key + key_base * sparseness - 1, kKeySize,
+          kValueSize, key_base * sparseness / num_keys_per_L0_file,
          compression_ratio, 1);
      snprintf(buf, kBufSize, "%d,%d", ++num_L0_files, num_L1_files);
      ASSERT_EQ(std::string(buf), FilesPerLevel(1));
@@ -737,21 +695,15 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
    // output files without coordinating to see if the output could fit into
    // a smaller number of files like it does when it runs sequentially
    int num_output_files = options.max_subcompactions > 1 ? 2 : 1;
-    for (uint64_t start_key = key_base;
-         num_L0_files > 1;
+    for (uint64_t start_key = key_base; num_L0_files > 1;
         start_key += key_base * sparseness) {
      smallest_key = Key(start_key, 10);
-      largest_key =
-          Key(start_key + key_base * sparseness - key_interval, 10);
-      stats_checker->AddExpectedStats(
-          NewManualCompactionJobStats(
-              smallest_key, largest_key,
-              3, 2, num_keys_per_L0_file * 3,
-              kKeySize, kValueSize,
-              num_output_files,
-              num_keys_per_L0_file * 2,  // 1/3 of the data will be updated.
-              compression_ratio,
-              num_keys_per_L0_file));
+      largest_key = Key(start_key + key_base * sparseness - key_interval, 10);
+      stats_checker->AddExpectedStats(NewManualCompactionJobStats(
+          smallest_key, largest_key, 3, 2, num_keys_per_L0_file * 3, kKeySize,
+          kValueSize, num_output_files,
+          num_keys_per_L0_file * 2,  // 1/3 of the data will be updated.
+          compression_ratio, num_keys_per_L0_file));
      ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 1U);
      Compact(1, smallest_key, largest_key);
      if (options.max_subcompactions == 1) {
@@ -766,14 +718,10 @@ TEST_P(CompactionJobStatsTest, CompactionJobStatsTest) {
    // In the first sub-compaction, we expect L0 compaction.
    smallest_key = Key(key_base, 10);
    largest_key = Key(key_base * (kTestScale + 1) - key_interval, 10);
-    stats_checker->AddExpectedStats(
-        NewManualCompactionJobStats(
-            Key(key_base * (kTestScale + 1 - sparseness), 10), largest_key,
-            2, 1, num_keys_per_L0_file * 3,
-            kKeySize, kValueSize,
-            1, num_keys_per_L0_file * 2,
-            compression_ratio,
-            num_keys_per_L0_file));
+    stats_checker->AddExpectedStats(NewManualCompactionJobStats(
+        Key(key_base * (kTestScale + 1 - sparseness), 10), largest_key, 2, 1,
+        num_keys_per_L0_file * 3, kKeySize, kValueSize, 1,
+        num_keys_per_L0_file * 2, compression_ratio, num_keys_per_L0_file));
    ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 1U);
    Compact(1, smallest_key, largest_key);

@@ -869,7 +817,7 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {
  Options options;
  options.listeners.emplace_back(stats_checker);
  options.create_if_missing = true;
-  options.level0_file_num_compaction_trigger = kTestScale+1;
+  options.level0_file_num_compaction_trigger = kTestScale + 1;
  options.num_levels = 3;
  options.compression = kNoCompression;
  options.max_bytes_for_level_multiplier = 2;
@@ -881,13 +829,10 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {
  // Stage 1: Generate several L0 files and then send them to L2 by
  // using CompactRangeOptions and CompactRange(). These files will
  // have a strict subset of the keys from the full key-range
-  for (uint64_t start_key = key_base;
-                start_key <= key_base * kTestScale / 2;
-                start_key += key_base) {
-    MakeTableWithKeyValues(
-        &rnd, start_key, start_key + key_base - 1,
-        kKeySize, kValueSize, key_interval,
-        compression_ratio, 1);
+  for (uint64_t start_key = key_base; start_key <= key_base * kTestScale / 2;
+       start_key += key_base) {
+    MakeTableWithKeyValues(&rnd, start_key, start_key + key_base - 1, kKeySize,
+                           kValueSize, key_interval, compression_ratio, 1);
  }

  CompactRangeOptions cr_options;
@@ -897,13 +842,10 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {
  ASSERT_GT(NumTableFilesAtLevel(2, 1), 0);

  // Stage 2: Generate files including keys from the entire key range
-  for (uint64_t start_key = key_base;
-                start_key <= key_base * kTestScale;
-                start_key += key_base) {
-    MakeTableWithKeyValues(
-        &rnd, start_key, start_key + key_base - 1,
-        kKeySize, kValueSize, key_interval,
-        compression_ratio, 1);
+  for (uint64_t start_key = key_base; start_key <= key_base * kTestScale;
+       start_key += key_base) {
+    MakeTableWithKeyValues(&rnd, start_key, start_key + key_base - 1, kKeySize,
+                           kValueSize, key_interval, compression_ratio, 1);
  }

  // Send these L0 files to L1
@@ -912,16 +854,16 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {

  // Add a new record and flush so now there is a L0 file
  // with a value too (not just deletions from the next step)
-  ASSERT_OK(Put(1, Key(key_base-6, kKeySize), "test"));
+  ASSERT_OK(Put(1, Key(key_base - 6, kKeySize), "test"));
  ASSERT_OK(Flush(1));

  // Stage 3: Generate L0 files with some deletions so now
  // there are files with the same key range in L0, L1, and L2
  int deletion_interval = 3;
  CompactionJobStats first_compaction_stats;
-  SelectivelyDeleteKeys(key_base, largest_key_num,
-      key_interval, deletion_interval, kKeySize, cutoff_key_num,
-      &first_compaction_stats, 1);
+  SelectivelyDeleteKeys(key_base, largest_key_num, key_interval,
+                        deletion_interval, kKeySize, cutoff_key_num,
+                        &first_compaction_stats, 1);

  stats_checker->AddExpectedStats(first_compaction_stats);

@@ -932,8 +874,7 @@ TEST_P(CompactionJobStatsTest, DeletionStatsTest) {
 namespace {
 int GetUniversalCompactionInputUnits(uint32_t num_flushes) {
  uint32_t compaction_input_units;
-  for (compaction_input_units = 1;
-       num_flushes >= compaction_input_units;
+  for (compaction_input_units = 1; num_flushes >= compaction_input_units;
       compaction_input_units *= 2) {
    if ((num_flushes & compaction_input_units) != 0) {
      return compaction_input_units > 1 ? compaction_input_units : 0;
@@ -998,13 +939,10 @@ TEST_P(CompactionJobStatsTest, UniversalCompactionTest) {
  }
  ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 3U);

-  for (uint64_t start_key = key_base;
-                start_key <= key_base * kTestScale;
-                start_key += key_base) {
-    MakeTableWithKeyValues(
-        &rnd, start_key, start_key + key_base - 1,
-        kKeySize, kValueSize, key_interval,
-        compression_ratio, 1);
+  for (uint64_t start_key = key_base; start_key <= key_base * kTestScale;
+       start_key += key_base) {
+    MakeTableWithKeyValues(&rnd, start_key, start_key + key_base - 1, kKeySize,
+                           kValueSize, key_interval, compression_ratio, 1);
    ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_WaitForCompact());
  }
  ASSERT_EQ(stats_checker->NumberOfUnverifiedStats(), 0U);
@@ -1020,15 +958,6 @@ int main(int argc, char** argv) {
  return RUN_ALL_TESTS();
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED, not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE

 #else

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

-#ifndef ROCKSDB_LITE

 #include "db/compaction/compaction_job.h"

@@ -40,7 +39,7 @@ namespace ROCKSDB_NAMESPACE {
 namespace {

 void VerifyInitializationOfCompactionJobStats(
-      const CompactionJobStats& compaction_job_stats) {
+    const CompactionJobStats& compaction_job_stats) {
 #if !defined(IOS_CROSS_COMPILE)
  ASSERT_EQ(compaction_job_stats.elapsed_micros, 0U);

@@ -380,11 +379,14 @@ class CompactionJobTestBase : public testing::Test {
    }

    VersionEdit edit;
-    edit.AddFile(level, file_number, 0, file_size, smallest_key, largest_key,
-                 smallest_seqno, largest_seqno, false, Temperature::kUnknown,
-                 oldest_blob_file_number, kUnknownOldestAncesterTime,
-                 kUnknownFileCreationTime, kUnknownFileChecksum,
-                 kUnknownFileChecksumFuncName, kNullUniqueId64x2);
+    edit.AddFile(
+        level, file_number, 0, file_size, smallest_key, largest_key,
+        smallest_seqno, largest_seqno, false, Temperature::kUnknown,
+        oldest_blob_file_number, kUnknownOldestAncesterTime,
+        kUnknownFileCreationTime,
+        versions_->GetColumnFamilySet()->GetDefault()->NewEpochNumber(),
+        kUnknownFileChecksum, kUnknownFileChecksumFuncName, kNullUniqueId64x2,
+        0);

    mutex_.Lock();
    EXPECT_OK(
@@ -499,8 +501,7 @@ class CompactionJobTestBase : public testing::Test {

        // This is how the key will look like once it's written in bottommost
        // file
-        InternalKey bottommost_internal_key(
-            key, 0, kTypeValue);
+        InternalKey bottommost_internal_key(key, 0, kTypeValue);

        if (corrupt_id(k)) {
          test::CorruptKeyType(&internal_key);
@@ -620,7 +621,7 @@ class CompactionJobTestBase : public testing::Test {
      CompactionInputFiles compaction_level;
      compaction_level.level = input_levels[i];
      compaction_level.files.insert(compaction_level.files.end(),
-          level_files.begin(), level_files.end());
+                                    level_files.begin(), level_files.end());
      compaction_input_files.push_back(compaction_level);
      num_input_files += level_files.size();
    }
@@ -1656,7 +1657,7 @@ TEST_F(CompactionJobTest, ResultSerialization) {
        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
        rnd.RandomBinaryString(rnd.Uniform(kStrMaxLen)),
        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX),
-        rnd64.Uniform(UINT64_MAX), rnd.OneIn(2), id);
+        rnd64.Uniform(UINT64_MAX), rnd64.Uniform(UINT64_MAX), rnd.OneIn(2), id);
  }
  result.output_level = rnd.Uniform(10);
  result.output_path = rnd.RandomString(rnd.Uniform(kStrMaxLen));
@@ -2440,13 +2441,3 @@ int main(int argc, char** argv) {
  return RUN_ALL_TESTS();
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr,
-          "SKIPPED as CompactionJobStats is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE
@@ -76,6 +76,46 @@ IOStatus CompactionOutputs::WriterSyncClose(const Status& input_status,
  return io_s;
 }

+bool CompactionOutputs::UpdateFilesToCutForTTLStates(
+    const Slice& internal_key) {
+  if (!files_to_cut_for_ttl_.empty()) {
+    const InternalKeyComparator* icmp =
+        &compaction_->column_family_data()->internal_comparator();
+    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;
+}
+
 size_t CompactionOutputs::UpdateGrandparentBoundaryInfo(
    const Slice& internal_key) {
  size_t curr_key_boundary_switched_num = 0;
@@ -185,18 +225,30 @@ uint64_t CompactionOutputs::GetCurrentKeyGrandparentOverlappedBytes(

 bool CompactionOutputs::ShouldStopBefore(const CompactionIterator& c_iter) {
  assert(c_iter.Valid());
-
-  // always update grandparent information like overlapped file number, size
-  // etc.
  const Slice& internal_key = c_iter.key();
  const uint64_t previous_overlapped_bytes = grandparent_overlapped_bytes_;
-  size_t num_grandparent_boundaries_crossed =
-      UpdateGrandparentBoundaryInfo(internal_key);
+  const InternalKeyComparator* icmp =
+      &compaction_->column_family_data()->internal_comparator();
+  size_t num_grandparent_boundaries_crossed = 0;
+  bool should_stop_for_ttl = false;
+  // Always update grandparent information like overlapped file number, size
+  // etc., and TTL states.
+  // If compaction_->output_level() == 0, there is no need to update grandparent
+  // info, and that `grandparent` should be empty.
+  if (compaction_->output_level() > 0) {
+    num_grandparent_boundaries_crossed =
+        UpdateGrandparentBoundaryInfo(internal_key);
+    should_stop_for_ttl = UpdateFilesToCutForTTLStates(internal_key);
+  }

  if (!HasBuilder()) {
    return false;
  }

+  if (should_stop_for_ttl) {
+    return true;
+  }
+
  // If there's user defined partitioner, check that first
  if (partitioner_ && partitioner_->ShouldPartition(PartitionerRequest(
                          last_key_for_partitioner_, c_iter.user_key(),
@@ -214,9 +266,6 @@ bool CompactionOutputs::ShouldStopBefore(const CompactionIterator& c_iter) {
    return true;
  }

-  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_) {
@@ -290,41 +339,6 @@ bool CompactionOutputs::ShouldStopBefore(const CompactionIterator& c_iter) {
    }
  }

-  // 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;
 }

@@ -399,6 +413,17 @@ Status CompactionOutputs::AddRangeDels(
  const Slice *lower_bound, *upper_bound;
  bool lower_bound_from_sub_compact = false;

+  // The following example does not happen since
+  // CompactionOutput::ShouldStopBefore() always return false for the first
+  // point key. But we should consider removing this dependency. Suppose for the
+  // first compaction output file,
+  //  - next_table_min_key.user_key == comp_start_user_key
+  //  - no point key is in the output file
+  //  - there is a range tombstone @seqno to be added that covers
+  //  comp_start_user_key
+  // Then meta.smallest will be set to comp_start_user_key@seqno
+  // and meta.largest will be set to comp_start_user_key@kMaxSequenceNumber
+  // which violates the assumption that meta.smallest should be <= meta.largest.
  size_t output_size = outputs_.size();
  if (output_size == 1) {
    // For the first output table, include range tombstones before the min
@@ -459,20 +484,34 @@ Status CompactionOutputs::AddRangeDels(
  } else {
    it->SeekToFirst();
  }
+  Slice last_tombstone_start_user_key{};
  for (; it->Valid(); it->Next()) {
    auto tombstone = it->Tombstone();
    if (upper_bound != nullptr) {
      int cmp =
          ucmp->CompareWithoutTimestamp(*upper_bound, tombstone.start_key_);
-      if ((has_overlapping_endpoints && cmp < 0) ||
-          (!has_overlapping_endpoints && cmp <= 0)) {
-        // Tombstones starting after upper_bound only need to be included in
-        // the next table. If the current SST ends before upper_bound, i.e.,
-        // `has_overlapping_endpoints == false`, we can also skip over range
-        // tombstones that start exactly at upper_bound. Such range
-        // tombstones will be included in the next file and are not relevant
-        // to the point keys or endpoints of the current file.
+      // Tombstones starting after upper_bound only need to be included in
+      // the next table.
+      // If the current SST ends before upper_bound, i.e.,
+      // `has_overlapping_endpoints == false`, we can also skip over range
+      // tombstones that start exactly at upper_bound. Such range
+      // tombstones will be included in the next file and are not relevant
+      // to the point keys or endpoints of the current file.
+      // If the current SST ends at the same user key at upper_bound,
+      // i.e., `has_overlapping_endpoints == true`, AND the tombstone has
+      // the same start key as upper_bound, i.e., cmp == 0, then
+      // the tombstone is relevant only if the tombstone's sequence number
+      // is no larger than this file's largest key's sequence number. This
+      // is because the upper bound to truncate this file's range tombstone
+      // will be meta.largest in this case, and any tombstone that starts after
+      // it will not be relevant.
+      if (cmp < 0) {
        break;
+      } else if (cmp == 0) {
+        if (!has_overlapping_endpoints ||
+            tombstone.seq_ < GetInternalKeySeqno(meta.largest.Encode())) {
+          break;
+        }
      }
    }

@@ -500,30 +539,26 @@ Status CompactionOutputs::AddRangeDels(
           ucmp->CompareWithoutTimestamp(*lower_bound, kv.second) < 0);
    // Range tombstone is not supported by output validator yet.
    builder_->Add(kv.first.Encode(), kv.second);
-    InternalKey smallest_candidate = std::move(kv.first);
+    InternalKey tombstone_start = std::move(kv.first);
+    InternalKey smallest_candidate{tombstone_start};
    if (lower_bound != nullptr &&
        ucmp->CompareWithoutTimestamp(smallest_candidate.user_key(),
                                      *lower_bound) <= 0) {
      // Pretend the smallest key has the same user key as lower_bound
      // (the max key in the previous table or subcompaction) in order for
      // files to appear key-space partitioned.
-      //
-      // When lower_bound is chosen by a subcompaction, we know that
-      // subcompactions over smaller keys cannot contain any keys at
-      // lower_bound. We also know that smaller subcompactions exist,
-      // because otherwise the subcompaction woud be unbounded on the left.
-      // As a result, we know that no other files on the output level will
-      // contain actual keys at lower_bound (an output file may have a
-      // largest key of lower_bound@kMaxSequenceNumber, but this only
-      // indicates a large range tombstone was truncated). Therefore, it is
-      // safe to use the tombstone's sequence number, to ensure that keys at
-      // lower_bound at lower levels are covered by truncated tombstones.
-      //
-      // If lower_bound was chosen by the smallest data key in the file,
-      // choose lowest seqnum so this file's smallest internal key comes
-      // after the previous file's largest. The fake seqnum is OK because
-      // the read path's file-picking code only considers user key.
      if (lower_bound_from_sub_compact) {
+        // When lower_bound is chosen by a subcompaction
+        // (lower_bound_from_sub_compact), we know that subcompactions over
+        // smaller keys cannot contain any keys at lower_bound. We also know
+        // that smaller subcompactions exist, because otherwise the
+        // subcompaction woud be unbounded on the left. As a result, we know
+        // that no other files on the output level will contain actual keys at
+        // lower_bound (an output file may have a largest key of
+        // lower_bound@kMaxSequenceNumber, but this only indicates a large range
+        // tombstone was truncated). Therefore, it is safe to use the
+        // tombstone's sequence number, to ensure that keys at lower_bound at
+        // lower levels are covered by truncated tombstones.
        if (ts_sz) {
          assert(tombstone.ts_.size() == ts_sz);
          smallest_candidate = InternalKey(*lower_bound, tombstone.seq_,
@@ -533,10 +568,15 @@ Status CompactionOutputs::AddRangeDels(
              InternalKey(*lower_bound, tombstone.seq_, kTypeRangeDeletion);
        }
      } else {
+        // If lower_bound was chosen by the smallest data key in the file,
+        // choose lowest seqnum so this file's smallest internal key comes
+        // after the previous file's largest. The fake seqnum is OK because
+        // the read path's file-picking code only considers user key.
        smallest_candidate = InternalKey(*lower_bound, 0, kTypeRangeDeletion);
      }
    }
-    InternalKey largest_candidate = tombstone.SerializeEndKey();
+    InternalKey tombstone_end = tombstone.SerializeEndKey();
+    InternalKey largest_candidate{tombstone_end};
    if (upper_bound != nullptr &&
        ucmp->CompareWithoutTimestamp(*upper_bound,
                                      largest_candidate.user_key()) <= 0) {
@@ -570,21 +610,174 @@ Status CompactionOutputs::AddRangeDels(
            InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion);
      }
    }
-#ifndef NDEBUG
-    SequenceNumber smallest_ikey_seqnum = kMaxSequenceNumber;
-    if (meta.smallest.size() > 0) {
-      smallest_ikey_seqnum = GetInternalKeySeqno(meta.smallest.Encode());
-    }
-#endif
    meta.UpdateBoundariesForRange(smallest_candidate, largest_candidate,
                                  tombstone.seq_, icmp);
-    // The smallest key in a file is used for range tombstone truncation, so
-    // it cannot have a seqnum of 0 (unless the smallest data key in a file
-    // has a seqnum of 0). Otherwise, the truncated tombstone may expose
-    // deleted keys at lower levels.
-    assert(smallest_ikey_seqnum == 0 ||
-           ExtractInternalKeyFooter(meta.smallest.Encode()) !=
-               PackSequenceAndType(0, kTypeRangeDeletion));
+    if (!bottommost_level) {
+      bool start_user_key_changed =
+          last_tombstone_start_user_key.empty() ||
+          ucmp->CompareWithoutTimestamp(last_tombstone_start_user_key,
+                                        it->start_key()) < 0;
+      last_tombstone_start_user_key = it->start_key();
+      // Range tombstones are truncated at file boundaries
+      if (icmp.Compare(tombstone_start, meta.smallest) < 0) {
+        tombstone_start = meta.smallest;
+      }
+      if (icmp.Compare(tombstone_end, meta.largest) > 0) {
+        tombstone_end = meta.largest;
+      }
+      // this assertion validates invariant (2) in the comment below.
+      assert(icmp.Compare(tombstone_start, tombstone_end) <= 0);
+      if (start_user_key_changed) {
+        // if tombstone_start >= tombstone_end, then either no key range is
+        // covered, or that they have the same user key. If they have the same
+        // user key, then the internal key range should only be within this
+        // level, and no keys from older levels is covered.
+        if (ucmp->CompareWithoutTimestamp(tombstone_start.user_key(),
+                                          tombstone_end.user_key()) < 0) {
+          SizeApproximationOptions approx_opts;
+          approx_opts.files_size_error_margin = 0.1;
+          auto approximate_covered_size =
+              compaction_->input_version()->version_set()->ApproximateSize(
+                  approx_opts, compaction_->input_version(),
+                  tombstone_start.Encode(), tombstone_end.Encode(),
+                  compaction_->output_level() + 1 /* start_level */,
+                  -1 /* end_level */, kCompaction);
+          meta.compensated_range_deletion_size += approximate_covered_size;
+        }
+      }
+    }
+    // TODO: show invariants that ensure all necessary range tombstones are
+    // added
+    //  and that file boundaries ensure no coverage is lost.
+    // Each range tombstone with internal key range [tombstone_start,
+    // tombstone_end] is being added to the current compaction output file here.
+    // The range tombstone is going to be truncated at range [meta.smallest,
+    // meta.largest] during reading/scanning. We should maintain invariants
+    // (1) meta.smallest <= meta.largest and,
+    // (2) [tombstone_start, tombstone_end] and [meta.smallest, meta.largest]
+    // overlaps, as there is no point adding range tombstone with a range
+    // outside the file's range.
+    // Since `tombstone_end` is always some user_key@kMaxSeqno, it is okay to
+    // use either open or closed range. Using closed range here to make
+    // reasoning easier, and it is more consistent with an ongoing work that
+    // tries to simplify this method.
+    //
+    // There are two cases:
+    // Case 1. Output file has no point key:
+    //   First we show this case only happens when the entire compaction output
+    //   is range tombstone only. This is true if CompactionIterator does not
+    //   emit any point key. Suppose CompactionIterator emits some point key.
+    //   Based on the assumption that CompactionOutputs::ShouldStopBefore()
+    //   always return false for the first point key, the first compaction
+    //   output file always contains a point key. Each new compaction output
+    //   file is created if there is a point key for which ShouldStopBefore()
+    //   returns true, and the point key would be added to the new compaction
+    //   output file. So each new compaction file always contains a point key.
+    //   So Case 1 only happens when CompactionIterator does not emit any
+    //   point key.
+    //
+    //   To show (1) meta.smallest <= meta.largest:
+    //   Since the compaction output is range tombstone only, `lower_bound` and
+    //   `upper_bound` are either null or comp_start/end_user_key respectively.
+    //   According to how UpdateBoundariesForRange() is implemented, it blindly
+    //   updates meta.smallest and meta.largest to smallest_candidate and
+    //   largest_candidate the first time it is called. Subsequently, it
+    //   compares input parameter with meta.smallest and meta.largest and only
+    //   updates them when input is smaller/larger. So we only need to show
+    //   smallest_candidate <= largest_candidate the first time
+    //   UpdateBoundariesForRange() is called. Here we show something stronger
+    //   that smallest_candidate.user_key < largest_candidate.user_key always
+    //   hold for Case 1.
+    //   We assume comp_start_user_key < comp_end_user_key, if provided. We
+    //   assume that tombstone_start < tombstone_end. This assumption is based
+    //   on that each fragment in FragmentedTombstoneList has
+    //   start_key < end_key (user_key) and that
+    //   FragmentedTombstoneIterator::Tombstone() returns the pair
+    //   (start_key@tombstone_seqno with op_type kTypeRangeDeletion, end_key).
+    //   The logic in this loop sets smallest_candidate to
+    //   max(tombstone_start.user_key, comp_start_user_key)@tombstone.seq_ with
+    //   op_type kTypeRangeDeletion, largest_candidate to
+    //   min(tombstone_end.user_key, comp_end_user_key)@kMaxSequenceNumber with
+    //   op_type kTypeRangeDeletion. When a bound is null, there is no
+    //   truncation on that end. To show that smallest_candidate.user_key <
+    //   largest_candidate.user_key, it suffices to show
+    //   tombstone_start.user_key < comp_end_user_key (if not null) AND
+    //   comp_start_user_key (if not null) < tombstone_end.user_key.
+    //   Since the file has no point key, `has_overlapping_endpoints` is false.
+    //   In the first sanity check of this for-loop, we compare
+    //   tombstone_start.user_key against upper_bound = comp_end_user_key,
+    //   and only proceed if tombstone_start.user_key < comp_end_user_key.
+    //   We assume FragmentedTombstoneIterator::Seek(k) lands
+    //   on a tombstone with end_key > k. So the call it->Seek(*lower_bound)
+    //   above implies compact_start_user_key < tombstone_end.user_key.
+    //
+    //   To show (2) [tombstone_start, tombstone_end] and [meta.smallest,
+    //   meta.largest] overlaps (after the call to UpdateBoundariesForRange()):
+    //   In the proof for (1) we have shown that
+    //   smallest_candidate <= largest_candidate. Since tombstone_start <=
+    //   smallest_candidate <= largest_candidate <= tombstone_end, for (2) to
+    //   hold, it suffices to show that [smallest_candidate, largest_candidate]
+    //   overlaps with [meta.smallest, meta.largest]. too.
+    //   Given meta.smallest <= meta.largest shown above, we need to show
+    //   that it is impossible to have largest_candidate < meta.smallest or
+    //   meta.largest < smallest_candidate. If the above
+    //   meta.UpdateBoundariesForRange(smallest_candidate, largest_candidate)
+    //   updates meta.largest or meta.smallest, then the two ranges overlap.
+    //   So we assume meta.UpdateBoundariesForRange(smallest_candidate,
+    //   largest_candidate) did not update meta.smallest nor meta.largest, which
+    //   means meta.smallest < smallest_candidate and largest_candidate <
+    //   meta.largest.
+    //
+    // Case 2. Output file has >= 1 point key. This means meta.smallest and
+    // meta.largest are not empty when AddRangeDels() is called.
+    //   To show (1) meta.smallest <= meta.largest:
+    //   Assume meta.smallest <= meta.largest when AddRangeDels() is called,
+    //   this follow from how UpdateBoundariesForRange() is implemented where it
+    //   takes min or max to update meta.smallest or meta.largest.
+    //
+    //   To show (2) [tombstone_start, tombstone_end] and [meta.smallest,
+    //   meta.largest] overlaps (after the call to UpdateBoundariesForRange()):
+    //   When smallest_candidate <= largest_candidate, the proof in Case 1
+    //   applies, so we only need to show (2) holds when smallest_candidate >
+    //   largest_candidate. When both bounds are either null or from
+    //   subcompaction boundary, the proof in Case 1 applies, so we only need to
+    //   show (2) holds when at least one bound is from a point key (either
+    //   meta.smallest for lower bound or next_table_min_key for upper bound).
+    //
+    //   Suppose lower bound is meta.smallest.user_key. The call
+    //   it->Seek(*lower_bound) implies tombstone_end.user_key >
+    //   meta.smallest.user_key. We have smallest_candidate.user_key =
+    //   max(tombstone_start.user_key, meta.smallest.user_key). For
+    //   smallest_candidate to be > largest_candidate, we need
+    //   largest_candidate.user_key = upper_bound = smallest_candidate.user_key,
+    //   where tombstone_end is truncated to largest_candidate.
+    //   Subcase 1:
+    //   Suppose largest_candidate.user_key = comp_end_user_key (there is no
+    //   next point key). Subcompaction ensures any point key from this
+    //   subcompaction has a user_key < comp_end_user_key, so 1)
+    //   meta.smallest.user_key < comp_end_user_key, 2)
+    //   `has_overlapping_endpoints` is false, and the first if condition in
+    //   this for-loop ensures tombstone_start.user_key < comp_end_user_key. So
+    //   smallest_candidate.user_key < largest_candidate.user_key. This case
+    //   cannot happen when smallest > largest_candidate.
+    //   Subcase 2:
+    //   Suppose largest_candidate.user_key = next_table_min_key.user_key.
+    //   The first if condition in this for-loop together with
+    //   smallest_candidate.user_key = next_table_min_key.user_key =
+    //   upper_bound implies `has_overlapping_endpoints` is true (so meta
+    //   largest.user_key = upper_bound) and
+    //   tombstone.seq_ < meta.largest.seqno. So
+    //   tombstone_start < meta.largest < tombstone_end.
+    //
+    //   Suppose lower bound is comp_start_user_key and upper_bound is
+    //   next_table_min_key. The call it->Seek(*lower_bound) implies we have
+    //   tombstone_end_key.user_key > comp_start_user_key. So
+    //   tombstone_end_key.user_key > smallest_candidate.user_key. For
+    //   smallest_candidate to be > largest_candidate, we need
+    //   tombstone_start.user_key = largest_candidate.user_key = upper_bound =
+    //   next_table_min_key.user_key. This means `has_overlapping_endpoints` is
+    //   true (so meta.largest.user_key = upper_bound) and tombstone.seq_ <
+    //   meta.largest.seqno. So tombstone_start < meta.largest < tombstone_end.
  }
  return Status::OK();
 }
@@ -221,6 +221,13 @@ class CompactionOutputs {
    }
  }

+  // Updates states related to file cutting for TTL.
+  // Returns a boolean value indicating whether the current
+  // compaction output file should be cut before `internal_key`.
+  //
+  // @param internal_key the current key to be added to output.
+  bool UpdateFilesToCutForTTLStates(const Slice& internal_key);
+
  // update tracked grandparents information like grandparent index, if it's
  // in the gap between 2 grandparent files, accumulated grandparent files size
  // etc.
@@ -31,27 +31,15 @@ bool FindIntraL0Compaction(const std::vector<FileMetaData*>& level_files,
                           size_t min_files_to_compact,
                           uint64_t max_compact_bytes_per_del_file,
                           uint64_t max_compaction_bytes,
-                           CompactionInputFiles* comp_inputs,
-                           SequenceNumber earliest_mem_seqno) {
-  // Do not pick ingested file when there is at least one memtable not flushed
-  // which of seqno is overlap with the sst.
+                           CompactionInputFiles* comp_inputs) {
  TEST_SYNC_POINT("FindIntraL0Compaction");
+
  size_t start = 0;
-  for (; start < level_files.size(); start++) {
-    if (level_files[start]->being_compacted) {
-      return false;
-    }
-    // If there is no data in memtable, the earliest sequence number would the
-    // largest sequence number in last memtable.
-    // Because all files are sorted in descending order by largest_seqno, so we
-    // only need to check the first one.
-    if (level_files[start]->fd.largest_seqno <= earliest_mem_seqno) {
-      break;
-    }
-  }
-  if (start >= level_files.size()) {
+
+  if (level_files.size() == 0 || level_files[start]->being_compacted) {
    return false;
  }
+
  size_t compact_bytes = static_cast<size_t>(level_files[start]->fd.file_size);
  size_t compact_bytes_per_del_file = std::numeric_limits<size_t>::max();
  // Compaction range will be [start, limit).
@@ -889,7 +877,6 @@ Compaction* CompactionPicker::CompactRange(
  return compaction;
 }

-#ifndef ROCKSDB_LITE
 namespace {
 // Test whether two files have overlapping key-ranges.
 bool HaveOverlappingKeyRanges(const Comparator* c, const SstFileMetaData& a,
@@ -995,6 +982,7 @@ Status CompactionPicker::SanitizeCompactionInputFilesForAllLevels(
                               current_files[f].name +
                               " is currently being compacted.");
      }
+
      input_files->insert(TableFileNameToNumber(current_files[f].name));
    }

@@ -1127,7 +1115,6 @@ Status CompactionPicker::SanitizeCompactionInputFiles(

  return Status::OK();
 }
-#endif  // !ROCKSDB_LITE

 void CompactionPicker::RegisterCompaction(Compaction* c) {
  if (c == nullptr) {
@@ -1137,7 +1124,11 @@ void CompactionPicker::RegisterCompaction(Compaction* c) {
         c->output_level() == 0 ||
         !FilesRangeOverlapWithCompaction(*c->inputs(), c->output_level(),
                                          c->GetPenultimateLevel()));
-  if (c->start_level() == 0 ||
+  // CompactionReason::kExternalSstIngestion's start level is just a placeholder
+  // number without actual meaning as file ingestion technically does not have
+  // an input level like other compactions
+  if ((c->start_level() == 0 &&
+       c->compaction_reason() != CompactionReason::kExternalSstIngestion) ||
      ioptions_.compaction_style == kCompactionStyleUniversal) {
    level0_compactions_in_progress_.insert(c);
  }
@@ -51,14 +51,15 @@ class CompactionPicker {
  virtual ~CompactionPicker();

  // Pick level and inputs for a new compaction.
+  //
  // Returns nullptr if there is no compaction to be done.
  // Otherwise returns a pointer to a heap-allocated object that
  // describes the compaction.  Caller should delete the result.
-  virtual Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer,
-      SequenceNumber earliest_memtable_seqno = kMaxSequenceNumber) = 0;
+  virtual Compaction* PickCompaction(const std::string& cf_name,
+                                     const MutableCFOptions& mutable_cf_options,
+                                     const MutableDBOptions& mutable_db_options,
+                                     VersionStorageInfo* vstorage,
+                                     LogBuffer* log_buffer) = 0;

  // Return a compaction object for compacting the range [begin,end] in
  // the specified level.  Returns nullptr if there is nothing in that
@@ -91,11 +92,10 @@ class CompactionPicker {
 // files.  If it's not possible to conver an invalid input_files
 // into a valid one by adding more files, the function will return a
 // non-ok status with specific reason.
-#ifndef ROCKSDB_LITE
+//
  Status SanitizeCompactionInputFiles(std::unordered_set<uint64_t>* input_files,
                                      const ColumnFamilyMetaData& cf_meta,
                                      const int output_level) const;
-#endif  // ROCKSDB_LITE

  // Free up the files that participated in a compaction
  //
@@ -227,11 +227,9 @@ class CompactionPicker {

 // A helper function to SanitizeCompactionInputFiles() that
 // sanitizes "input_files" by adding necessary files.
-#ifndef ROCKSDB_LITE
  virtual Status SanitizeCompactionInputFilesForAllLevels(
      std::unordered_set<uint64_t>* input_files,
      const ColumnFamilyMetaData& cf_meta, const int output_level) const;
-#endif  // ROCKSDB_LITE

  // Keeps track of all compactions that are running on Level0.
  // Protected by DB mutex
@@ -244,7 +242,6 @@ class CompactionPicker {
  const InternalKeyComparator* const icmp_;
 };

-#ifndef ROCKSDB_LITE
 // A dummy compaction that never triggers any automatic
 // compaction.
 class NullCompactionPicker : public CompactionPicker {
@@ -255,12 +252,11 @@ class NullCompactionPicker : public CompactionPicker {
  virtual ~NullCompactionPicker() {}

  // Always return "nullptr"
-  Compaction* PickCompaction(
-      const std::string& /*cf_name*/,
-      const MutableCFOptions& /*mutable_cf_options*/,
-      const MutableDBOptions& /*mutable_db_options*/,
-      VersionStorageInfo* /*vstorage*/, LogBuffer* /* log_buffer */,
-      SequenceNumber /* earliest_memtable_seqno */) override {
+  Compaction* PickCompaction(const std::string& /*cf_name*/,
+                             const MutableCFOptions& /*mutable_cf_options*/,
+                             const MutableDBOptions& /*mutable_db_options*/,
+                             VersionStorageInfo* /*vstorage*/,
+                             LogBuffer* /* log_buffer */) override {
    return nullptr;
  }

@@ -286,7 +282,6 @@ class NullCompactionPicker : public CompactionPicker {
    return false;
  }
 };
-#endif  // !ROCKSDB_LITE

 // Attempts to find an intra L0 compaction conforming to the given parameters.
 //
@@ -304,11 +299,11 @@ class NullCompactionPicker : public CompactionPicker {
 //                                        files. Cannot be nullptr.
 //
 // @return                                true iff compaction was found.
-bool FindIntraL0Compaction(
-    const std::vector<FileMetaData*>& level_files, size_t min_files_to_compact,
-    uint64_t max_compact_bytes_per_del_file, uint64_t max_compaction_bytes,
-    CompactionInputFiles* comp_inputs,
-    SequenceNumber earliest_mem_seqno = kMaxSequenceNumber);
+bool FindIntraL0Compaction(const std::vector<FileMetaData*>& level_files,
+                           size_t min_files_to_compact,
+                           uint64_t max_compact_bytes_per_del_file,
+                           uint64_t max_compaction_bytes,
+                           CompactionInputFiles* comp_inputs);

 CompressionType GetCompressionType(const VersionStorageInfo* vstorage,
                                   const MutableCFOptions& mutable_cf_options,
@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/compaction/compaction_picker_fifo.h"
-#ifndef ROCKSDB_LITE

 #include <cinttypes>
 #include <string>
@@ -232,7 +231,8 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
        break;
      }
    }
-  } else {
+  } else if (total_size >
+             mutable_cf_options.compaction_options_fifo.max_table_files_size) {
    // If the last level is non-L0, we actually don't know which file is
    // logically the oldest since the file creation time only represents
    // when this file was compacted to this level, which is independent
@@ -247,15 +247,27 @@ Compaction* FIFOCompactionPicker::PickSizeCompaction(
      inputs[0].files.push_back(f);
      char tmp_fsize[16];
      AppendHumanBytes(f->fd.GetFileSize(), tmp_fsize, sizeof(tmp_fsize));
-      ROCKS_LOG_BUFFER(log_buffer,
-                       "[%s] FIFO compaction: picking file %" PRIu64
-                       " with size %s for deletion",
-                       cf_name.c_str(), f->fd.GetNumber(), tmp_fsize);
+      ROCKS_LOG_BUFFER(
+          log_buffer,
+          "[%s] FIFO compaction: picking file %" PRIu64
+          " with size %s for deletion under total size %" PRIu64
+          " vs max table files size %" PRIu64,
+          cf_name.c_str(), f->fd.GetNumber(), tmp_fsize, total_size,
+          mutable_cf_options.compaction_options_fifo.max_table_files_size);
+
      if (total_size <=
          mutable_cf_options.compaction_options_fifo.max_table_files_size) {
        break;
      }
    }
+  } else {
+    ROCKS_LOG_BUFFER(
+        log_buffer,
+        "[%s] FIFO compaction: nothing to do. Total size %" PRIu64
+        ", max size %" PRIu64 "\n",
+        cf_name.c_str(), total_size,
+        mutable_cf_options.compaction_options_fifo.max_table_files_size);
+    return nullptr;
  }

  Compaction* c = new Compaction(
@@ -389,7 +401,7 @@ Compaction* FIFOCompactionPicker::PickCompactionToWarm(
 Compaction* FIFOCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, SequenceNumber /*earliest_memtable_seqno*/) {
+    LogBuffer* log_buffer) {
  Compaction* c = nullptr;
  if (mutable_cf_options.ttl > 0) {
    c = PickTTLCompaction(cf_name, mutable_cf_options, mutable_db_options,
@@ -430,4 +442,3 @@ Compaction* FIFOCompactionPicker::CompactRange(
 }

 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE
@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-#ifndef ROCKSDB_LITE

 #include "db/compaction/compaction_picker.h"

@@ -19,11 +18,11 @@ class FIFOCompactionPicker : public CompactionPicker {
                       const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}

-  virtual Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options, VersionStorageInfo* version,
-      LogBuffer* log_buffer,
-      SequenceNumber earliest_memtable_seqno = kMaxSequenceNumber) override;
+  virtual Compaction* PickCompaction(const std::string& cf_name,
+                                     const MutableCFOptions& mutable_cf_options,
+                                     const MutableDBOptions& mutable_db_options,
+                                     VersionStorageInfo* version,
+                                     LogBuffer* log_buffer) override;

  virtual Compaction* CompactRange(
      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
@@ -60,4 +59,3 @@ class FIFOCompactionPicker : public CompactionPicker {
                                   LogBuffer* log_buffer);
 };
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE
@@ -50,7 +50,6 @@ class LevelCompactionBuilder {
 public:
  LevelCompactionBuilder(const std::string& cf_name,
                         VersionStorageInfo* vstorage,
-                         SequenceNumber earliest_mem_seqno,
                         CompactionPicker* compaction_picker,
                         LogBuffer* log_buffer,
                         const MutableCFOptions& mutable_cf_options,
@@ -58,7 +57,6 @@ class LevelCompactionBuilder {
                         const MutableDBOptions& mutable_db_options)
      : cf_name_(cf_name),
        vstorage_(vstorage),
-        earliest_mem_seqno_(earliest_mem_seqno),
        compaction_picker_(compaction_picker),
        log_buffer_(log_buffer),
        mutable_cf_options_(mutable_cf_options),
@@ -122,7 +120,6 @@ class LevelCompactionBuilder {

  const std::string& cf_name_;
  VersionStorageInfo* vstorage_;
-  SequenceNumber earliest_mem_seqno_;
  CompactionPicker* compaction_picker_;
  LogBuffer* log_buffer_;
  int start_level_ = -1;
@@ -196,7 +193,10 @@ void LevelCompactionBuilder::SetupInitialFiles() {
      }
      output_level_ =
          (start_level_ == 0) ? vstorage_->base_level() : start_level_ + 1;
-      if (PickFileToCompact()) {
+      bool picked_file_to_compact = PickFileToCompact();
+      TEST_SYNC_POINT_CALLBACK("PostPickFileToCompact",
+                               &picked_file_to_compact);
+      if (picked_file_to_compact) {
        // found the compaction!
        if (start_level_ == 0) {
          // L0 score = `num L0 files` / `level0_file_num_compaction_trigger`
@@ -447,21 +447,21 @@ bool LevelCompactionBuilder::SetupOtherInputsIfNeeded() {
      compaction_inputs_.push_back(output_level_inputs_);
    }

+    // In some edge cases we could pick a compaction that will be compacting
+    // a key range that overlap with another running compaction, and both
+    // of them have the same output level. This could happen if
+    // (1) we are running a non-exclusive manual compaction
+    // (2) AddFile ingest a new file into the LSM tree
+    // We need to disallow this from happening.
+    if (compaction_picker_->FilesRangeOverlapWithCompaction(
+            compaction_inputs_, output_level_,
+            Compaction::EvaluatePenultimateLevel(
+                vstorage_, ioptions_, start_level_, output_level_))) {
+      // This compaction output could potentially conflict with the output
+      // of a currently running compaction, we cannot run it.
+      return false;
+    }
    if (!is_l0_trivial_move_) {
-      // In some edge cases we could pick a compaction that will be compacting
-      // a key range that overlap with another running compaction, and both
-      // of them have the same output level. This could happen if
-      // (1) we are running a non-exclusive manual compaction
-      // (2) AddFile ingest a new file into the LSM tree
-      // We need to disallow this from happening.
-      if (compaction_picker_->FilesRangeOverlapWithCompaction(
-              compaction_inputs_, output_level_,
-              Compaction::EvaluatePenultimateLevel(
-                  vstorage_, ioptions_, start_level_, output_level_))) {
-        // This compaction output could potentially conflict with the output
-        // of a currently running compaction, we cannot run it.
-        return false;
-      }
      compaction_picker_->GetGrandparents(vstorage_, start_level_inputs_,
                                          output_level_inputs_, &grandparents_);
    }
@@ -825,16 +825,16 @@ bool LevelCompactionBuilder::PickIntraL0Compaction() {
  return FindIntraL0Compaction(level_files, kMinFilesForIntraL0Compaction,
                               std::numeric_limits<uint64_t>::max(),
                               mutable_cf_options_.max_compaction_bytes,
-                               &start_level_inputs_, earliest_mem_seqno_);
+                               &start_level_inputs_);
 }
 }  // namespace

 Compaction* LevelCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, SequenceNumber earliest_mem_seqno) {
-  LevelCompactionBuilder builder(cf_name, vstorage, earliest_mem_seqno, this,
-                                 log_buffer, mutable_cf_options, ioptions_,
+    LogBuffer* log_buffer) {
+  LevelCompactionBuilder builder(cf_name, vstorage, this, log_buffer,
+                                 mutable_cf_options, ioptions_,
                                 mutable_db_options);
  return builder.PickCompaction();
 }
@@ -20,11 +20,11 @@ class LevelCompactionPicker : public CompactionPicker {
  LevelCompactionPicker(const ImmutableOptions& ioptions,
                        const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}
-  virtual Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer,
-      SequenceNumber earliest_memtable_seqno = kMaxSequenceNumber) override;
+  virtual Compaction* PickCompaction(const std::string& cf_name,
+                                     const MutableCFOptions& mutable_cf_options,
+                                     const MutableDBOptions& mutable_db_options,
+                                     VersionStorageInfo* vstorage,
+                                     LogBuffer* log_buffer) override;

  virtual bool NeedsCompaction(
      const VersionStorageInfo* vstorage) const override;
@@ -77,8 +77,9 @@ class CompactionPickerTestBase : public testing::Test {
  void NewVersionStorage(int num_levels, CompactionStyle style) {
    DeleteVersionStorage();
    options_.num_levels = num_levels;
-    vstorage_.reset(new VersionStorageInfo(&icmp_, ucmp_, options_.num_levels,
-                                           style, nullptr, false));
+    vstorage_.reset(new VersionStorageInfo(
+        &icmp_, ucmp_, options_.num_levels, style, nullptr, false,
+        EpochNumberRequirement::kMustPresent));
    vstorage_->PrepareForVersionAppend(ioptions_, mutable_cf_options_);
  }

@@ -87,7 +88,7 @@ class CompactionPickerTestBase : public testing::Test {
  void AddVersionStorage() {
    temp_vstorage_.reset(new VersionStorageInfo(
        &icmp_, ucmp_, options_.num_levels, ioptions_.compaction_style,
-        vstorage_.get(), false));
+        vstorage_.get(), false, EpochNumberRequirement::kMustPresent));
  }

  void DeleteVersionStorage() {
@@ -105,7 +106,8 @@ class CompactionPickerTestBase : public testing::Test {
           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()) {
+           Slice ts_of_smallest = Slice(), Slice ts_of_largest = Slice(),
+           uint64_t epoch_number = kUnknownEpochNumber) {
    assert(ts_of_smallest.size() == ucmp_->timestamp_size());
    assert(ts_of_largest.size() == ucmp_->timestamp_size());

@@ -145,8 +147,8 @@ class CompactionPickerTestBase : public testing::Test {
        file_number, path_id, file_size, smallest_ikey, largest_ikey,
        smallest_seq, largest_seq, marked_for_compact, temperature,
        kInvalidBlobFileNumber, kUnknownOldestAncesterTime,
-        kUnknownFileCreationTime, kUnknownFileChecksum,
-        kUnknownFileChecksumFuncName, kNullUniqueId64x2);
+        kUnknownFileCreationTime, epoch_number, kUnknownFileChecksum,
+        kUnknownFileChecksumFuncName, kNullUniqueId64x2, 0);
    f->compensated_file_size =
        (compensated_file_size != 0) ? compensated_file_size : file_size;
    f->oldest_ancester_time = oldest_ancestor_time;
@@ -480,8 +482,6 @@ TEST_F(CompactionPickerTest, LevelTriggerDynamic4) {
  ASSERT_EQ(num_levels - 1, compaction->output_level());
 }

-// Universal and FIFO Compactions are not supported in ROCKSDB_LITE
-#ifndef ROCKSDB_LITE
 TEST_F(CompactionPickerTest, NeedsCompactionUniversal) {
  NewVersionStorage(1, kCompactionStyleUniversal);
  UniversalCompactionPicker universal_compaction_picker(ioptions_, &icmp_);
@@ -1243,7 +1243,6 @@ TEST_F(CompactionPickerTest, FIFOToWarmWithHotBetweenWarms) {
  ASSERT_EQ(2U, compaction->input(0, 0)->fd.GetNumber());
 }

-#endif  // ROCKSDB_LITE

 TEST_F(CompactionPickerTest, CompactionPriMinOverlapping1) {
  NewVersionStorage(6, kCompactionStyleLevel);
@@ -2871,40 +2870,6 @@ TEST_F(CompactionPickerTest, IntraL0MaxCompactionBytesHit) {
  ASSERT_EQ(0, compaction->output_level());
 }

-TEST_F(CompactionPickerTest, IntraL0ForEarliestSeqno) {
-  // Intra L0 compaction triggers only if there are at least
-  // level0_file_num_compaction_trigger + 2 L0 files.
-  mutable_cf_options_.level0_file_num_compaction_trigger = 3;
-  mutable_cf_options_.max_compaction_bytes = 999999u;
-  NewVersionStorage(6, kCompactionStyleLevel);
-
-  // 4 out of 6 L0 files will be picked for intra L0 compaction due to
-  // being_compact limit. And the latest one L0 will be skipped due to earliest
-  // seqno. The one L1 file spans entire L0 key range and is marked as being
-  // compacted to avoid L0->L1 compaction.
-  Add(1, 1U, "100", "350", 200000U, 0, 110, 111);
-  Add(0, 2U, "301", "350", 1U, 0, 108, 109);
-  Add(0, 3U, "251", "300", 1U, 0, 106, 107);
-  Add(0, 4U, "201", "250", 1U, 0, 104, 105);
-  Add(0, 5U, "151", "200", 1U, 0, 102, 103);
-  Add(0, 6U, "100", "150", 1U, 0, 100, 101);
-  Add(0, 7U, "100", "100", 1U, 0, 99, 100);
-  vstorage_->LevelFiles(0)[5]->being_compacted = true;
-  vstorage_->LevelFiles(1)[0]->being_compacted = true;
-  UpdateVersionStorageInfo();
-
-  std::unique_ptr<Compaction> compaction(level_compaction_picker.PickCompaction(
-      cf_name_, mutable_cf_options_, mutable_db_options_, vstorage_.get(),
-      &log_buffer_, 107));
-  ASSERT_TRUE(compaction.get() != nullptr);
-  ASSERT_EQ(1U, compaction->num_input_levels());
-  ASSERT_EQ(4U, compaction->num_input_files(0));
-  ASSERT_EQ(CompactionReason::kLevelL0FilesNum,
-            compaction->compaction_reason());
-  ASSERT_EQ(0, compaction->output_level());
-}
-
-#ifndef ROCKSDB_LITE
 TEST_F(CompactionPickerTest, UniversalMarkedCompactionFullOverlap) {
  const uint64_t kFileSize = 100000;

@@ -2916,9 +2881,23 @@ TEST_F(CompactionPickerTest, UniversalMarkedCompactionFullOverlap) {
  // should fail
  NewVersionStorage(5, kCompactionStyleUniversal);

-  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550);
-  Add(0, 2U, "201", "250", 2 * kFileSize, 0, 401, 450);
-  Add(0, 4U, "260", "300", 4 * kFileSize, 0, 260, 300);
+  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550, /*compensated_file_size*/ 0,
+      /*marked_for_compact*/ false, /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 3);
+  Add(0, 2U, "201", "250", 2 * kFileSize, 0, 401, 450,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 2);
+  Add(0, 4U, "260", "300", 4 * kFileSize, 0, 260, 300,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 1);
  Add(3, 5U, "010", "080", 8 * kFileSize, 0, 200, 251);
  Add(4, 3U, "301", "350", 8 * kFileSize, 0, 101, 150);
  Add(4, 6U, "501", "750", 8 * kFileSize, 0, 101, 150);
@@ -2940,7 +2919,11 @@ TEST_F(CompactionPickerTest, UniversalMarkedCompactionFullOverlap) {

  AddVersionStorage();
  // Simulate a flush and mark the file for compaction
-  Add(0, 7U, "150", "200", kFileSize, 0, 551, 600, 0, true);
+  Add(0, 7U, "150", "200", kFileSize, 0, 551, 600, 0, true,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 4);
  UpdateVersionStorageInfo();

  std::unique_ptr<Compaction> compaction2(
@@ -2962,7 +2945,11 @@ TEST_F(CompactionPickerTest, UniversalMarkedCompactionFullOverlap2) {
  NewVersionStorage(5, kCompactionStyleUniversal);

  // Mark file number 4 for compaction
-  Add(0, 4U, "260", "300", 4 * kFileSize, 0, 260, 300, 0, true);
+  Add(0, 4U, "260", "300", 4 * kFileSize, 0, 260, 300, 0, true,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 1);
  Add(3, 5U, "240", "290", 8 * kFileSize, 0, 201, 250);
  Add(4, 3U, "301", "350", 8 * kFileSize, 0, 101, 150);
  Add(4, 6U, "501", "750", 8 * kFileSize, 0, 101, 150);
@@ -2983,8 +2970,17 @@ TEST_F(CompactionPickerTest, UniversalMarkedCompactionFullOverlap2) {
  ASSERT_EQ(1U, compaction->num_input_files(1));

  AddVersionStorage();
-  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550);
-  Add(0, 2U, "201", "250", 2 * kFileSize, 0, 401, 450);
+  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550, /*compensated_file_size*/ 0,
+      /*marked_for_compact*/ false, /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 3);
+  Add(0, 2U, "201", "250", 2 * kFileSize, 0, 401, 450,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 2);
  UpdateVersionStorageInfo();

  std::unique_ptr<Compaction> compaction2(
@@ -3150,10 +3146,29 @@ TEST_F(CompactionPickerTest, UniversalMarkedL0Overlap2) {
  NewVersionStorage(1, kCompactionStyleUniversal);

  // Mark file number 5 for compaction
-  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 260, 300);
-  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 201, 250, 0, true);
-  Add(0, 3U, "301", "350", 4 * kFileSize, 0, 101, 150);
-  Add(0, 6U, "501", "750", 8 * kFileSize, 0, 50, 100);
+  Add(0, 4U, "260", "300", 1 * kFileSize, 0, 260, 300,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 4);
+  Add(0, 5U, "240", "290", 2 * kFileSize, 0, 201, 250, 0, true,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 3);
+  Add(0, 3U, "301", "350", 4 * kFileSize, 0, 101, 150,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 2);
+  Add(0, 6U, "501", "750", 8 * kFileSize, 0, 50, 100,
+      /*compensated_file_size*/ 0, /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 1);
  UpdateVersionStorageInfo();

  std::unique_ptr<Compaction> compaction(
@@ -3173,8 +3188,18 @@ TEST_F(CompactionPickerTest, UniversalMarkedL0Overlap2) {
  ASSERT_TRUE(file_map_[6].first->being_compacted);

  AddVersionStorage();
-  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550);
-  Add(0, 2U, "201", "250", kFileSize, 0, 401, 450);
+  Add(0, 1U, "150", "200", kFileSize, 0, 500, 550, /*compensated_file_size*/ 0,
+      /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 6);
+  Add(0, 2U, "201", "250", kFileSize, 0, 401, 450, /*compensated_file_size*/ 0,
+      /*marked_for_compact*/ false,
+      /* temperature*/ Temperature::kUnknown,
+      /*oldest_ancestor_time*/ kUnknownOldestAncesterTime,
+      /*ts_of_smallest*/ Slice(), /*ts_of_largest*/ Slice(),
+      /*epoch_number*/ 5);
  UpdateVersionStorageInfo();

  std::unique_ptr<Compaction> compaction2(
@@ -3953,7 +3978,6 @@ TEST_P(PerKeyPlacementCompactionPickerTest,
 INSTANTIATE_TEST_CASE_P(PerKeyPlacementCompactionPickerTest,
                        PerKeyPlacementCompactionPickerTest, ::testing::Bool());

-#endif  // ROCKSDB_LITE

 }  // namespace ROCKSDB_NAMESPACE

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

 #include "db/compaction/compaction_picker_universal.h"
-#ifndef ROCKSDB_LITE

 #include <cinttypes>
 #include <limits>
@@ -293,7 +292,7 @@ bool UniversalCompactionPicker::NeedsCompaction(
 Compaction* UniversalCompactionPicker::PickCompaction(
    const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
    const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-    LogBuffer* log_buffer, SequenceNumber /* earliest_memtable_seqno */) {
+    LogBuffer* log_buffer) {
  UniversalCompactionBuilder builder(ioptions_, icmp_, cf_name,
                                     mutable_cf_options, mutable_db_options,
                                     vstorage, this, log_buffer);
@@ -308,9 +307,10 @@ void UniversalCompactionBuilder::SortedRun::Dump(char* out_buf,
    if (file->fd.GetPathId() == 0 || !print_path) {
      snprintf(out_buf, out_buf_size, "file %" PRIu64, file->fd.GetNumber());
    } else {
-      snprintf(out_buf, out_buf_size, "file %" PRIu64
-                                      "(path "
-                                      "%" PRIu32 ")",
+      snprintf(out_buf, out_buf_size,
+               "file %" PRIu64
+               "(path "
+               "%" PRIu32 ")",
               file->fd.GetNumber(), file->fd.GetPathId());
    }
  } else {
@@ -399,6 +399,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
  if (!vstorage_->FilesMarkedForPeriodicCompaction().empty()) {
    // Always need to do a full compaction for periodic compaction.
    c = PickPeriodicCompaction();
+    TEST_SYNC_POINT_CALLBACK("PostPickPeriodicCompaction", c);
  }

  // Check for size amplification.
@@ -407,6 +408,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
          static_cast<size_t>(
              mutable_cf_options_.level0_file_num_compaction_trigger)) {
    if ((c = PickCompactionToReduceSizeAmp()) != nullptr) {
+      TEST_SYNC_POINT("PickCompactionToReduceSizeAmpReturnNonnullptr");
      ROCKS_LOG_BUFFER(log_buffer_, "[%s] Universal: compacting for size amp\n",
                       cf_name_.c_str());
    } else {
@@ -416,6 +418,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {
          mutable_cf_options_.compaction_options_universal.size_ratio;

      if ((c = PickCompactionToReduceSortedRuns(ratio, UINT_MAX)) != nullptr) {
+        TEST_SYNC_POINT("PickCompactionToReduceSortedRunsReturnNonnullptr");
        ROCKS_LOG_BUFFER(log_buffer_,
                         "[%s] Universal: compacting for size ratio\n",
                         cf_name_.c_str());
@@ -456,6 +459,7 @@ Compaction* UniversalCompactionBuilder::PickCompaction() {

  if (c == nullptr) {
    if ((c = PickDeleteTriggeredCompaction()) != nullptr) {
+      TEST_SYNC_POINT("PickDeleteTriggeredCompactionReturnNonnullptr");
      ROCKS_LOG_BUFFER(log_buffer_,
                       "[%s] Universal: delete triggered compaction\n",
                       cf_name_.c_str());
@@ -1446,4 +1450,3 @@ uint64_t UniversalCompactionBuilder::GetMaxOverlappingBytes() const {
 }
 }  // namespace ROCKSDB_NAMESPACE

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

 #pragma once
-#ifndef ROCKSDB_LITE

 #include "db/compaction/compaction_picker.h"

@@ -18,15 +17,14 @@ class UniversalCompactionPicker : public CompactionPicker {
  UniversalCompactionPicker(const ImmutableOptions& ioptions,
                            const InternalKeyComparator* icmp)
      : CompactionPicker(ioptions, icmp) {}
-  virtual Compaction* PickCompaction(
-      const std::string& cf_name, const MutableCFOptions& mutable_cf_options,
-      const MutableDBOptions& mutable_db_options, VersionStorageInfo* vstorage,
-      LogBuffer* log_buffer,
-      SequenceNumber earliest_memtable_seqno = kMaxSequenceNumber) override;
+  virtual Compaction* PickCompaction(const std::string& cf_name,
+                                     const MutableCFOptions& mutable_cf_options,
+                                     const MutableDBOptions& mutable_db_options,
+                                     VersionStorageInfo* vstorage,
+                                     LogBuffer* log_buffer) override;
  virtual int MaxOutputLevel() const override { return NumberLevels() - 1; }

  virtual bool NeedsCompaction(
      const VersionStorageInfo* vstorage) const override;
 };
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE
@@ -16,7 +16,6 @@
 #include "options/options_helper.h"
 #include "rocksdb/utilities/options_type.h"

-#ifndef ROCKSDB_LITE
 namespace ROCKSDB_NAMESPACE {
 class SubcompactionState;

@@ -190,6 +189,7 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
    meta.largest.DecodeFrom(file.largest_internal_key);
    meta.oldest_ancester_time = file.oldest_ancester_time;
    meta.file_creation_time = file.file_creation_time;
+    meta.epoch_number = file.epoch_number;
    meta.marked_for_compaction = file.marked_for_compaction;
    meta.unique_id = file.unique_id;

@@ -333,8 +333,9 @@ Status CompactionServiceCompactionJob::Run() {
        MakeTableFileName(meta.fd.GetNumber()), meta.fd.smallest_seqno,
        meta.fd.largest_seqno, meta.smallest.Encode().ToString(),
        meta.largest.Encode().ToString(), meta.oldest_ancester_time,
-        meta.file_creation_time, output_file.validator.GetHash(),
-        meta.marked_for_compaction, meta.unique_id);
+        meta.file_creation_time, meta.epoch_number,
+        output_file.validator.GetHash(), meta.marked_for_compaction,
+        meta.unique_id);
  }
  InternalStats::CompactionStatsFull compaction_stats;
  sub_compact->AggregateCompactionStats(compaction_stats);
@@ -489,6 +490,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {offsetof(struct CompactionServiceOutputFile, file_creation_time),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
          OptionTypeFlags::kNone}},
+        {"epoch_number",
+         {offsetof(struct CompactionServiceOutputFile, epoch_number),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
        {"paranoid_hash",
         {offsetof(struct CompactionServiceOutputFile, paranoid_hash),
          OptionType::kUInt64T, OptionVerificationType::kNormal,
@@ -826,4 +831,3 @@ bool CompactionServiceInput::TEST_Equals(CompactionServiceInput* other,
 #endif  // NDEBUG
 }  // namespace ROCKSDB_NAMESPACE

-#endif  // !ROCKSDB_LITE
@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

-#ifndef ROCKSDB_LITE

 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
@@ -954,13 +953,3 @@ int main(int argc, char** argv) {
  return RUN_ALL_TESTS();
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr,
-          "SKIPPED as CompactionService is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE
@@ -15,11 +15,9 @@
 namespace ROCKSDB_NAMESPACE {
 static std::unordered_map<std::string, OptionTypeInfo>
    sst_fixed_prefix_type_info = {
-#ifndef ROCKSDB_LITE
        {"length",
         {0, OptionType::kSizeT, OptionVerificationType::kNormal,
          OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };

 SstPartitionerFixedPrefixFactory::SstPartitionerFixedPrefixFactory(size_t len)
@@ -58,7 +56,6 @@ std::shared_ptr<SstPartitionerFactory> NewSstPartitionerFixedPrefixFactory(
  return std::make_shared<SstPartitionerFixedPrefixFactory>(prefix_len);
 }

-#ifndef ROCKSDB_LITE
 namespace {
 static int RegisterSstPartitionerFactories(ObjectLibrary& library,
                                           const std::string& /*arg*/) {
@@ -73,17 +70,14 @@ static int RegisterSstPartitionerFactories(ObjectLibrary& library,
  return 1;
 }
 }  // namespace
-#endif  // ROCKSDB_LITE

 Status SstPartitionerFactory::CreateFromString(
    const ConfigOptions& options, const std::string& value,
    std::shared_ptr<SstPartitionerFactory>* result) {
-#ifndef ROCKSDB_LITE
  static std::once_flag once;
  std::call_once(once, [&]() {
    RegisterSstPartitionerFactories(*(ObjectLibrary::Default().get()), "");
  });
-#endif  // ROCKSDB_LITE
  return LoadSharedObject<SstPartitionerFactory>(options, value, nullptr,
                                                 result);
 }
@@ -99,7 +99,6 @@ class SubcompactionState {
    penultimate_level_outputs_.RemoveLastEmptyOutput();
  }

-#ifndef ROCKSDB_LITE
  void BuildSubcompactionJobInfo(
      SubcompactionJobInfo& subcompaction_job_info) const {
    const Compaction* c = compaction;
@@ -113,7 +112,6 @@ class SubcompactionState {
    subcompaction_job_info.output_level = c->output_level();
    subcompaction_job_info.stats = compaction_job_stats;
  }
-#endif  // !ROCKSDB_LITE

  SubcompactionState() = delete;
  SubcompactionState(const SubcompactionState&) = delete;
@@ -196,8 +194,11 @@ class SubcompactionState {
                              const CompactionFileCloseFunc& close_file_func) {
    // Call FinishCompactionOutputFile() even if status is not ok: it needs to
    // close the output file.
+    // CloseOutput() may open new compaction output files.
+    is_current_penultimate_level_ = true;
    Status s = penultimate_level_outputs_.CloseOutput(
        curr_status, open_file_func, close_file_func);
+    is_current_penultimate_level_ = false;
    s = compaction_outputs_.CloseOutput(s, open_file_func, close_file_func);
    return s;
  }
@@ -17,7 +17,6 @@

 namespace ROCKSDB_NAMESPACE {

-#if !defined(ROCKSDB_LITE)

 class TieredCompactionTest : public DBTestBase,
                             public testing::WithParamInterface<bool> {
@@ -663,8 +662,19 @@ TEST_P(TieredCompactionTest, LevelOutofBoundaryRangeDelete) {
  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));

-  ASSERT_EQ(GetSstSizeHelper(Temperature::kUnknown),
-            0);  // tombstone has no size, even it's in hot tier
+  // range tombstone is not in cold tier
+  ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
+  std::vector<std::vector<FileMetaData>> level_to_files;
+  dbfull()->TEST_GetFilesMetaData(dbfull()->DefaultColumnFamily(),
+                                  &level_to_files);
+  // range tombstone is in the penultimate level
+  const int penultimate_level = kNumLevels - 2;
+  ASSERT_EQ(level_to_files[penultimate_level].size(), 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].num_entries, 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].num_deletions, 1);
+  ASSERT_EQ(level_to_files[penultimate_level][0].temperature,
+            Temperature::kUnknown);
+
  ASSERT_GT(GetSstSizeHelper(Temperature::kCold), 0);
  ASSERT_EQ("0,1,10",
            FilesPerLevel());  // one file is at the penultimate level which
@@ -1240,7 +1250,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });

  int sst_num = 0;
@@ -1248,7 +1258,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeManualCompaction) {
  for (; sst_num < kNumTrigger; sst_num++) {
    for (int i = 0; i < kNumKeys; i++) {
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1302,7 +1312,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });

  int sst_num = 0;
@@ -1310,7 +1320,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
  for (; sst_num < kNumTrigger; sst_num++) {
    for (int i = 0; i < kNumKeys; i++) {
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1344,7 +1354,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimeAutoCompaction) {
    for (int i = 0; i < kNumKeys; i++) {
      // the value needs to be big enough to trigger full compaction
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), rnd.RandomString(100)));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1378,7 +1388,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });

  int sst_num = 0;
@@ -1386,7 +1396,7 @@ TEST_F(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
  for (; sst_num < kNumTrigger; sst_num++) {
    for (int i = 0; i < kNumKeys; i++) {
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1452,13 +1462,13 @@ TEST_F(PrecludeLastLevelTest, SmallPrecludeTime) {

  Random rnd(301);

-  dbfull()->TEST_WaitForPeridicTaskRun([&] {
+  dbfull()->TEST_WaitForPeriodicTaskRun([&] {
    mock_clock_->MockSleepForSeconds(static_cast<int>(rnd.Uniform(10) + 1));
  });

  for (int i = 0; i < kNumKeys; i++) {
    ASSERT_OK(Put(Key(i), rnd.RandomString(100)));
-    dbfull()->TEST_WaitForPeridicTaskRun([&] {
+    dbfull()->TEST_WaitForPeriodicTaskRun([&] {
      mock_clock_->MockSleepForSeconds(static_cast<int>(rnd.Uniform(2)));
    });
  }
@@ -1505,7 +1515,7 @@ TEST_F(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });

  int sst_num = 0;
@@ -1513,7 +1523,7 @@ TEST_F(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
  for (; sst_num < kNumTrigger; sst_num++) {
    for (int i = 0; i < kNumKeys; i++) {
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1583,7 +1593,7 @@ TEST_P(PrecludeLastLevelTestWithParms, LastLevelOnlyCompactionNoPreclude) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec)); });

  Random rnd(301);
@@ -1592,7 +1602,7 @@ TEST_P(PrecludeLastLevelTestWithParms, LastLevelOnlyCompactionNoPreclude) {
  for (; sst_num < kNumTrigger; sst_num++) {
    for (int i = 0; i < kNumKeys; i++) {
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), rnd.RandomString(100)));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1685,7 +1695,7 @@ TEST_P(PrecludeLastLevelTestWithParms, LastLevelOnlyCompactionNoPreclude) {
    for (int i = 0; i < kNumKeys; i++) {
      // the value needs to be big enough to trigger full compaction
      ASSERT_OK(Put(Key(sst_num * (kNumKeys - 1) + i), "value"));
-      dbfull()->TEST_WaitForPeridicTaskRun([&] {
+      dbfull()->TEST_WaitForPeriodicTaskRun([&] {
        mock_clock_->MockSleepForSeconds(static_cast<int>(kKeyPerSec));
      });
    }
@@ -1710,6 +1720,133 @@ TEST_P(PrecludeLastLevelTestWithParms, LastLevelOnlyCompactionNoPreclude) {
  Close();
 }

+TEST_P(PrecludeLastLevelTestWithParms, PeriodicCompactionToPenultimateLevel) {
+  // Test the last level only periodic compaction should also be blocked by an
+  // ongoing compaction in penultimate level if tiered compaction is enabled
+  // otherwise, the periodic compaction should just run for the last level.
+  const int kNumTrigger = 4;
+  const int kNumLevels = 7;
+  const int kPenultimateLevel = kNumLevels - 2;
+  const int kKeyPerSec = 1;
+  const int kNumKeys = 100;
+
+  bool enable_preclude_last_level = GetParam();
+
+  Options options = CurrentOptions();
+  options.compaction_style = kCompactionStyleUniversal;
+  options.preserve_internal_time_seconds = 20000;
+  options.env = mock_env_.get();
+  options.level0_file_num_compaction_trigger = kNumTrigger;
+  options.num_levels = kNumLevels;
+  options.ignore_max_compaction_bytes_for_input = false;
+  options.periodic_compaction_seconds = 10000;
+  DestroyAndReopen(options);
+
+  Random rnd(301);
+
+  for (int i = 0; i < 3 * kNumKeys; i++) {
+    ASSERT_OK(Put(Key(i), rnd.RandomString(100)));
+    dbfull()->TEST_WaitForPeriodicTaskRun(
+        [&] { mock_clock_->MockSleepForSeconds(kKeyPerSec); });
+  }
+  ASSERT_OK(Flush());
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
+
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+
+  // make sure all data is compacted to the last level
+  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
+
+  // enable preclude feature
+  if (enable_preclude_last_level) {
+    options.preclude_last_level_data_seconds = 20000;
+  }
+  options.max_background_jobs = 8;
+  options.last_level_temperature = Temperature::kCold;
+  Reopen(options);
+
+  std::atomic_bool is_size_ratio_compaction_running = false;
+  std::atomic_bool verified_last_level_compaction = false;
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "CompactionJob::ProcessKeyValueCompaction()::Processing", [&](void* arg) {
+        auto compaction = static_cast<Compaction*>(arg);
+        if (compaction->output_level() == kPenultimateLevel) {
+          is_size_ratio_compaction_running = true;
+          TEST_SYNC_POINT(
+              "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+              "SizeRatioCompaction1");
+          TEST_SYNC_POINT(
+              "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+              "SizeRatioCompaction2");
+          is_size_ratio_compaction_running = false;
+        }
+      });
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
+        auto compaction = static_cast<Compaction*>(arg);
+
+        if (is_size_ratio_compaction_running) {
+          if (enable_preclude_last_level) {
+            ASSERT_TRUE(compaction == nullptr);
+          } else {
+            ASSERT_TRUE(compaction != nullptr);
+            ASSERT_EQ(compaction->compaction_reason(),
+                      CompactionReason::kPeriodicCompaction);
+            ASSERT_EQ(compaction->start_level(), kNumLevels - 1);
+          }
+          verified_last_level_compaction = true;
+        }
+        TEST_SYNC_POINT(
+            "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+            "AutoCompactionPicked");
+      });
+
+  SyncPoint::GetInstance()->LoadDependency({
+      {"PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+       "SizeRatioCompaction1",
+       "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:DoneWrite"},
+      {"PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+       "AutoCompactionPicked",
+       "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:"
+       "SizeRatioCompaction2"},
+  });
+
+  auto stop_token =
+      dbfull()->TEST_write_controler().GetCompactionPressureToken();
+
+  for (int i = 0; i < kNumTrigger - 1; i++) {
+    for (int j = 0; j < kNumKeys; j++) {
+      ASSERT_OK(Put(Key(i * (kNumKeys - 1) + i), rnd.RandomString(10)));
+      dbfull()->TEST_WaitForPeriodicTaskRun(
+          [&] { mock_clock_->MockSleepForSeconds(kKeyPerSec); });
+    }
+    ASSERT_OK(Flush());
+  }
+
+  TEST_SYNC_POINT(
+      "PrecludeLastLevelTest::PeriodicCompactionToPenultimateLevel:DoneWrite");
+
+  // wait for periodic compaction time and flush to trigger the periodic
+  // compaction, which should be blocked by ongoing compaction in the
+  // penultimate level
+  mock_clock_->MockSleepForSeconds(10000);
+  for (int i = 0; i < 3 * kNumKeys; i++) {
+    ASSERT_OK(Put(Key(i), rnd.RandomString(10)));
+    dbfull()->TEST_WaitForPeriodicTaskRun(
+        [&] { mock_clock_->MockSleepForSeconds(kKeyPerSec); });
+  }
+  ASSERT_OK(Flush());
+
+  ASSERT_OK(dbfull()->WaitForCompact(true));
+
+  stop_token.reset();
+
+  Close();
+}
+
 INSTANTIATE_TEST_CASE_P(PrecludeLastLevelTestWithParms,
                        PrecludeLastLevelTestWithParms, testing::Bool());

@@ -1770,14 +1907,14 @@ TEST_F(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
+  dbfull()->TEST_WaitForPeriodicTaskRun(
      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });

  Random rnd(301);

  for (int i = 0; i < 300; i++) {
    ASSERT_OK(Put(Key(i), rnd.RandomString(100)));
-    dbfull()->TEST_WaitForPeridicTaskRun(
+    dbfull()->TEST_WaitForPeriodicTaskRun(
        [&] { mock_clock_->MockSleepForSeconds(kKeyPerSec); });
  }
  ASSERT_OK(Flush());
@@ -1858,171 +1995,154 @@ TEST_F(PrecludeLastLevelTest, PartialPenultimateLevelCompaction) {
  Close();
 }

-struct TestPropertiesCollector : public TablePropertiesCollector {
-  Status AddUserKey(const Slice& key, const Slice& /*value*/,
-                    EntryType /*type*/, SequenceNumber /*seq*/,
-                    uint64_t /*file_size*/) override {
-    if (cmp->Compare(key, DBTestBase::Key(100)) == 0) {
-      has_key_100 = true;
-    }
-    if (cmp->Compare(key, DBTestBase::Key(200)) == 0) {
-      has_key_200 = true;
-    }
-
-    return Status::OK();
-  }
-
-  const char* Name() const override { return "TestTablePropertiesCollector"; }
-
-  UserCollectedProperties GetReadableProperties() const override {
-    UserCollectedProperties ret;
-    return ret;
-  }
-
-  Status Finish(UserCollectedProperties* /*properties*/) override {
-    // The LSM tree would be like:
-    // L5: [0,19] [20,39] [40,299]
-    // L6: [0,                299]
-    // the 3rd file @L5 has both 100 and 200, which will be marked for
-    // compaction
-    // Also avoid marking flushed SST for compaction, which won't have both 100
-    // and 200
-    if (has_key_100 && has_key_200) {
-      need_compact_ = true;
-    } else {
-      need_compact_ = false;
-    }
-    has_key_100 = false;
-    has_key_200 = false;
-    return Status::OK();
-  }
-
-  bool NeedCompact() const override { return need_compact_; }
-
-  const Comparator* cmp = BytewiseComparator();
-
- private:
-  bool has_key_100 = false;
-  bool has_key_200 = false;
-
-  bool need_compact_ = false;
-};
-
-class TestPropertiesCollectorFactory : public TablePropertiesCollectorFactory {
- public:
-  TablePropertiesCollector* CreateTablePropertiesCollector(
-      TablePropertiesCollectorFactory::Context /*context*/) override {
-    return new TestPropertiesCollector;
-  }
-  const char* Name() const override { return "TestTablePropertiesCollector"; }
-};
-
-TEST_F(PrecludeLastLevelTest, PartialPenultimateLevelCompactionWithRangeDel) {
-  const int kNumTrigger = 4;
+TEST_F(PrecludeLastLevelTest, RangeDelsCauseFileEndpointsToOverlap) {
  const int kNumLevels = 7;
-  const int kKeyPerSec = 10;
+  const int kSecondsPerKey = 10;
+  const int kNumFiles = 3;
+  const int kValueBytes = 4 << 10;
+  const int kFileBytes = 4 * kValueBytes;
+  // `kNumKeysPerFile == 5` is determined by the current file cutting heuristics
+  // for this choice of `kValueBytes` and `kFileBytes`.
+  const int kNumKeysPerFile = 5;
+  const int kNumKeys = kNumFiles * kNumKeysPerFile;

  Options options = CurrentOptions();
  options.compaction_style = kCompactionStyleUniversal;
  options.env = mock_env_.get();
-  options.level0_file_num_compaction_trigger = kNumTrigger;
-  options.preserve_internal_time_seconds = 10000;
+  options.last_level_temperature = Temperature::kCold;
+  options.preserve_internal_time_seconds = 600;
+  options.preclude_last_level_data_seconds = 1;
  options.num_levels = kNumLevels;
-  // set a small max_compaction_bytes to avoid input level expansion
-  options.max_compaction_bytes = 30000;
-  options.ignore_max_compaction_bytes_for_input = false;
+  options.target_file_size_base = kFileBytes;
  DestroyAndReopen(options);

  // pass some time first, otherwise the first a few keys write time are going
  // to be zero, and internally zero has special meaning: kUnknownSeqnoTime
-  dbfull()->TEST_WaitForPeridicTaskRun(
-      [&] { mock_clock_->MockSleepForSeconds(static_cast<int>(10)); });
+  dbfull()->TEST_WaitForPeriodicTaskRun([&] {
+    mock_clock_->MockSleepForSeconds(static_cast<int>(kSecondsPerKey));
+  });

-  Random rnd(301);
-
-  for (int i = 0; i < 300; i++) {
-    ASSERT_OK(Put(Key(i), rnd.RandomString(100)));
-    dbfull()->TEST_WaitForPeridicTaskRun(
-        [&] { mock_clock_->MockSleepForSeconds(kKeyPerSec); });
-  }
-  ASSERT_OK(Flush());
-  CompactRangeOptions cro;
-  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-
-  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
-
-  // make sure all data is compacted to the last level
-  ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
-
-  // Create 3 L5 files
-  auto factory = std::make_shared<ThreeRangesPartitionerFactory>();
-  options.sst_partitioner_factory = factory;
-
-  // the user defined properties_collector will mark the 3rd file for compaction
-  auto collector_factory = std::make_shared<TestPropertiesCollectorFactory>();
-  options.table_properties_collector_factories.resize(1);
-  options.table_properties_collector_factories[0] = collector_factory;
-  // enable tiered storage feature
-  options.preclude_last_level_data_seconds = 10000;
-  options.last_level_temperature = Temperature::kCold;
-  Reopen(options);
-
-  for (int i = 0; i < kNumTrigger - 2; i++) {
-    for (int j = 0; j < 100; j++) {
-      ASSERT_OK(Put(Key(i * 100 + j), rnd.RandomString(10)));
+  // Flush an L0 file with the following contents (new to old):
+  //
+  // Range deletions [4, 6) [7, 8) [9, 11)
+  // --- snap2 ---
+  // Key(0) .. Key(14)
+  // --- snap1 ---
+  // Key(3) .. Key(17)
+  const auto verify_db = [&]() {
+    for (int i = 0; i < kNumKeys; i++) {
+      std::string value;
+      auto s = db_->Get(ReadOptions(), Key(i), &value);
+      if (i == 4 || i == 5 || i == 7 || i == 9 || i == 10) {
+        ASSERT_TRUE(s.IsNotFound());
+      } else {
+        ASSERT_OK(s);
+      }
    }
-    ASSERT_OK(Flush());
+  };
+  Random rnd(301);
+  for (int i = 0; i < kNumKeys; i++) {
+    ASSERT_OK(Put(Key(i + 3), rnd.RandomString(kValueBytes)));
+    dbfull()->TEST_WaitForPeriodicTaskRun(
+        [&] { mock_clock_->MockSleepForSeconds(kSecondsPerKey); });
  }
+  auto* snap1 = db_->GetSnapshot();
+  for (int i = 0; i < kNumKeys; i++) {
+    ASSERT_OK(Put(Key(i), rnd.RandomString(kValueBytes)));
+    dbfull()->TEST_WaitForPeriodicTaskRun(
+        [&] { mock_clock_->MockSleepForSeconds(kSecondsPerKey); });
+  }
+  auto* snap2 = db_->GetSnapshot();
+  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
+                             Key(kNumKeysPerFile - 1),
+                             Key(kNumKeysPerFile + 1)));
+  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
+                             Key(kNumKeysPerFile + 2),
+                             Key(kNumKeysPerFile + 3)));
+  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
+                             Key(2 * kNumKeysPerFile - 1),
+                             Key(2 * kNumKeysPerFile + 1)));
+  ASSERT_OK(Flush());
+  dbfull()->TEST_WaitForPeriodicTaskRun(
+      [&] { mock_clock_->MockSleepForSeconds(kSecondsPerKey); });
+  verify_db();

-  // make sure there is one and only one compaction supports per-key placement
-  // but has the penultimate level output disabled.
+  // Count compactions supporting per-key placement
  std::atomic_int per_key_comp_num = 0;
  SyncPoint::GetInstance()->SetCallBack(
      "UniversalCompactionBuilder::PickCompaction:Return", [&](void* arg) {
        auto compaction = static_cast<Compaction*>(arg);
        if (compaction->SupportsPerKeyPlacement()) {
          ASSERT_EQ(compaction->GetPenultimateOutputRangeType(),
-                    Compaction::PenultimateOutputRangeType::kDisabled);
+                    Compaction::PenultimateOutputRangeType::kNonLastRange);
          per_key_comp_num++;
        }
      });
-
  SyncPoint::GetInstance()->EnableProcessing();

-  for (int j = 0; j < 100; j++) {
-    ASSERT_OK(Put(Key(200 + j), rnd.RandomString(10)));
-  }
-  ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
-                             Key(32), Key(40)));
-  ASSERT_OK(Flush());
-
-  // Before the per-key placement compaction, the LSM tress should be like:
-  // L5: [0,19] [20,40] [40,299]
-  // L6: [0,                299]
-  // The 2nd file @L5 has the largest key 40 because of range del
+  // The `CompactRange()` writes the following files to L5.
+  //
+  //   [key000000#16,kTypeValue,
+  //    key000005#kMaxSequenceNumber,kTypeRangeDeletion]
+  //   [key000005#21,kTypeValue,
+  //    key000010#kMaxSequenceNumber,kTypeRangeDeletion]
+  //   [key000010#26,kTypeValue, key000014#30,kTypeValue]
+  //
+  // And it writes the following files to L6.
+  //
+  //   [key000003#1,kTypeValue, key000007#5,kTypeValue]
+  //   [key000008#6,kTypeValue, key000012#10,kTypeValue]
+  //   [key000013#11,kTypeValue, key000017#15,kTypeValue]
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  ASSERT_EQ("0,0,0,0,0,3,3", FilesPerLevel());
+  verify_db();

+  // Rewrite the middle file only. File endpoints should not change.
+  std::string begin_key_buf = Key(kNumKeysPerFile + 1),
+              end_key_buf = Key(kNumKeysPerFile + 2);
+  Slice begin_key(begin_key_buf), end_key(end_key_buf);
+  ASSERT_OK(db_->SuggestCompactRange(db_->DefaultColumnFamily(), &begin_key,
+                                     &end_key));
  ASSERT_OK(dbfull()->WaitForCompact(true));
+  ASSERT_EQ("0,0,0,0,0,3,3", FilesPerLevel());
+  ASSERT_EQ(1, per_key_comp_num);
+  verify_db();

-  ASSERT_EQ(per_key_comp_num, 1);
+  // Rewrite the middle file again after releasing snap2. Still file endpoints
+  // should not change.
+  db_->ReleaseSnapshot(snap2);
+  ASSERT_OK(db_->SuggestCompactRange(db_->DefaultColumnFamily(), &begin_key,
+                                     &end_key));
+  ASSERT_OK(dbfull()->WaitForCompact(true));
+  ASSERT_EQ("0,0,0,0,0,3,3", FilesPerLevel());
+  ASSERT_EQ(2, per_key_comp_num);
+  verify_db();

-  // the compaction won't move any data to the penultimate level
+  // Middle file once more after releasing snap1. This time the data in the
+  // middle L5 file can all be compacted to the last level.
+  db_->ReleaseSnapshot(snap1);
+  ASSERT_OK(db_->SuggestCompactRange(db_->DefaultColumnFamily(), &begin_key,
+                                     &end_key));
+  ASSERT_OK(dbfull()->WaitForCompact(true));
  ASSERT_EQ("0,0,0,0,0,2,3", FilesPerLevel());
+  ASSERT_EQ(3, per_key_comp_num);
+  verify_db();
+
+  // Finish off the penultimate level.
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));
+  ASSERT_EQ("0,0,0,0,0,0,3", FilesPerLevel());
+  verify_db();

  Close();
 }

-#endif  // !defined(ROCKSDB_LITE)

 }  // namespace ROCKSDB_NAMESPACE

 int main(int argc, char** argv) {
-#if !defined(ROCKSDB_LITE)
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
-#else
-  (void)argc;
-  (void)argv;
-  return 0;
-#endif
 }
@@ -17,7 +17,6 @@
 #include "util/string_util.h"
 #include "utilities/merge_operators.h"

-
 namespace ROCKSDB_NAMESPACE {
 namespace {

@@ -249,7 +248,7 @@ class TwoStrComparator : public Comparator {

  void FindShortSuccessor(std::string* /*key*/) const override {}
 };
-}  // namespace
+}  // anonymous namespace

 class ComparatorDBTest
    : public testing::Test,
@@ -470,7 +469,7 @@ void VerifySuccessor(const Slice& s, const Slice& t) {
  ASSERT_FALSE(rbc->IsSameLengthImmediateSuccessor(t, s));
 }

-}  // namespace
+}  // anonymous namespace

 TEST_P(ComparatorDBTest, IsSameLengthImmediateSuccessor) {
  {
@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //

-#ifndef ROCKSDB_LITE

 #include "rocksdb/convenience.h"

@@ -26,8 +25,7 @@ Status DeleteFilesInRange(DB* db, ColumnFamilyHandle* column_family,
 }

 Status DeleteFilesInRanges(DB* db, ColumnFamilyHandle* column_family,
-                           const RangePtr* ranges, size_t n,
-                           bool include_end) {
+                           const RangePtr* ranges, size_t n, bool include_end) {
  return (static_cast_with_check<DBImpl>(db->GetRootDB()))
      ->DeleteFilesInRanges(column_family, ranges, n, include_end);
 }
@@ -47,9 +45,8 @@ Status VerifySstFileChecksum(const Options& options,
  InternalKeyComparator internal_comparator(options.comparator);
  ImmutableOptions ioptions(options);

-  Status s = ioptions.fs->NewRandomAccessFile(file_path,
-                                              FileOptions(env_options),
-                                              &file, nullptr);
+  Status s = ioptions.fs->NewRandomAccessFile(
+      file_path, FileOptions(env_options), &file, nullptr);
  if (s.ok()) {
    s = ioptions.fs->GetFileSize(file_path, IOOptions(), &file_size, nullptr);
  } else {
@@ -80,4 +77,3 @@ Status VerifySstFileChecksum(const Options& options,

 }  // namespace ROCKSDB_NAMESPACE

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

 #include "rocksdb/options.h"
-#ifndef ROCKSDB_LITE

 #include <fcntl.h>
 #include <sys/stat.h>
@@ -43,33 +42,36 @@ namespace ROCKSDB_NAMESPACE {
 static constexpr int kValueSize = 1000;
 namespace {
 // A wrapper that allows injection of errors.
-class ErrorEnv : public EnvWrapper {
+class ErrorFS : public FileSystemWrapper {
 public:
  bool writable_file_error_;
  int num_writable_file_errors_;

-  explicit ErrorEnv(Env* _target)
-      : EnvWrapper(_target),
+  explicit ErrorFS(const std::shared_ptr<FileSystem>& _target)
+      : FileSystemWrapper(_target),
        writable_file_error_(false),
        num_writable_file_errors_(0) {}
  const char* Name() const override { return "ErrorEnv"; }

-  virtual Status NewWritableFile(const std::string& fname,
-                                 std::unique_ptr<WritableFile>* result,
-                                 const EnvOptions& soptions) override {
+  virtual IOStatus NewWritableFile(const std::string& fname,
+                                   const FileOptions& opts,
+                                   std::unique_ptr<FSWritableFile>* result,
+                                   IODebugContext* dbg) override {
    result->reset();
    if (writable_file_error_) {
      ++num_writable_file_errors_;
-      return Status::IOError(fname, "fake error");
+      return IOStatus::IOError(fname, "fake error");
    }
-    return target()->NewWritableFile(fname, result, soptions);
+    return target()->NewWritableFile(fname, opts, result, dbg);
  }
 };
-}  // namespace
+}  // anonymous namespace
 class CorruptionTest : public testing::Test {
 public:
  std::shared_ptr<Env> env_guard_;
-  ErrorEnv* env_;
+  std::shared_ptr<ErrorFS> fs_;
+  std::unique_ptr<Env> env_;
+  Env* base_env_;
  std::string dbname_;
  std::shared_ptr<Cache> tiny_cache_;
  Options options_;
@@ -80,14 +82,15 @@ class CorruptionTest : public testing::Test {
    // set it to 0), test SequenceNumberRecovery will fail, likely because of a
    // bug in recovery code. Keep it 4 for now to make the test passes.
    tiny_cache_ = NewLRUCache(100, 4);
-    Env* base_env = Env::Default();
+    base_env_ = Env::Default();
    EXPECT_OK(
-        test::CreateEnvFromSystem(ConfigOptions(), &base_env, &env_guard_));
-    EXPECT_NE(base_env, nullptr);
-    env_ = new ErrorEnv(base_env);
+        test::CreateEnvFromSystem(ConfigOptions(), &base_env_, &env_guard_));
+    EXPECT_NE(base_env_, nullptr);
+    fs_.reset(new ErrorFS(base_env_->GetFileSystem()));
+    env_ = NewCompositeEnv(fs_);
    options_.wal_recovery_mode = WALRecoveryMode::kTolerateCorruptedTailRecords;
-    options_.env = env_;
-    dbname_ = test::PerThreadDBPath(env_, "corruption_test");
+    options_.env = env_.get();
+    dbname_ = test::PerThreadDBPath(env_.get(), "corruption_test");
    Status s = DestroyDB(dbname_, options_);
    EXPECT_OK(s);

@@ -110,10 +113,9 @@ class CorruptionTest : public testing::Test {
      fprintf(stdout, "db is still at %s\n", dbname_.c_str());
    } else {
      Options opts;
-      opts.env = env_->target();
+      opts.env = base_env_;
      EXPECT_OK(DestroyDB(dbname_, opts));
    }
-    delete env_;
  }

  void CloseDb() {
@@ -128,7 +130,7 @@ class CorruptionTest : public testing::Test {
    if (opt.env == Options().env) {
      // If env is not overridden, replace it with ErrorEnv.
      // Otherwise, the test already uses a non-default Env.
-      opt.env = env_;
+      opt.env = env_.get();
    }
    opt.arena_block_size = 4096;
    BlockBasedTableOptions table_options;
@@ -138,9 +140,7 @@ class CorruptionTest : public testing::Test {
    return DB::Open(opt, dbname_, &db_);
  }

-  void Reopen(Options* options = nullptr) {
-    ASSERT_OK(TryReopen(options));
-  }
+  void Reopen(Options* options = nullptr) { ASSERT_OK(TryReopen(options)); }

  void RepairDB() {
    delete db_;
@@ -156,7 +156,7 @@ class CorruptionTest : public testing::Test {
        DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
        ASSERT_OK(dbi->TEST_FlushMemTable());
      }
-      //if ((i % 100) == 0) fprintf(stderr, "@ %d of %d\n", i, n);
+      // if ((i % 100) == 0) fprintf(stderr, "@ %d of %d\n", i, n);
      Slice key = Key(i + start, &key_space);
      batch.Clear();
      ASSERT_OK(batch.Put(key, Value(i + start, &value_space)));
@@ -167,6 +167,10 @@ class CorruptionTest : public testing::Test {
  void Build(int n, int flush_every = 0) { Build(n, 0, flush_every); }

  void Check(int min_expected, int max_expected) {
+    Check(min_expected, max_expected, ReadOptions(false, true));
+  }
+
+  void Check(int min_expected, int max_expected, ReadOptions read_options) {
    uint64_t next_expected = 0;
    uint64_t missed = 0;
    int bad_keys = 0;
@@ -178,13 +182,12 @@ class CorruptionTest : public testing::Test {
    // Instead, we want the reads to be successful and this test
    // will detect whether the appropriate corruptions have
    // occurred.
-    Iterator* iter = db_->NewIterator(ReadOptions(false, true));
+    Iterator* iter = db_->NewIterator(read_options);
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(iter->status());
      uint64_t key;
      Slice in(iter->key());
-      if (!ConsumeDecimalNumber(&in, &key) ||
-          !in.empty() ||
+      if (!ConsumeDecimalNumber(&in, &key) || !in.empty() ||
          key < next_expected) {
        bad_keys++;
        continue;
@@ -200,10 +203,11 @@ class CorruptionTest : public testing::Test {
    iter->status().PermitUncheckedError();
    delete iter;

-    fprintf(stderr,
-      "expected=%d..%d; got=%d; bad_keys=%d; bad_values=%d; missed=%llu\n",
-            min_expected, max_expected, correct, bad_keys, bad_values,
-            static_cast<unsigned long long>(missed));
+    fprintf(
+        stderr,
+        "expected=%d..%d; got=%d; bad_keys=%d; bad_values=%d; missed=%llu\n",
+        min_expected, max_expected, correct, bad_keys, bad_values,
+        static_cast<unsigned long long>(missed));
    ASSERT_LE(min_expected, correct);
    ASSERT_GE(max_expected, correct);
  }
@@ -217,8 +221,7 @@ class CorruptionTest : public testing::Test {
    std::string fname;
    int picked_number = -1;
    for (size_t i = 0; i < filenames.size(); i++) {
-      if (ParseFileName(filenames[i], &number, &type) &&
-          type == filetype &&
+      if (ParseFileName(filenames[i], &number, &type) && type == filetype &&
          static_cast<int>(number) > picked_number) {  // Pick latest file
        fname = dbname_ + "/" + filenames[i];
        picked_number = static_cast<int>(number);
@@ -226,7 +229,8 @@ class CorruptionTest : public testing::Test {
    }
    ASSERT_TRUE(!fname.empty()) << filetype;

-    ASSERT_OK(test::CorruptFile(env_, fname, offset, bytes_to_corrupt));
+    ASSERT_OK(test::CorruptFile(env_.get(), fname, offset, bytes_to_corrupt,
+                                /*verify_checksum*/ filetype == kTableFile));
  }

  // corrupts exactly one file at level `level`. if no file found at level,
@@ -236,7 +240,7 @@ class CorruptionTest : public testing::Test {
    db_->GetLiveFilesMetaData(&metadata);
    for (const auto& m : metadata) {
      if (m.level == level) {
-        ASSERT_OK(test::CorruptFile(env_, dbname_ + "/" + m.name, offset,
+        ASSERT_OK(test::CorruptFile(env_.get(), dbname_ + "/" + m.name, offset,
                                    bytes_to_corrupt));
        return;
      }
@@ -244,7 +248,6 @@ class CorruptionTest : public testing::Test {
    FAIL() << "no file found at level";
  }

-
  int Property(const std::string& name) {
    std::string property;
    int result;
@@ -311,7 +314,7 @@ class CorruptionTest : public testing::Test {
    if (bytes_to_truncate == 0) {
      new_size = 0;
    }
-    ASSERT_OK(test::TruncateFile(env_, path, new_size));
+    ASSERT_OK(test::TruncateFile(env_.get(), path, new_size));
  }
 };

@@ -405,14 +408,14 @@ TEST_F(CorruptionTest, PostPITRCorruptionWALsRetained) {
 }

 TEST_F(CorruptionTest, RecoverWriteError) {
-  env_->writable_file_error_ = true;
+  fs_->writable_file_error_ = true;
  Status s = TryReopen();
  ASSERT_TRUE(!s.ok());
 }

 TEST_F(CorruptionTest, NewFileErrorDuringWrite) {
  // Do enough writing to force minor compaction
-  env_->writable_file_error_ = true;
+  fs_->writable_file_error_ = true;
  const int num =
      static_cast<int>(3 + (Options().write_buffer_size / kValueSize));
  std::string value_storage;
@@ -428,8 +431,8 @@ TEST_F(CorruptionTest, NewFileErrorDuringWrite) {
    ASSERT_TRUE(!failed || !s.ok());
  }
  ASSERT_TRUE(!s.ok());
-  ASSERT_GE(env_->num_writable_file_errors_, 1);
-  env_->writable_file_error_ = false;
+  ASSERT_GE(fs_->num_writable_file_errors_, 1);
+  fs_->writable_file_error_ = false;
  Reopen();
 }

@@ -447,7 +450,7 @@ TEST_F(CorruptionTest, TableFile) {

 TEST_F(CorruptionTest, VerifyChecksumReadahead) {
  Options options;
-  SpecialEnv senv(env_->target());
+  SpecialEnv senv(base_env_);
  options.env = &senv;
  // Disable block cache as we are going to check checksum for
  // the same file twice and measure number of reads.
@@ -515,13 +518,97 @@ TEST_F(CorruptionTest, TableFileIndexData) {
  dbi = static_cast_with_check<DBImpl>(db_);
  // one full file may be readable, since only one was corrupted
  // the other file should be fully non-readable, since index was corrupted
-  Check(0, 5000);
+  Check(0, 5000, ReadOptions(true, true));
  ASSERT_NOK(dbi->VerifyChecksum());

  // In paranoid mode, the db cannot be opened due to the corrupted file.
  ASSERT_TRUE(TryReopen().IsCorruption());
 }

+TEST_F(CorruptionTest, TableFileFooterMagic) {
+  Build(100);
+  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  ASSERT_OK(dbi->TEST_FlushMemTable());
+  Check(100, 100);
+  // Corrupt the whole footer
+  Corrupt(kTableFile, -100, 100);
+  Status s = TryReopen();
+  ASSERT_TRUE(s.IsCorruption());
+  // Contains useful message, and magic number should be the first thing
+  // reported as corrupt.
+  ASSERT_TRUE(s.ToString().find("magic number") != std::string::npos);
+  // with file name
+  ASSERT_TRUE(s.ToString().find(".sst") != std::string::npos);
+}
+
+TEST_F(CorruptionTest, TableFileFooterNotMagic) {
+  Build(100);
+  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  ASSERT_OK(dbi->TEST_FlushMemTable());
+  Check(100, 100);
+  // Corrupt footer except magic number
+  Corrupt(kTableFile, -100, 92);
+  Status s = TryReopen();
+  ASSERT_TRUE(s.IsCorruption());
+  // The next thing checked after magic number is format_version
+  ASSERT_TRUE(s.ToString().find("format_version") != std::string::npos);
+  // with file name
+  ASSERT_TRUE(s.ToString().find(".sst") != std::string::npos);
+}
+
+TEST_F(CorruptionTest, TableFileWrongSize) {
+  Build(100);
+  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  ASSERT_OK(dbi->TEST_FlushMemTable());
+  Check(100, 100);
+
+  // ********************************************
+  // Make the file bigger by appending to it
+  std::vector<LiveFileMetaData> metadata;
+  db_->GetLiveFilesMetaData(&metadata);
+  ASSERT_EQ(1U, metadata.size());
+  std::string filename = dbname_ + metadata[0].name;
+  const auto& fs = options_.env->GetFileSystem();
+  {
+    std::unique_ptr<FSWritableFile> f;
+    ASSERT_OK(fs->ReopenWritableFile(filename, FileOptions(), &f, nullptr));
+    ASSERT_OK(f->Append("blahblah", IOOptions(), nullptr));
+    ASSERT_OK(f->Close(IOOptions(), nullptr));
+  }
+
+  // DB actually accepts this without paranoid checks, relying on size
+  // recorded in manifest to locate the SST footer.
+  options_.paranoid_checks = false;
+  options_.skip_checking_sst_file_sizes_on_db_open = false;
+  Reopen();
+  Check(100, 100);
+
+  // But reports the issue with paranoid checks
+  options_.paranoid_checks = true;
+  Status s = TryReopen();
+  ASSERT_TRUE(s.IsCorruption());
+  ASSERT_TRUE(s.ToString().find("file size mismatch") != std::string::npos);
+
+  // ********************************************
+  // Make the file smaller with truncation.
+  // First leaving a partial footer, and then completely removing footer.
+  for (size_t bytes_lost : {8, 100}) {
+    ASSERT_OK(test::TruncateFile(env_.get(), filename,
+                                 metadata[0].size - bytes_lost));
+
+    // Reported well with paranoid checks
+    options_.paranoid_checks = true;
+    s = TryReopen();
+    ASSERT_TRUE(s.IsCorruption());
+    ASSERT_TRUE(s.ToString().find("file size mismatch") != std::string::npos);
+
+    // Without paranoid checks, not reported until read
+    options_.paranoid_checks = false;
+    Reopen();
+    Check(0, 0);  // Missing data
+  }
+}
+
 TEST_F(CorruptionTest, MissingDescriptor) {
  Build(1000);
  RepairDB();
@@ -572,7 +659,7 @@ TEST_F(CorruptionTest, CorruptedDescriptor) {

 TEST_F(CorruptionTest, CompactionInputError) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  Reopen(&options);
  Build(10);
  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
@@ -593,7 +680,7 @@ TEST_F(CorruptionTest, CompactionInputError) {

 TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.paranoid_checks = true;
  options.write_buffer_size = 131072;
  options.max_write_buffer_number = 2;
@@ -680,7 +767,7 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) {
      ImmutableOptions(options_), kRangeDelBlockName, &range_del_handle));

  ASSERT_OK(TryReopen());
-  ASSERT_OK(test::CorruptFile(env_, filename,
+  ASSERT_OK(test::CorruptFile(env_.get(), filename,
                              static_cast<int>(range_del_handle.offset()), 1));
  ASSERT_TRUE(TryReopen().IsCorruption());
 }
@@ -688,7 +775,7 @@ TEST_F(CorruptionTest, RangeDeletionCorrupted) {
 TEST_F(CorruptionTest, FileSystemStateCorrupted) {
  for (int iter = 0; iter < 2; ++iter) {
    Options options;
-    options.env = env_;
+    options.env = env_.get();
    options.paranoid_checks = true;
    options.create_if_missing = true;
    Reopen(&options);
@@ -727,7 +814,7 @@ static const auto& corruption_modes = {

 TEST_F(CorruptionTest, ParanoidFileChecksOnFlush) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.check_flush_compaction_key_order = false;
  options.paranoid_file_checks = true;
  options.create_if_missing = true;
@@ -755,7 +842,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnFlush) {

 TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.paranoid_file_checks = true;
  options.create_if_missing = true;
  options.check_flush_compaction_key_order = false;
@@ -788,7 +875,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {

 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.check_flush_compaction_key_order = false;
  options.paranoid_file_checks = true;
  options.create_if_missing = true;
@@ -824,7 +911,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {

 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.check_flush_compaction_key_order = false;
  options.paranoid_file_checks = true;
  options.create_if_missing = true;
@@ -863,7 +950,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {

 TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.check_flush_compaction_key_order = false;
  options.paranoid_file_checks = true;
  options.create_if_missing = true;
@@ -899,7 +986,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {

 TEST_F(CorruptionTest, LogCorruptionErrorsInCompactionIterator) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.create_if_missing = true;
  options.allow_data_in_errors = true;
  auto mode = mock::MockTableFactory::kCorruptKey;
@@ -928,7 +1015,7 @@ TEST_F(CorruptionTest, LogCorruptionErrorsInCompactionIterator) {

 TEST_F(CorruptionTest, CompactionKeyOrderCheck) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.paranoid_file_checks = false;
  options.create_if_missing = true;
  options.check_flush_compaction_key_order = false;
@@ -955,7 +1042,7 @@ TEST_F(CorruptionTest, CompactionKeyOrderCheck) {

 TEST_F(CorruptionTest, FlushKeyOrderCheck) {
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  options.paranoid_file_checks = false;
  options.create_if_missing = true;
  ASSERT_OK(db_->SetOptions({{"check_flush_compaction_key_order", "true"}}));
@@ -1008,7 +1095,7 @@ TEST_F(CorruptionTest, DisableKeyOrderCheck) {
 TEST_F(CorruptionTest, VerifyWholeTableChecksum) {
  CloseDb();
  Options options;
-  options.env = env_;
+  options.env = env_.get();
  ASSERT_OK(DestroyDB(dbname_, options));
  options.create_if_missing = true;
  options.file_checksum_gen_factory =
@@ -1097,7 +1184,7 @@ TEST_P(CrashDuringRecoveryWithCorruptionTest, CrashDuringRecovery) {
      track_and_verify_wals_in_manifest_;
  options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
  options.avoid_flush_during_recovery = false;
-  options.env = env_;
+  options.env = env_.get();
  ASSERT_OK(DestroyDB(dbname_, options));
  options.create_if_missing = true;
  options.max_write_buffer_number = 8;
@@ -1269,7 +1356,7 @@ TEST_P(CrashDuringRecoveryWithCorruptionTest, TxnDbCrashDuringRecovery) {
  options.track_and_verify_wals_in_manifest =
      track_and_verify_wals_in_manifest_;
  options.avoid_flush_during_recovery = false;
-  options.env = env_;
+  options.env = env_.get();
  ASSERT_OK(DestroyDB(dbname_, options));
  options.create_if_missing = true;
  options.max_write_buffer_number = 3;
@@ -1464,7 +1551,7 @@ TEST_P(CrashDuringRecoveryWithCorruptionTest, CrashDuringRecoveryWithFlush) {
  Options options;
  options.wal_recovery_mode = WALRecoveryMode::kPointInTimeRecovery;
  options.avoid_flush_during_recovery = false;
-  options.env = env_;
+  options.env = env_.get();
  options.create_if_missing = true;

  ASSERT_OK(DestroyDB(dbname_, options));
@@ -1580,12 +1667,3 @@ int main(int argc, char** argv) {
  return RUN_ALL_TESTS();
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as RepairDB() is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE
@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).

-#ifndef ROCKSDB_LITE

 #include "db/db_impl/db_impl.h"
 #include "db/db_test_util.h"
@@ -77,9 +76,7 @@ class CuckooTableDBTest : public testing::Test {
    return db_->Put(WriteOptions(), k, v);
  }

-  Status Delete(const std::string& k) {
-    return db_->Delete(WriteOptions(), k);
-  }
+  Status Delete(const std::string& k) { return db_->Delete(WriteOptions(), k); }

  std::string Get(const std::string& k) {
    ReadOptions options;
@@ -313,23 +310,21 @@ TEST_F(CuckooTableDBTest, AdaptiveTable) {
  // Write some keys using plain table.
  std::shared_ptr<TableFactory> block_based_factory(
      NewBlockBasedTableFactory());
-  std::shared_ptr<TableFactory> plain_table_factory(
-      NewPlainTableFactory());
-  std::shared_ptr<TableFactory> cuckoo_table_factory(
-      NewCuckooTableFactory());
+  std::shared_ptr<TableFactory> plain_table_factory(NewPlainTableFactory());
+  std::shared_ptr<TableFactory> cuckoo_table_factory(NewCuckooTableFactory());
  options.create_if_missing = false;
-  options.table_factory.reset(NewAdaptiveTableFactory(
-    plain_table_factory, block_based_factory, plain_table_factory,
-    cuckoo_table_factory));
+  options.table_factory.reset(
+      NewAdaptiveTableFactory(plain_table_factory, block_based_factory,
+                              plain_table_factory, cuckoo_table_factory));
  Reopen(&options);
  ASSERT_OK(Put("key4", "v4"));
  ASSERT_OK(Put("key1", "v5"));
  ASSERT_OK(dbfull()->TEST_FlushMemTable());

  // Write some keys using block based table.
-  options.table_factory.reset(NewAdaptiveTableFactory(
-    block_based_factory, block_based_factory, plain_table_factory,
-    cuckoo_table_factory));
+  options.table_factory.reset(
+      NewAdaptiveTableFactory(block_based_factory, block_based_factory,
+                              plain_table_factory, cuckoo_table_factory));
  Reopen(&options);
  ASSERT_OK(Put("key5", "v6"));
  ASSERT_OK(Put("key2", "v7"));
@@ -354,12 +349,3 @@ int main(int argc, char** argv) {
  }
 }

-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as Cuckoo table is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE
@@ -20,9 +20,7 @@
 #include "rocksdb/utilities/debug.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/block_builder.h"
-#if !defined(ROCKSDB_LITE)
 #include "test_util/sync_point.h"
-#endif
 #include "util/file_checksum_helper.h"
 #include "util/random.h"
 #include "utilities/counted_fs.h"
@@ -95,7 +93,6 @@ TEST_F(DBBasicTest, UniqueSession) {
  EXPECT_MATCHES_REGEX(sid2, expected);
  EXPECT_MATCHES_REGEX(sid3, expected);

-#ifndef ROCKSDB_LITE
  Close();
  ASSERT_OK(ReadOnlyReopen(options));
  ASSERT_OK(db_->GetDbSessionId(sid1));
@@ -110,7 +107,6 @@ TEST_F(DBBasicTest, UniqueSession) {
  ASSERT_NE(sid1, sid2);

  ASSERT_EQ(sid2, sid3);
-#endif  // ROCKSDB_LITE

  CreateAndReopenWithCF({"goku"}, options);
  ASSERT_OK(db_->GetDbSessionId(sid1));
@@ -127,7 +123,6 @@ TEST_F(DBBasicTest, UniqueSession) {
  ASSERT_NE(sid1, sid4);
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBasicTest, ReadOnlyDB) {
  ASSERT_OK(Put("foo", "v1"));
  ASSERT_OK(Put("bar", "v2"));
@@ -364,7 +359,6 @@ TEST_F(DBBasicTest, LevelLimitReopen) {
  options.max_bytes_for_level_multiplier_additional.resize(10, 1);
  ASSERT_OK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
 }
-#endif  // ROCKSDB_LITE

 TEST_F(DBBasicTest, PutDeleteGet) {
  do {
@@ -426,7 +420,6 @@ TEST_F(DBBasicTest, GetFromVersions) {
  } while (ChangeOptions());
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBasicTest, GetSnapshot) {
  anon::OptionsOverride options_override;
  options_override.skip_policy = kSkipNoSnapshot;
@@ -447,7 +440,6 @@ TEST_F(DBBasicTest, GetSnapshot) {
    }
  } while (ChangeOptions());
 }
-#endif  // ROCKSDB_LITE

 TEST_F(DBBasicTest, CheckLock) {
  do {
@@ -679,7 +671,27 @@ TEST_F(DBBasicTest, IdentityAcrossRestarts) {
  } while (ChangeCompactOptions());
 }

-#ifndef ROCKSDB_LITE
+TEST_F(DBBasicTest, LockFileRecovery) {
+  Options options = CurrentOptions();
+  // Regardless of best_efforts_recovery
+  for (bool ber : {false, true}) {
+    options.best_efforts_recovery = ber;
+    DestroyAndReopen(options);
+    std::string id1, id2;
+    ASSERT_OK(db_->GetDbIdentity(id1));
+    Close();
+
+    // Should be OK to re-open DB after lock file deleted
+    std::string lockfilename = LockFileName(dbname_);
+    ASSERT_OK(env_->DeleteFile(lockfilename));
+    Reopen(options);
+
+    // Should be same DB as before
+    ASSERT_OK(db_->GetDbIdentity(id2));
+    ASSERT_EQ(id1, id2);
+  }
+}
+
 TEST_F(DBBasicTest, Snapshot) {
  env_->SetMockSleep();
  anon::OptionsOverride options_override;
@@ -751,7 +763,6 @@ TEST_F(DBBasicTest, Snapshot) {
  } while (ChangeOptions());
 }

-#endif  // ROCKSDB_LITE

 class DBBasicMultiConfigs : public DBBasicTest,
                            public ::testing::WithParamInterface<int> {
@@ -2158,11 +2169,11 @@ class DBMultiGetAsyncIOTest : public DBBasicTest,
      : DBBasicTest(), statistics_(ROCKSDB_NAMESPACE::CreateDBStatistics()) {
    BlockBasedTableOptions bbto;
    bbto.filter_policy.reset(NewBloomFilterPolicy(10));
-    Options options = CurrentOptions();
-    options.disable_auto_compactions = true;
-    options.statistics = statistics_;
-    options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-    Reopen(options);
+    options_ = CurrentOptions();
+    options_.disable_auto_compactions = true;
+    options_.statistics = statistics_;
+    options_.table_factory.reset(NewBlockBasedTableFactory(bbto));
+    Reopen(options_);
    int num_keys = 0;

    // Put all keys in the bottommost level, and overwrite some keys
@@ -2227,8 +2238,12 @@ class DBMultiGetAsyncIOTest : public DBBasicTest,

  const std::shared_ptr<Statistics>& statistics() { return statistics_; }

+ protected:
+  void ReopenDB() { Reopen(options_); }
+
 private:
  std::shared_ptr<Statistics> statistics_;
+  Options options_;
 };

 TEST_P(DBMultiGetAsyncIOTest, GetFromL0) {
@@ -2305,6 +2320,69 @@ TEST_P(DBMultiGetAsyncIOTest, GetFromL1) {
  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 3);
 }

+TEST_P(DBMultiGetAsyncIOTest, GetFromL1Error) {
+  std::vector<std::string> key_strs;
+  std::vector<Slice> keys;
+  std::vector<PinnableSlice> values;
+  std::vector<Status> statuses;
+
+  key_strs.push_back(Key(33));
+  key_strs.push_back(Key(54));
+  key_strs.push_back(Key(102));
+  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());
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "TableCache::GetTableReader:BeforeOpenFile", [&](void* status) {
+        static int count = 0;
+        count++;
+        // Fail the last table reader open, which is the 6th SST file
+        // since 3 overlapping L0 files + 3 L1 files containing the keys
+        if (count == 6) {
+          Status* s = static_cast<Status*>(status);
+          *s = Status::IOError();
+        }
+      });
+  // DB open will create table readers unless we reduce the table cache
+  // capacity.
+  // SanitizeOptions will set max_open_files to minimum of 20. Table cache
+  // is allocated with max_open_files - 10 as capacity. So override
+  // max_open_files to 11 so table cache capacity will become 1. This will
+  // prevent file open during DB open and force the file to be opened
+  // during MultiGet
+  SyncPoint::GetInstance()->SetCallBack(
+      "SanitizeOptions::AfterChangeMaxOpenFiles", [&](void* arg) {
+        int* max_open_files = (int*)arg;
+        *max_open_files = 11;
+      });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  ReopenDB();
+
+  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());
+  SyncPoint::GetInstance()->DisableProcessing();
+  ASSERT_EQ(values.size(), 3);
+  ASSERT_EQ(statuses[0], Status::OK());
+  ASSERT_EQ(statuses[1], Status::OK());
+  ASSERT_EQ(statuses[2], Status::IOError());
+
+  HistogramData multiget_io_batch_size;
+
+  statistics()->histogramData(MULTIGET_IO_BATCH_SIZE, &multiget_io_batch_size);
+
+  // A batch of 3 async IOs is expected, one for each overlapping file in L1
+  ASSERT_EQ(multiget_io_batch_size.count, 1);
+  ASSERT_EQ(multiget_io_batch_size.max, 2);
+  ASSERT_EQ(statistics()->getTickerCount(MULTIGET_COROUTINE_COUNT), 2);
+}
+
 TEST_P(DBMultiGetAsyncIOTest, LastKeyInFile) {
  std::vector<std::string> key_strs;
  std::vector<Slice> keys;
@@ -2641,7 +2719,6 @@ TEST_P(MultiGetPrefixExtractorTest, Batched) {
 INSTANTIATE_TEST_CASE_P(MultiGetPrefix, MultiGetPrefixExtractorTest,
                        ::testing::Bool());

-#ifndef ROCKSDB_LITE
 class DBMultiGetRowCacheTest : public DBBasicTest,
                               public ::testing::WithParamInterface<bool> {};

@@ -2796,7 +2873,6 @@ TEST_F(DBBasicTest, ValueTypeString) {
    ASSERT_TRUE(key_version.GetTypeName() != "Invalid");
  }
 }
-#endif  // !ROCKSDB_LITE

 TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
  Options options = CurrentOptions();
@@ -2805,7 +2881,7 @@ TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
  table_options.pin_l0_filter_and_index_blocks_in_cache = true;
  table_options.block_size = 16 * 1024;
  ASSERT_TRUE(table_options.block_size >
-            BlockBasedTable::kMultiGetReadStackBufSize);
+              BlockBasedTable::kMultiGetReadStackBufSize);
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
  Reopen(options);

@@ -2897,7 +2973,6 @@ TEST_F(DBBasicTest, BestEffortsRecoveryWithVersionBuildingFailure) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-#ifndef ROCKSDB_LITE
 namespace {
 class TableFileListener : public EventListener {
 public:
@@ -2914,7 +2989,7 @@ class TableFileListener : public EventListener {
  InstrumentedMutex mutex_;
  std::unordered_map<std::string, std::vector<std::string>> cf_to_paths_;
 };
-}  // namespace
+}  // anonymous namespace

 TEST_F(DBBasicTest, LastSstFileNotInManifest) {
  // If the last sst file is not tracked in MANIFEST,
@@ -3172,7 +3247,6 @@ TEST_F(DBBasicTest, DisableTrackWal) {
  ASSERT_TRUE(dbfull()->GetVersionSet()->GetWalSet().GetWals().empty());
  Close();
 }
-#endif  // !ROCKSDB_LITE

 TEST_F(DBBasicTest, ManifestChecksumMismatch) {
  Options options = CurrentOptions();
@@ -3216,7 +3290,6 @@ TEST_F(DBBasicTest, ConcurrentlyCloseDB) {
  }
 }

-#ifndef ROCKSDB_LITE
 class DBBasicTestTrackWal : public DBTestBase,
                            public testing::WithParamInterface<bool> {
 public:
@@ -3272,21 +3345,16 @@ TEST_P(DBBasicTestTrackWal, DoNotTrackObsoleteWal) {

 INSTANTIATE_TEST_CASE_P(DBBasicTestTrackWal, DBBasicTestTrackWal,
                        testing::Bool());
-#endif  // ROCKSDB_LITE

 class DBBasicTestMultiGet : public DBTestBase {
 public:
-  DBBasicTestMultiGet(std::string test_dir, int num_cfs, bool compressed_cache,
+  DBBasicTestMultiGet(std::string test_dir, int num_cfs,
                      bool uncompressed_cache, bool _compression_enabled,
                      bool _fill_cache, uint32_t compression_parallel_threads)
      : DBTestBase(test_dir, /*env_do_fsync=*/false) {
    compression_enabled_ = _compression_enabled;
    fill_cache_ = _fill_cache;

-    if (compressed_cache) {
-      std::shared_ptr<Cache> cache = NewLRUCache(1048576);
-      compressed_cache_ = std::make_shared<MyBlockCache>(cache);
-    }
    if (uncompressed_cache) {
      std::shared_ptr<Cache> cache = NewLRUCache(1048576);
      uncompressed_cache_ = std::make_shared<MyBlockCache>(cache);
@@ -3298,7 +3366,6 @@ class DBBasicTestMultiGet : public DBTestBase {
    Random rnd(301);
    BlockBasedTableOptions table_options;

-#ifndef ROCKSDB_LITE
    if (compression_enabled_) {
      std::vector<CompressionType> compression_types;
      compression_types = GetSupportedCompressions();
@@ -3317,12 +3384,6 @@ class DBBasicTestMultiGet : public DBTestBase {
        compression_enabled_ = false;
      }
    }
-#else
-    // GetSupportedCompressions() is not available in LITE build
-    if (!Snappy_Supported()) {
-      compression_enabled_ = false;
-    }
-#endif  // ROCKSDB_LITE

    table_options.block_cache = uncompressed_cache_;
    if (table_options.block_cache == nullptr) {
@@ -3330,7 +3391,6 @@ class DBBasicTestMultiGet : public DBTestBase {
    } else {
      table_options.pin_l0_filter_and_index_blocks_in_cache = true;
    }
-    table_options.block_cache_compressed = compressed_cache_;
    table_options.flush_block_policy_factory.reset(
        new MyFlushBlockPolicyFactory());
    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
@@ -3470,24 +3530,27 @@ class DBBasicTestMultiGet : public DBTestBase {

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

-    using Cache::Insert;
-    Status Insert(const Slice& key, void* value, size_t charge,
-                  void (*deleter)(const Slice& key, void* value),
+    Status Insert(const Slice& key, Cache::ObjectPtr value,
+                  const CacheItemHelper* helper, size_t charge,
                  Handle** handle = nullptr,
                  Priority priority = Priority::LOW) override {
      num_inserts_++;
-      return target_->Insert(key, value, charge, deleter, handle, priority);
+      return target_->Insert(key, value, helper, charge, handle, priority);
    }

-    using Cache::Lookup;
-    Handle* Lookup(const Slice& key, Statistics* stats = nullptr) override {
+    Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
+                   CreateContext* create_context,
+                   Priority priority = Priority::LOW, bool wait = true,
+                   Statistics* stats = nullptr) override {
      num_lookups_++;
-      Handle* handle = target_->Lookup(key, stats);
+      Handle* handle =
+          target_->Lookup(key, helper, create_context, priority, wait, stats);
      if (handle != nullptr) {
        num_found_++;
      }
      return handle;
    }
+
    int num_lookups() { return num_lookups_; }

    int num_found() { return num_found_; }
@@ -3510,16 +3573,14 @@ class DBBasicTestMultiGet : public DBTestBase {
  std::vector<std::string> cf_names_;
 };

-class DBBasicTestWithParallelIO
-    : public DBBasicTestMultiGet,
-      public testing::WithParamInterface<
-          std::tuple<bool, bool, bool, bool, uint32_t>> {
+class DBBasicTestWithParallelIO : public DBBasicTestMultiGet,
+                                  public testing::WithParamInterface<
+                                      std::tuple<bool, bool, bool, uint32_t>> {
 public:
  DBBasicTestWithParallelIO()
      : DBBasicTestMultiGet("/db_basic_test_with_parallel_io", 1,
                            std::get<0>(GetParam()), std::get<1>(GetParam()),
-                            std::get<2>(GetParam()), std::get<3>(GetParam()),
-                            std::get<4>(GetParam())) {}
+                            std::get<2>(GetParam()), std::get<3>(GetParam())) {}
 };

 TEST_P(DBBasicTestWithParallelIO, MultiGet) {
@@ -3645,7 +3706,6 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
  }
 }

-#ifndef ROCKSDB_LITE
 TEST_P(DBBasicTestWithParallelIO, MultiGetDirectIO) {
  class FakeDirectIOEnv : public EnvWrapper {
    class FakeDirectIOSequentialFile;
@@ -3762,7 +3822,6 @@ TEST_P(DBBasicTestWithParallelIO, MultiGetDirectIO) {
  }
  Close();
 }
-#endif  // ROCKSDB_LITE

 TEST_P(DBBasicTestWithParallelIO, MultiGetWithChecksumMismatch) {
  std::vector<std::string> key_data(10);
@@ -3850,13 +3909,12 @@ TEST_P(DBBasicTestWithParallelIO, MultiGetWithMissingFile) {

 INSTANTIATE_TEST_CASE_P(ParallelIO, DBBasicTestWithParallelIO,
                        // Params are as follows -
-                        // Param 0 - Compressed cache enabled
-                        // Param 1 - Uncompressed cache enabled
-                        // Param 2 - Data compression enabled
-                        // Param 3 - ReadOptions::fill_cache
-                        // Param 4 - CompressionOptions::parallel_threads
+                        // Param 0 - Uncompressed cache enabled
+                        // Param 1 - Data compression enabled
+                        // Param 2 - ReadOptions::fill_cache
+                        // Param 3 - CompressionOptions::parallel_threads
                        ::testing::Combine(::testing::Bool(), ::testing::Bool(),
-                                           ::testing::Bool(), ::testing::Bool(),
+                                           ::testing::Bool(),
                                           ::testing::Values(1, 4)));

 // Forward declaration
@@ -4067,9 +4125,8 @@ class DBBasicTestMultiGetDeadline : public DBBasicTestMultiGet,
  DBBasicTestMultiGetDeadline()
      : DBBasicTestMultiGet(
            "db_basic_test_multiget_deadline" /*Test dir*/,
-            10 /*# of column families*/, false /*compressed cache enabled*/,
-            true /*uncompressed cache enabled*/, true /*compression enabled*/,
-            true /*ReadOptions.fill_cache*/,
+            10 /*# of column families*/, true /*uncompressed cache enabled*/,
+            true /*compression enabled*/, true /*ReadOptions.fill_cache*/,
            1 /*# of parallel compression threads*/) {}

  inline void CheckStatus(std::vector<Status>& statuses, size_t num_ok) {
@@ -4305,7 +4362,6 @@ TEST_F(DBBasicTest, FailOpenIfLoggerCreationFail) {
  SyncPoint::GetInstance()->ClearAllCallBacks();
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBBasicTest, VerifyFileChecksums) {
  Options options = GetDefaultOptions();
  options.create_if_missing = true;
@@ -4371,7 +4427,6 @@ TEST_F(DBBasicTest, DISABLED_ManualWalSync) {

  ASSERT_TRUE(TryReopen(options).IsCorruption());
 }
-#endif  // !ROCKSDB_LITE

 // A test class for intercepting random reads and injecting artificial
 // delays. Used for testing the deadline/timeout feature
@@ -13,8 +13,8 @@

 #include "cache/cache_entry_roles.h"
 #include "cache/cache_key.h"
-#include "cache/fast_lru_cache.h"
 #include "cache/lru_cache.h"
+#include "cache/typed_cache.h"
 #include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/db_test_util.h"
@@ -44,10 +44,6 @@ class DBBlockCacheTest : public DBTestBase {
  size_t compression_dict_miss_count_ = 0;
  size_t compression_dict_hit_count_ = 0;
  size_t compression_dict_insert_count_ = 0;
-  size_t compressed_miss_count_ = 0;
-  size_t compressed_hit_count_ = 0;
-  size_t compressed_insert_count_ = 0;
-  size_t compressed_failure_count_ = 0;

 public:
  const size_t kNumBlocks = 10;
@@ -85,14 +81,6 @@ class DBBlockCacheTest : public DBTestBase {
    hit_count_ = TestGetTickerCount(options, BLOCK_CACHE_HIT);
    insert_count_ = TestGetTickerCount(options, BLOCK_CACHE_ADD);
    failure_count_ = TestGetTickerCount(options, BLOCK_CACHE_ADD_FAILURES);
-    compressed_miss_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS);
-    compressed_hit_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT);
-    compressed_insert_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_ADD);
-    compressed_failure_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_ADD_FAILURES);
  }

  void RecordCacheCountersForCompressionDict(const Options& options) {
@@ -144,30 +132,6 @@ class DBBlockCacheTest : public DBTestBase {
    compression_dict_insert_count_ = new_compression_dict_insert_count;
  }

-  void CheckCompressedCacheCounters(const Options& options,
-                                    size_t expected_misses,
-                                    size_t expected_hits,
-                                    size_t expected_inserts,
-                                    size_t expected_failures) {
-    size_t new_miss_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS);
-    size_t new_hit_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT);
-    size_t new_insert_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_ADD);
-    size_t new_failure_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_ADD_FAILURES);
-    ASSERT_EQ(compressed_miss_count_ + expected_misses, new_miss_count);
-    ASSERT_EQ(compressed_hit_count_ + expected_hits, new_hit_count);
-    ASSERT_EQ(compressed_insert_count_ + expected_inserts, new_insert_count);
-    ASSERT_EQ(compressed_failure_count_ + expected_failures, new_failure_count);
-    compressed_miss_count_ = new_miss_count;
-    compressed_hit_count_ = new_hit_count;
-    compressed_insert_count_ = new_insert_count;
-    compressed_failure_count_ = new_failure_count;
-  }
-
-#ifndef ROCKSDB_LITE
  const std::array<size_t, kNumCacheEntryRoles> GetCacheEntryRoleCountsBg() {
    // Verify in cache entry role stats
    std::array<size_t, kNumCacheEntryRoles> cache_entry_role_counts;
@@ -181,7 +145,6 @@ class DBBlockCacheTest : public DBTestBase {
    }
    return cache_entry_role_counts;
  }
-#endif  // ROCKSDB_LITE
 };

 TEST_F(DBBlockCacheTest, IteratorBlockCacheUsage) {
@@ -274,84 +237,6 @@ TEST_F(DBBlockCacheTest, TestWithoutCompressedBlockCache) {
 }

 #ifdef SNAPPY
-TEST_F(DBBlockCacheTest, TestWithCompressedBlockCache) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-  BlockBasedTableOptions table_options;
-  table_options.no_block_cache = true;
-  table_options.block_cache_compressed = nullptr;
-  table_options.block_size = 1;
-  table_options.filter_policy.reset(NewBloomFilterPolicy(20));
-  table_options.cache_index_and_filter_blocks = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.compression = CompressionType::kSnappyCompression;
-
-  DestroyAndReopen(options);
-
-  std::string value(kValueSize, 'a');
-  for (size_t i = 0; i < kNumBlocks; i++) {
-    ASSERT_OK(Put(std::to_string(i), value));
-    ASSERT_OK(Flush());
-  }
-
-  ReadOptions read_options;
-  std::shared_ptr<Cache> compressed_cache = NewLRUCache(1 << 25, 0, false);
-  LRUCacheOptions co;
-  co.capacity = 0;
-  co.num_shard_bits = 0;
-  co.strict_capacity_limit = false;
-  // Needed not to count entry stats collector
-  co.metadata_charge_policy = kDontChargeCacheMetadata;
-  std::shared_ptr<Cache> cache = NewLRUCache(co);
-  table_options.block_cache = cache;
-  table_options.no_block_cache = false;
-  table_options.block_cache_compressed = compressed_cache;
-  table_options.max_auto_readahead_size = 0;
-  table_options.cache_index_and_filter_blocks = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  Reopen(options);
-  RecordCacheCounters(options);
-
-  // Load blocks into cache.
-  for (size_t i = 0; i < kNumBlocks - 1; i++) {
-    ASSERT_EQ(value, Get(std::to_string(i)));
-    CheckCacheCounters(options, 1, 0, 1, 0);
-    CheckCompressedCacheCounters(options, 1, 0, 1, 0);
-  }
-
-  size_t usage = cache->GetUsage();
-  ASSERT_EQ(0, usage);
-  ASSERT_EQ(usage, cache->GetPinnedUsage());
-  size_t compressed_usage = compressed_cache->GetUsage();
-  ASSERT_LT(0, compressed_usage);
-  // Compressed block cache cannot be pinned.
-  ASSERT_EQ(0, compressed_cache->GetPinnedUsage());
-
-  // Set strict capacity limit flag. Now block will only load into compressed
-  // block cache.
-  cache->SetCapacity(usage);
-  cache->SetStrictCapacityLimit(true);
-  ASSERT_EQ(usage, cache->GetPinnedUsage());
-
-  // Load last key block.
-  ASSERT_EQ(
-      "Operation aborted: Memory limit reached: Insert failed due to LRU cache "
-      "being full.",
-      Get(std::to_string(kNumBlocks - 1)));
-  // Failure will also record the miss counter.
-  CheckCacheCounters(options, 1, 0, 0, 1);
-  CheckCompressedCacheCounters(options, 1, 0, 1, 0);
-
-  // Clear strict capacity limit flag. This time we shall hit compressed block
-  // cache and load into block cache.
-  cache->SetStrictCapacityLimit(false);
-  // Load last key block.
-  ASSERT_EQ(value, Get(std::to_string(kNumBlocks - 1)));
-  CheckCacheCounters(options, 1, 0, 1, 0);
-  CheckCompressedCacheCounters(options, 0, 1, 0, 0);
-}

 namespace {
 class PersistentCacheFromCache : public PersistentCache {
@@ -366,9 +251,7 @@ class PersistentCacheFromCache : public PersistentCache {
    }
    std::unique_ptr<char[]> copy{new char[size]};
    std::copy_n(data, size, copy.get());
-    Status s = cache_->Insert(
-        key, copy.get(), size,
-        GetCacheEntryDeleterForRole<char[], CacheEntryRole::kMisc>());
+    Status s = cache_.Insert(key, copy.get(), size);
    if (s.ok()) {
      copy.release();
    }
@@ -377,13 +260,13 @@ class PersistentCacheFromCache : public PersistentCache {

  Status Lookup(const Slice& key, std::unique_ptr<char[]>* data,
                size_t* size) override {
-    auto handle = cache_->Lookup(key);
+    auto handle = cache_.Lookup(key);
    if (handle) {
-      char* ptr = static_cast<char*>(cache_->Value(handle));
-      *size = cache_->GetCharge(handle);
+      char* ptr = cache_.Value(handle);
+      *size = cache_.get()->GetCharge(handle);
      data->reset(new char[*size]);
      std::copy_n(ptr, *size, data->get());
-      cache_->Release(handle);
+      cache_.Release(handle);
      return Status::OK();
    } else {
      return Status::NotFound();
@@ -396,10 +279,10 @@ class PersistentCacheFromCache : public PersistentCache {

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

-  uint64_t NewId() override { return cache_->NewId(); }
+  uint64_t NewId() override { return cache_.get()->NewId(); }

 private:
-  std::shared_ptr<Cache> cache_;
+  BasicTypedSharedCacheInterface<char[], CacheEntryRole::kMisc> cache_;
  bool read_only_;
 };

@@ -407,91 +290,16 @@ class ReadOnlyCacheWrapper : public CacheWrapper {
  using CacheWrapper::CacheWrapper;

  using Cache::Insert;
-  Status Insert(const Slice& /*key*/, void* /*value*/, size_t /*charge*/,
-                void (*)(const Slice& key, void* value) /*deleter*/,
+  Status Insert(const Slice& /*key*/, Cache::ObjectPtr /*value*/,
+                const CacheItemHelper* /*helper*/, size_t /*charge*/,
                Handle** /*handle*/, Priority /*priority*/) override {
    return Status::NotSupported();
  }
 };

-}  // namespace
-
-TEST_F(DBBlockCacheTest, TestWithSameCompressed) {
-  auto table_options = GetTableOptions();
-  auto options = GetOptions(table_options);
-  InitTable(options);
-
-  std::shared_ptr<Cache> rw_cache{NewLRUCache(1000000)};
-  std::shared_ptr<PersistentCacheFromCache> rw_pcache{
-      new PersistentCacheFromCache(rw_cache, /*read_only*/ false)};
-  // Exercise some obscure behavior with read-only wrappers
-  std::shared_ptr<Cache> ro_cache{new ReadOnlyCacheWrapper(rw_cache)};
-  std::shared_ptr<PersistentCacheFromCache> ro_pcache{
-      new PersistentCacheFromCache(rw_cache, /*read_only*/ true)};
-
-  // Simple same pointer
-  table_options.block_cache = rw_cache;
-  table_options.block_cache_compressed = rw_cache;
-  table_options.persistent_cache.reset();
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: block_cache same as block_cache_compressed not "
-            "currently supported, and would be bad for performance anyway");
-
-  // Other cases
-  table_options.block_cache = ro_cache;
-  table_options.block_cache_compressed = rw_cache;
-  table_options.persistent_cache.reset();
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: block_cache and block_cache_compressed share "
-            "the same key space, which is not supported");
-
-  table_options.block_cache = rw_cache;
-  table_options.block_cache_compressed = ro_cache;
-  table_options.persistent_cache.reset();
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: block_cache_compressed and block_cache share "
-            "the same key space, which is not supported");
-
-  table_options.block_cache = ro_cache;
-  table_options.block_cache_compressed.reset();
-  table_options.persistent_cache = rw_pcache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: block_cache and persistent_cache share the same "
-            "key space, which is not supported");
-
-  table_options.block_cache = rw_cache;
-  table_options.block_cache_compressed.reset();
-  table_options.persistent_cache = ro_pcache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: persistent_cache and block_cache share the same "
-            "key space, which is not supported");
-
-  table_options.block_cache.reset();
-  table_options.no_block_cache = true;
-  table_options.block_cache_compressed = ro_cache;
-  table_options.persistent_cache = rw_pcache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: block_cache_compressed and persistent_cache "
-            "share the same key space, which is not supported");
-
-  table_options.block_cache.reset();
-  table_options.no_block_cache = true;
-  table_options.block_cache_compressed = rw_cache;
-  table_options.persistent_cache = ro_pcache;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_EQ(TryReopen(options).ToString(),
-            "Invalid argument: persistent_cache and block_cache_compressed "
-            "share the same key space, which is not supported");
-}
+}  // anonymous namespace
 #endif  // SNAPPY

-#ifndef ROCKSDB_LITE

 // Make sure that when options.block_cache is set, after a new table is
 // created its index/filter blocks are added to block cache.
@@ -611,11 +419,6 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
  ASSERT_EQ(cache->GetUsage(), index_bytes_insert + filter_bytes_insert);
  // set the cache capacity to the current usage
  cache->SetCapacity(index_bytes_insert + filter_bytes_insert);
-  // The index and filter eviction statistics were broken by the refactoring
-  // that moved the readers out of the block cache. Disabling these until we can
-  // bring the stats back.
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_INDEX_BYTES_EVICT), 0);
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT), 0);
  // Note that the second key needs to be no longer than the first one.
  // Otherwise the second index block may not fit in cache.
  ASSERT_OK(Put(1, "key", "val"));
@@ -626,13 +429,6 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
            index_bytes_insert);
  ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_INSERT),
            filter_bytes_insert);
-  // The index and filter eviction statistics were broken by the refactoring
-  // that moved the readers out of the block cache. Disabling these until we can
-  // bring the stats back.
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_INDEX_BYTES_EVICT),
-  //           index_bytes_insert);
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT),
-  //           filter_bytes_insert);
 }

 #if (defined OS_LINUX || defined OS_WIN)
@@ -828,16 +624,15 @@ class MockCache : public LRUCache {

  using ShardedCache::Insert;

-  Status Insert(const Slice& key, void* value,
-                const Cache::CacheItemHelper* helper_cb, size_t charge,
+  Status Insert(const Slice& key, Cache::ObjectPtr value,
+                const Cache::CacheItemHelper* helper, size_t charge,
                Handle** handle, Priority priority) override {
-    DeleterFn delete_cb = helper_cb->del_cb;
    if (priority == Priority::LOW) {
      low_pri_insert_count++;
    } else {
      high_pri_insert_count++;
    }
-    return LRUCache::Insert(key, value, charge, delete_cb, handle, priority);
+    return LRUCache::Insert(key, value, helper, charge, handle, priority);
  }
 };

@@ -917,7 +712,10 @@ class LookupLiarCache : public CacheWrapper {
      : CacheWrapper(std::move(target)) {}

  using Cache::Lookup;
-  Handle* Lookup(const Slice& key, Statistics* stats) override {
+  Handle* Lookup(const Slice& key, const CacheItemHelper* helper = nullptr,
+                 CreateContext* create_context = nullptr,
+                 Priority priority = Priority::LOW, bool wait = true,
+                 Statistics* stats = nullptr) override {
    if (nth_lookup_not_found_ == 1) {
      nth_lookup_not_found_ = 0;
      return nullptr;
@@ -925,7 +723,8 @@ class LookupLiarCache : public CacheWrapper {
    if (nth_lookup_not_found_ > 1) {
      --nth_lookup_not_found_;
    }
-    return CacheWrapper::Lookup(key, stats);
+    return CacheWrapper::Lookup(key, helper, create_context, priority, wait,
+                                stats);
  }

  // 1 == next lookup, 2 == after next, etc.
@@ -944,10 +743,7 @@ TEST_F(DBBlockCacheTest, AddRedundantStats) {
            capacity,
            BlockBasedTableOptions().block_size /*estimated_value_size*/,
            num_shard_bits)
-            .MakeSharedCache(),
-        NewFastLRUCache(capacity, 1 /*estimated_value_size*/, num_shard_bits,
-                        false /*strict_capacity_limit*/,
-                        kDefaultCacheMetadataChargePolicy)}) {
+            .MakeSharedCache()}) {
    if (!base_cache) {
      // Skip clock cache when not supported
      continue;
@@ -1088,124 +884,6 @@ TEST_F(DBBlockCacheTest, ParanoidFileChecks) {
            TestGetTickerCount(options, BLOCK_CACHE_ADD));
 }

-TEST_F(DBBlockCacheTest, CompressedCache) {
-  if (!Snappy_Supported()) {
-    return;
-  }
-  int num_iter = 80;
-
-  // Run this test three iterations.
-  // Iteration 1: only a uncompressed block cache
-  // Iteration 2: only a compressed block cache
-  // Iteration 3: both block cache and compressed cache
-  // Iteration 4: both block cache and compressed cache, but DB is not
-  // compressed
-  for (int iter = 0; iter < 4; iter++) {
-    Options options = CurrentOptions();
-    options.write_buffer_size = 64 * 1024;  // small write buffer
-    options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
-
-    BlockBasedTableOptions table_options;
-    switch (iter) {
-      case 0:
-        // only uncompressed block cache
-        table_options.block_cache = NewLRUCache(8 * 1024);
-        table_options.block_cache_compressed = nullptr;
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 1:
-        // no block cache, only compressed cache
-        table_options.no_block_cache = true;
-        table_options.block_cache = nullptr;
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 2:
-        // both compressed and uncompressed block cache
-        table_options.block_cache = NewLRUCache(1024);
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        break;
-      case 3:
-        // both block cache and compressed cache, but DB is not compressed
-        // also, make block cache sizes bigger, to trigger block cache hits
-        table_options.block_cache = NewLRUCache(1024 * 1024);
-        table_options.block_cache_compressed = NewLRUCache(8 * 1024 * 1024);
-        options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-        options.compression = kNoCompression;
-        break;
-      default:
-        FAIL();
-    }
-    CreateAndReopenWithCF({"pikachu"}, options);
-    // default column family doesn't have block cache
-    Options no_block_cache_opts;
-    no_block_cache_opts.statistics = options.statistics;
-    no_block_cache_opts = CurrentOptions(no_block_cache_opts);
-    BlockBasedTableOptions table_options_no_bc;
-    table_options_no_bc.no_block_cache = true;
-    no_block_cache_opts.table_factory.reset(
-        NewBlockBasedTableFactory(table_options_no_bc));
-    ReopenWithColumnFamilies(
-        {"default", "pikachu"},
-        std::vector<Options>({no_block_cache_opts, options}));
-
-    Random rnd(301);
-
-    // Write 8MB (80 values, each 100K)
-    ASSERT_EQ(NumTableFilesAtLevel(0, 1), 0);
-    std::vector<std::string> values;
-    std::string str;
-    for (int i = 0; i < num_iter; i++) {
-      if (i % 4 == 0) {  // high compression ratio
-        str = rnd.RandomString(1000);
-      }
-      values.push_back(str);
-      ASSERT_OK(Put(1, Key(i), values[i]));
-    }
-
-    // flush all data from memtable so that reads are from block cache
-    ASSERT_OK(Flush(1));
-
-    for (int i = 0; i < num_iter; i++) {
-      ASSERT_EQ(Get(1, Key(i)), values[i]);
-    }
-
-    // check that we triggered the appropriate code paths in the cache
-    switch (iter) {
-      case 0:
-        // only uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 1:
-        // no block cache, only compressed cache
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 2:
-        // both compressed and uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        break;
-      case 3:
-        // both compressed and uncompressed block cache
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_MISS), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_HIT), 0);
-        ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_MISS), 0);
-        // compressed doesn't have any hits since blocks are not compressed on
-        // storage
-        ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_HIT), 0);
-        break;
-      default:
-        FAIL();
-    }
-
-    options.create_if_missing = true;
-    DestroyAndReopen(options);
-  }
-}
-
 TEST_F(DBBlockCacheTest, CacheCompressionDict) {
  const int kNumFiles = 4;
  const int kNumEntriesPerFile = 128;
@@ -1279,12 +957,11 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
 }

 static void ClearCache(Cache* cache) {
-  auto roles = CopyCacheDeleterRoleMap();
  std::deque<std::string> keys;
  Cache::ApplyToAllEntriesOptions opts;
-  auto callback = [&](const Slice& key, void* /*value*/, size_t /*charge*/,
-                      Cache::DeleterFn deleter) {
-    if (roles.find(deleter) == roles.end()) {
+  auto callback = [&](const Slice& key, Cache::ObjectPtr, size_t /*charge*/,
+                      const Cache::CacheItemHelper* helper) {
+    if (helper && helper->role == CacheEntryRole::kMisc) {
      // Keep the stats collector
      return;
    }
@@ -1306,11 +983,6 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {
              capacity,
              BlockBasedTableOptions().block_size /*estimated_value_size*/)
              .MakeSharedCache()}) {
-      if (!cache) {
-        // Skip clock cache when not supported
-        continue;
-      }
-
      ++iterations_tested;

      Options options = CurrentOptions();
@@ -1459,14 +1131,13 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {
      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));
+        ASSERT_OK(cache->Insert("Fill-it-up", nullptr, &kNoopCacheItemHelper,
+                                capacity + 1, &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-xxxxx", nullptr,
+                                &kNoopCacheItemHelper, capacity + 1, &h,
+                                Cache::Priority::HIGH));
      }
      ASSERT_GT(cache->GetUsage(), cache->GetCapacity());
      expected = {};
@@ -1543,7 +1214,124 @@ TEST_F(DBBlockCacheTest, CacheEntryRoleStats) {
  }
 }

-#endif  // ROCKSDB_LITE
+namespace {
+
+void DummyFillCache(Cache& cache, size_t entry_size,
+                    std::vector<CacheHandleGuard<void>>& handles) {
+  // fprintf(stderr, "Entry size: %zu\n", entry_size);
+  handles.clear();
+  cache.EraseUnRefEntries();
+  void* fake_value = &cache;
+  size_t capacity = cache.GetCapacity();
+  OffsetableCacheKey ck{"abc", "abc", 42};
+  for (size_t my_usage = 0; my_usage < capacity;) {
+    size_t charge = std::min(entry_size, capacity - my_usage);
+    Cache::Handle* handle;
+    Status st = cache.Insert(ck.WithOffset(my_usage).AsSlice(), fake_value,
+                             &kNoopCacheItemHelper, charge, &handle);
+    ASSERT_OK(st);
+    handles.emplace_back(&cache, handle);
+    my_usage += charge;
+  }
+}
+
+class CountingLogger : public Logger {
+ public:
+  ~CountingLogger() override {}
+  using Logger::Logv;
+  void Logv(const InfoLogLevel log_level, const char* format,
+            va_list /*ap*/) override {
+    if (std::strstr(format, "HyperClockCache") == nullptr) {
+      // Not a match
+      return;
+    }
+    // static StderrLogger debug;
+    // debug.Logv(log_level, format, ap);
+    if (log_level == InfoLogLevel::INFO_LEVEL) {
+      ++info_count_;
+    } else if (log_level == InfoLogLevel::WARN_LEVEL) {
+      ++warn_count_;
+    } else if (log_level == InfoLogLevel::ERROR_LEVEL) {
+      ++error_count_;
+    }
+  }
+
+  std::array<int, 3> PopCounts() {
+    std::array<int, 3> rv{{info_count_, warn_count_, error_count_}};
+    info_count_ = warn_count_ = error_count_ = 0;
+    return rv;
+  }
+
+ private:
+  int info_count_{};
+  int warn_count_{};
+  int error_count_{};
+};
+
+}  // namespace
+
+TEST_F(DBBlockCacheTest, HyperClockCacheReportProblems) {
+  size_t capacity = 1024 * 1024;
+  size_t value_size_est = 8 * 1024;
+  HyperClockCacheOptions hcc_opts{capacity, value_size_est};
+  hcc_opts.num_shard_bits = 2;  // 4 shards
+  hcc_opts.metadata_charge_policy = kDontChargeCacheMetadata;
+  std::shared_ptr<Cache> cache = hcc_opts.MakeSharedCache();
+  std::shared_ptr<CountingLogger> logger = std::make_shared<CountingLogger>();
+
+  auto table_options = GetTableOptions();
+  auto options = GetOptions(table_options);
+  table_options.block_cache = cache;
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  options.info_log = logger;
+  // Going to sample more directly
+  options.stats_dump_period_sec = 0;
+  Reopen(options);
+
+  std::vector<CacheHandleGuard<void>> handles;
+
+  // Clear anything from DB startup
+  logger->PopCounts();
+
+  // Fill cache based on expected size and check that when we
+  // don't report anything relevant in periodic stats dump
+  DummyFillCache(*cache, value_size_est, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 0, 0}}));
+
+  // Same, within reasonable bounds
+  DummyFillCache(*cache, value_size_est - value_size_est / 4, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 0, 0}}));
+
+  DummyFillCache(*cache, value_size_est + value_size_est / 3, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 0, 0}}));
+
+  // Estimate too high (value size too low) eventually reports ERROR
+  DummyFillCache(*cache, value_size_est / 2, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 1, 0}}));
+
+  DummyFillCache(*cache, value_size_est / 3, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 0, 1}}));
+
+  // Estimate too low (value size too high) starts with INFO
+  // and is only WARNING in the worst case
+  DummyFillCache(*cache, value_size_est * 2, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{1, 0, 0}}));
+
+  DummyFillCache(*cache, value_size_est * 3, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 1, 0}}));
+
+  DummyFillCache(*cache, value_size_est * 20, handles);
+  dbfull()->DumpStats();
+  EXPECT_EQ(logger->PopCounts(), (std::array<int, 3>{{0, 1, 0}}));
+}
+

 class DBBlockCacheKeyTest
    : public DBTestBase,
@@ -1599,31 +1387,16 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
  uint64_t expected_stat = 0;

  std::function<void()> verify_stats;
-  if (use_compressed_cache_) {
-    if (!Snappy_Supported()) {
-      ROCKSDB_GTEST_SKIP("Compressed cache test requires snappy support");
-      return;
-    }
-    options.compression = CompressionType::kSnappyCompression;
-    table_options.no_block_cache = true;
-    table_options.block_cache_compressed = NewLRUCache(1 << 25, 0, false);
-    verify_stats = [&options, &expected_stat] {
-      // One for ordinary SST file and one for external SST file
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_COMPRESSED_ADD));
-    };
-  } else {
-    table_options.cache_index_and_filter_blocks = true;
-    table_options.block_cache = NewLRUCache(1 << 25, 0, false);
-    verify_stats = [&options, &expected_stat] {
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_INDEX_ADD));
-      ASSERT_EQ(expected_stat,
-                options.statistics->getTickerCount(BLOCK_CACHE_FILTER_ADD));
-    };
-  }
+  table_options.cache_index_and_filter_blocks = true;
+  table_options.block_cache = NewLRUCache(1 << 25, 0, false);
+  verify_stats = [&options, &expected_stat] {
+    ASSERT_EQ(expected_stat,
+              options.statistics->getTickerCount(BLOCK_CACHE_DATA_ADD));
+    ASSERT_EQ(expected_stat,
+              options.statistics->getTickerCount(BLOCK_CACHE_INDEX_ADD));
+    ASSERT_EQ(expected_stat,
+              options.statistics->getTickerCount(BLOCK_CACHE_FILTER_ADD));
+  };

  table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
@@ -1665,7 +1438,6 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
    ++key_count;
  }

-#ifndef ROCKSDB_LITE
  // Save an export of those ordinary SST files for later
  std::string export_files_dir = dbname_ + "/exported";
  ExportImportFilesMetaData* metadata_ptr_ = nullptr;
@@ -1694,13 +1466,6 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
    ASSERT_OK(db_->IngestExternalFile(handles_[1], {f}, ingest_opts));
  }

-  if (exclude_file_numbers_) {
-    // FIXME(peterd): figure out where these extra ADDs are coming from
-    options.statistics->recordTick(BLOCK_CACHE_COMPRESSED_ADD,
-                                   uint64_t{0} - uint64_t{2});
-  }
-#endif
-
  perform_gets();
  verify_stats();

@@ -1713,7 +1478,6 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {
  // Make sure we can cache hit even on a full copy of the DB. Using
  // StableCacheKeyTestFS, Checkpoint will resort to full copy not hard link.
  // (Checkpoint  not available in LITE mode to test this.)
-#ifndef ROCKSDB_LITE
  auto db_copy_name = dbname_ + "-copy";
  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
  ASSERT_OK(checkpoint->CreateCheckpoint(db_copy_name));
@@ -1752,7 +1516,6 @@ TEST_P(DBBlockCacheKeyTest, StableCacheKeys) {

  perform_gets();
  verify_stats();
-#endif  // !ROCKSDB_LITE

  Close();
  Destroy(options);
@@ -1973,7 +1736,7 @@ struct CacheKeyDecoder {
                                   DownwardInvolution(decoded_session_counter));
  }
 };
-}  // namespace
+}  // anonymous namespace

 TEST_F(CacheKeyTest, Encodings) {
  // This test primarily verifies this claim from cache_key.cc:
@@ -43,7 +43,7 @@ const std::string kStandard128Ribbon =
    test::Standard128RibbonFilterPolicy::kClassName();
 const std::string kAutoBloom = BloomFilterPolicy::kClassName();
 const std::string kAutoRibbon = RibbonFilterPolicy::kClassName();
-}  // namespace
+}  // anonymous namespace

 // DB tests related to bloom filter.

@@ -245,14 +245,12 @@ TEST_F(DBBloomFilterTest, GetFilterByPrefixBloomCustomPrefixExtractor) {
        (*(get_perf_context()->level_to_perf_context))[0].bloom_filter_useful);

    // No bloom on extractor changed
-#ifndef ROCKSDB_LITE
    ASSERT_OK(db_->SetOptions({{"prefix_extractor", "capped:10"}}));
    ASSERT_EQ("NOT_FOUND", Get("foobarbar"));
    ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 3);
    ASSERT_EQ(
        3,
        (*(get_perf_context()->level_to_perf_context))[0].bloom_filter_useful);
-#endif  // ROCKSDB_LITE

    // No bloom on extractor changed, after re-open
    options.prefix_extractor.reset(NewCappedPrefixTransform(10));
@@ -317,14 +315,12 @@ TEST_F(DBBloomFilterTest, GetFilterByPrefixBloom) {
        (*(get_perf_context()->level_to_perf_context))[0].bloom_filter_useful);

    // No bloom on extractor changed
-#ifndef ROCKSDB_LITE
    ASSERT_OK(db_->SetOptions({{"prefix_extractor", "capped:10"}}));
    ASSERT_EQ("NOT_FOUND", Get("foobarbar"));
    ASSERT_EQ(TestGetTickerCount(options, BLOOM_FILTER_USEFUL), 3);
    ASSERT_EQ(
        3,
        (*(get_perf_context()->level_to_perf_context))[0].bloom_filter_useful);
-#endif  // ROCKSDB_LITE

    get_perf_context()->Reset();
  }
@@ -564,7 +560,6 @@ TEST_P(DBBloomFilterTestWithParam, BloomFilter) {
      ASSERT_LE(reads, 3 * N / 100);
    }

-#ifndef ROCKSDB_LITE
    // Sanity check some table properties
    std::map<std::string, std::string> props;
    ASSERT_TRUE(db_->GetMapProperty(
@@ -583,7 +578,6 @@ TEST_P(DBBloomFilterTestWithParam, BloomFilter) {

    uint64_t num_filter_entries = ParseUint64(props["num_filter_entries"]);
    EXPECT_EQ(num_filter_entries, nkeys);
-#endif  // ROCKSDB_LITE

    env_->delay_sstable_sync_.store(false, std::memory_order_release);
    Close();
@@ -622,7 +616,7 @@ class AlwaysTrueFilterPolicy : public ReadOnlyBuiltinFilterPolicy {
  bool skip_;
 };

-}  // namespace
+}  // anonymous namespace

 TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
  constexpr int maxKey = 10;
@@ -649,10 +643,8 @@ TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
    PutFn();
    GetFn();
  };
-#ifndef ROCKSDB_LITE
  std::map<std::string, std::string> props;
  const auto& kAggTableProps = DB::Properties::kAggregatedTableProperties;
-#endif  // ROCKSDB_LITE

  Options options = CurrentOptions();
  options.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
@@ -675,11 +667,9 @@ TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_POSITIVE), 0);
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_TRUE_POSITIVE), 0);

-#ifndef ROCKSDB_LITE
  props.clear();
  ASSERT_TRUE(db_->GetMapProperty(kAggTableProps, &props));
  EXPECT_EQ(props["filter_size"], "0");
-#endif  // ROCKSDB_LITE

  // Test 2: use custom API to skip filters -> no filter constructed
  // or read.
@@ -693,11 +683,9 @@ TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_POSITIVE), 0);
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_TRUE_POSITIVE), 0);

-#ifndef ROCKSDB_LITE
  props.clear();
  ASSERT_TRUE(db_->GetMapProperty(kAggTableProps, &props));
  EXPECT_EQ(props["filter_size"], "0");
-#endif  // ROCKSDB_LITE

  // Control test: using an actual filter with 100% FP rate -> the filter
  // is constructed and checked on read.
@@ -713,11 +701,9 @@ TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
  EXPECT_EQ(
      TestGetAndResetTickerCount(options, BLOOM_FILTER_FULL_TRUE_POSITIVE),
      maxKey);
-#ifndef ROCKSDB_LITE
  props.clear();
  ASSERT_TRUE(db_->GetMapProperty(kAggTableProps, &props));
  EXPECT_NE(props["filter_size"], "0");
-#endif  // ROCKSDB_LITE

  // Test 3 (options test): Able to read existing filters with longstanding
  // generated options file entry `filter_policy=rocksdb.BuiltinBloomFilter`
@@ -743,11 +729,9 @@ TEST_P(DBBloomFilterTestWithParam, SkipFilterOnEssentiallyZeroBpk) {
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_POSITIVE), 0);
  EXPECT_EQ(TestGetTickerCount(options, BLOOM_FILTER_FULL_TRUE_POSITIVE), 0);

-#ifndef ROCKSDB_LITE
  props.clear();
  ASSERT_TRUE(db_->GetMapProperty(kAggTableProps, &props));
  EXPECT_EQ(props["filter_size"], "0");
-#endif  // ROCKSDB_LITE
 }

 #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
@@ -767,10 +751,10 @@ INSTANTIATE_TEST_CASE_P(

 INSTANTIATE_TEST_CASE_P(
    FormatLatest, DBBloomFilterTestWithParam,
-    ::testing::Values(
-        std::make_tuple(kAutoBloom, true, kLatestFormatVersion),
-        std::make_tuple(kAutoBloom, false, kLatestFormatVersion),
-        std::make_tuple(kAutoRibbon, false, kLatestFormatVersion)));
+    ::testing::Values(std::make_tuple(kAutoBloom, true, kLatestFormatVersion),
+                      std::make_tuple(kAutoBloom, false, kLatestFormatVersion),
+                      std::make_tuple(kAutoRibbon, false,
+                                      kLatestFormatVersion)));
 #endif  // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)

 TEST_F(DBBloomFilterTest, BloomFilterRate) {
@@ -840,7 +824,7 @@ std::vector<CompatibilityConfig> kCompatibilityConfigs = {
     BlockBasedTableOptions().format_version},
    {kCompatibilityRibbonPolicy, true, BlockBasedTableOptions().format_version},
 };
-}  // namespace
+}  // anonymous namespace

 TEST_F(DBBloomFilterTest, BloomFilterCompatibility) {
  Options options = CurrentOptions();
@@ -1229,7 +1213,7 @@ TEST_P(ChargeFilterConstructionTestWithParam, Basic) {
     *
     *  The test is designed in a way such that the reservation for (p1 - b')
     *  will trigger at least another dummy entry insertion
-     *  (or equivelantly to saying, creating another peak).
+     *  (or equivalently to saying, creating another peak).
     *
     * kStandard128Ribbon + FullFilter +
     * detect_filter_construct_corruption
@@ -1503,7 +1487,6 @@ TEST_P(DBFilterConstructionCorruptionTestWithParam, DetectCorruption) {
 }

 // RocksDB lite does not support dynamic options
-#ifndef ROCKSDB_LITE
 TEST_P(DBFilterConstructionCorruptionTestWithParam,
       DynamicallyTurnOnAndOffDetectConstructCorruption) {
  Options options = CurrentOptions();
@@ -1587,7 +1570,6 @@ TEST_P(DBFilterConstructionCorruptionTestWithParam,
      db_->GetOptions().table_factory->GetOptions<BlockBasedTableOptions>();
  EXPECT_FALSE(updated_table_options->detect_filter_construct_corruption);
 }
-#endif  // ROCKSDB_LITE

 namespace {
 // NOTE: This class is referenced by HISTORY.md as a model for a wrapper
@@ -1678,7 +1660,7 @@ class TestingContextCustomFilterPolicy
 private:
  mutable std::string test_report_;
 };
-}  // namespace
+}  // anonymous namespace

 TEST_F(DBBloomFilterTest, ContextCustomFilterPolicy) {
  auto policy = std::make_shared<TestingContextCustomFilterPolicy>(15, 8, 5);
@@ -1756,7 +1738,6 @@ TEST_F(DBBloomFilterTest, ContextCustomFilterPolicy) {
        EXPECT_LE(useful_count, maxKey * 0.91);
      }
    } else {
-#ifndef ROCKSDB_LITE
      // Also try external SST file
      {
        std::string file_path = dbname_ + "/external.sst";
@@ -1768,7 +1749,6 @@ TEST_F(DBBloomFilterTest, ContextCustomFilterPolicy) {
      // Note: kCompactionStyleLevel is default, ignored if num_levels == -1
      EXPECT_EQ(policy->DumpTestReport(),
                "cf=abe,s=kCompactionStyleLevel,n=-1,l=-1,b=0,r=kMisc\n");
-#endif
    }

    // Destroy
@@ -2036,9 +2016,7 @@ TEST_P(DBBloomFilterTestVaryPrefixAndFormatVer, PartitionedMultiGet) {
    ASSERT_OK(Put(UKey(i), UKey(i)));
  }
  ASSERT_OK(Flush());
-#ifndef ROCKSDB_LITE
  ASSERT_EQ(TotalTableFiles(), 1);
-#endif

  constexpr uint32_t Q = 29;
  // MultiGet In
@@ -2186,16 +2164,13 @@ INSTANTIATE_TEST_CASE_P(DBBloomFilterTestVaryPrefixAndFormatVer,
                            std::make_tuple(false, 2),
                            std::make_tuple(false, 3),
                            std::make_tuple(false, 4),
-                            std::make_tuple(false, 5),
-                            std::make_tuple(true, 2),
-                            std::make_tuple(true, 3),
-                            std::make_tuple(true, 4),
+                            std::make_tuple(false, 5), std::make_tuple(true, 2),
+                            std::make_tuple(true, 3), std::make_tuple(true, 4),
                            std::make_tuple(true, 5)));

-#ifndef ROCKSDB_LITE
 namespace {
 static const std::string kPlainTable = "test_PlainTableBloom";
-}  // namespace
+}  // anonymous namespace

 class BloomStatsTestWithParam
    : public DBBloomFilterTest,
@@ -2408,7 +2383,7 @@ void PrefixScanInit(DBBloomFilterTest* dbtest) {
    dbtest->Flush();
  }
 }
-}  // namespace
+}  // anonymous namespace

 TEST_F(DBBloomFilterTest, PrefixScan) {
  while (ChangeFilterOptions()) {
@@ -2620,8 +2595,7 @@ TEST_F(DBBloomFilterTest, OptimizeFiltersForHits) {
      BottommostLevelCompaction::kSkip;
  compact_options.change_level = true;
  compact_options.target_level = 7;
-  ASSERT_TRUE(db_->CompactRange(compact_options, handles_[1], nullptr, nullptr)
-                  .IsNotSupported());
+  ASSERT_OK(db_->CompactRange(compact_options, handles_[1], nullptr, nullptr));

  ASSERT_EQ(trivial_move, 1);
  ASSERT_EQ(non_trivial_move, 0);
@@ -3169,7 +3143,7 @@ std::pair<uint64_t, uint64_t> CheckedAndUseful(uint64_t checked,
                                               uint64_t useful) {
  return {checked, useful};
 }
-}  // namespace
+}  // anonymous namespace

 // This uses a prefix_extractor + comparator combination that violates
 // one of the old obsolete, unnecessary axioms of prefix extraction:
@@ -3377,7 +3351,7 @@ class NonIdempotentFixed4Transform : public SliceTransform {

  bool InDomain(const Slice& src) const override { return src.size() >= 5; }
 };
-}  // namespace
+}  // anonymous namespace

 // This uses a prefix_extractor + comparator combination that violates
 // two of the old obsolete, unnecessary axioms of prefix extraction:
@@ -3489,7 +3463,6 @@ TEST_F(DBBloomFilterTest, WeirdPrefixExtractorWithFilter3) {
  }
 }

-#endif  // ROCKSDB_LITE

 }  // namespace ROCKSDB_NAMESPACE

@@ -285,7 +285,6 @@ class ChangeFilterFactory : public CompactionFilterFactory {
  const char* Name() const override { return "ChangeFilterFactory"; }
 };

-#ifndef ROCKSDB_LITE
 TEST_F(DBTestCompactionFilter, CompactionFilter) {
  Options options = CurrentOptions();
  options.max_open_files = -1;
@@ -469,7 +468,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterDeletesAll) {

  delete itr;
 }
-#endif  // ROCKSDB_LITE

 TEST_F(DBTestCompactionFilter, CompactionFilterFlush) {
  // Tests a `CompactionFilterFactory` that filters when table file is created
@@ -655,7 +653,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterWithMergeOperator) {
  ASSERT_EQ(newvalue, four);
 }

-#ifndef ROCKSDB_LITE
 TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
  KeepFilterFactory* filter = new KeepFilterFactory(true, true);

@@ -715,7 +712,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextManual) {
    ASSERT_EQ(count, 0);
  }
 }
-#endif  // ROCKSDB_LITE

 TEST_F(DBTestCompactionFilter, CompactionFilterContextCfId) {
  KeepFilterFactory* filter = new KeepFilterFactory(false, true);
@@ -746,7 +742,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterContextCfId) {
  ASSERT_TRUE(filter->compaction_filter_created());
 }

-#ifndef ROCKSDB_LITE
 // Compaction filters aplies to all records, regardless snapshots.
 TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
  std::string five = std::to_string(5);
@@ -807,7 +802,6 @@ TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
  // removed.
  db_->ReleaseSnapshot(snapshot);
 }
-#endif  // ROCKSDB_LITE

 TEST_F(DBTestCompactionFilter, SkipUntil) {
  Options options = CurrentOptions();
@@ -10,7 +10,6 @@
 // Introduction of SyncPoint effectively disabled building and running this test
 // in Release build.
 // which is a pity, it is a good test
-#if !defined(ROCKSDB_LITE)

 #include "db/db_test_util.h"
 #include "port/port.h"
@@ -492,16 +491,9 @@ TEST_F(DBTestDynamicLevel, DISABLED_MigrateToDynamicLevelMaxBytesBase) {
 }
 }  // namespace ROCKSDB_NAMESPACE

-#endif  // !defined(ROCKSDB_LITE)

 int main(int argc, char** argv) {
-#if !defined(ROCKSDB_LITE)
  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
-#else
-  (void) argc;
-  (void) argv;
-  return 0;
-#endif
 }
@@ -6,9 +6,7 @@
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
-#if !defined(ROCKSDB_LITE)
 #include "test_util/sync_point.h"
-#endif
 #include <iostream>
 #include <string>

@@ -27,7 +25,6 @@ class DBEncryptionTest : public DBTestBase {
  }
 };

-#ifndef ROCKSDB_LITE

 TEST_F(DBEncryptionTest, CheckEncrypted) {
  ASSERT_OK(Put("foo567", "v1.fetdq"));
@@ -43,7 +40,7 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {

  Env* target = GetTargetEnv();
  int hits = 0;
-  for (auto it = fileNames.begin() ; it != fileNames.end(); ++it) {
+  for (auto it = fileNames.begin(); it != fileNames.end(); ++it) {
    if (*it == "LOCK") {
      continue;
    }
@@ -64,24 +61,24 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
    ASSERT_OK(status);

    if (data.ToString().find("foo567") != std::string::npos) {
-      hits++; 
-      //std::cout << "Hit in " << filePath << "\n";
+      hits++;
+      // std::cout << "Hit in " << filePath << "\n";
    }
    if (data.ToString().find("v1.fetdq") != std::string::npos) {
-      hits++; 
-      //std::cout << "Hit in " << filePath << "\n";
+      hits++;
+      // std::cout << "Hit in " << filePath << "\n";
    }
    if (data.ToString().find("bar123") != std::string::npos) {
-      hits++; 
-      //std::cout << "Hit in " << filePath << "\n";
+      hits++;
+      // std::cout << "Hit in " << filePath << "\n";
    }
    if (data.ToString().find("v2.dfgkjdfghsd") != std::string::npos) {
-      hits++; 
-      //std::cout << "Hit in " << filePath << "\n";
+      hits++;
+      // std::cout << "Hit in " << filePath << "\n";
    }
    if (data.ToString().find("dfgk") != std::string::npos) {
-      hits++; 
-      //std::cout << "Hit in " << filePath << "\n";
+      hits++;
+      // std::cout << "Hit in " << filePath << "\n";
    }
  }
  if (encrypted_env_) {
@@ -119,7 +116,6 @@ TEST_F(DBEncryptionTest, ReadEmptyFile) {
  ASSERT_TRUE(data.empty());
 }

-#endif // ROCKSDB_LITE

 }  // namespace ROCKSDB_NAMESPACE

@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //

-#ifndef ROCKSDB_LITE

 #include <algorithm>
 #include <cstdint>
@@ -65,8 +64,7 @@ Status DBImpl::FlushForGetLiveFiles() {
 }

 Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
-                            uint64_t* manifest_file_size,
-                            bool flush_memtable) {
+                            uint64_t* manifest_file_size, bool flush_memtable) {
  *manifest_file_size = 0;

  mutex_.Lock();
@@ -440,4 +438,3 @@ Status DBImpl::GetLiveFilesStorageInfo(

 }  // namespace ROCKSDB_NAMESPACE

-#endif  // ROCKSDB_LITE