Improve comments on options.writable_file_max_buffer_size

Comments of options.writable_file_max_buffer_size mentioned Windows, which is confusing. Remove it.

.circleci/cat_ignore_eagain

@@ -0,0 +1,54 @@
+#! /bin/bash
+
+# Work around issue with parallel make output causing random error, as in
+# make[1]: write error: stdout
+# Probably due to a kernel bug:
+#   https://bugs.launchpad.net/ubuntu/+source/linux-signed/+bug/1814393
+# Seems to affect image ubuntu-1604:201903-01 and ubuntu-1604:202004-01
+
+cd "$(dirname $0)"
+
+if [ ! -x cat_ignore_eagain.out ]; then
+    cc -x c -o cat_ignore_eagain.out - << EOF
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+int main() {
+    int n, m, p;
+    char buf[1024];
+    for (;;) {
+        n = read(STDIN_FILENO, buf, 1024);
+        if (n > 0 && n <= 1024) {
+            for (m = 0; m < n;) {
+                p = write(STDOUT_FILENO, buf + m, n - m);
+                if (p < 0) {
+                    if (errno == EAGAIN) {
+                        // ignore but pause a bit
+                        usleep(100);
+                    } else {
+                        perror("write failed");
+                        return 42;
+                    }
+                } else {
+                    m += p;
+                }
+            }
+        } else if (n < 0) {
+            if (errno == EAGAIN) {
+                // ignore but pause a bit
+                usleep(100);
+            } else {
+                // Some non-ignorable error
+                perror("read failed");
+                return 43;
+            }
+        } else {
+            // EOF
+            return 0;
+        }
+    }
+}
+EOF
+fi
+
+exec ./cat_ignore_eagain.out

.circleci/vs2015_install.ps1

@@ -0,0 +1,24 @@
+$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."

.circleci/vs2017_install.ps1

@@ -0,0 +1,35 @@
+$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."

.github/workflows/sanity_check.yml

@@ -1,8 +1,5 @@
 name: Check buck targets and code format
 on: [push, pull_request]
-permissions:
-  contents: read
-
 jobs:
   check:
     name: Check TARGETS file and code format
@@ -35,7 +32,7 @@ jobs:
     - name: Download clang-format-diff.py
       uses: wei/wget@v1
       with:
-        args: https://raw.githubusercontent.com/llvm/llvm-project/release/12.x/clang/tools/clang-format/clang-format-diff.py
+        args: https://raw.githubusercontent.com/llvm/llvm-project/main/clang/tools/clang-format/clang-format-diff.py
 
     - name: Check format
       run: VERBOSE_CHECK=1 make check-format

.gitignore

@@ -36,6 +36,7 @@ manifest_dump
 sst_dump
 blob_dump
 block_cache_trace_analyzer
+db_with_timestamp_basic_test
 tools/block_cache_analyzer/*.pyc
 column_aware_encoding_exp
 util/build_version.cc
@@ -51,12 +52,12 @@ rocksdb_dump
 rocksdb_undump
 db_test2
 trace_analyzer
+trace_analyzer_test
 block_cache_trace_analyzer
 io_tracer_parser
 .DS_Store
 .vs
 .vscode
-.clangd
 
 java/out
 java/target
@@ -94,4 +95,3 @@ fuzz/proto/gen/
 fuzz/crash-*
 
 cmake-build-*
-third-party/folly/

.travis.yml

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

CMakeLists.txt

@@ -2,7 +2,7 @@
 #     This cmake build is for Windows 64-bit only.
 #
 # Prerequisites:
-#     You must have at least Visual Studio 2019. Start the Developer Command Prompt window that is a part of Visual Studio installation.
+#     You must have at least Visual Studio 2015 Update 3. Start the Developer Command Prompt window that is a part of Visual Studio installation.
 #     Run the build commands from within the Developer Command Prompt window to have paths to the compiler and runtime libraries set.
 #     You must have git.exe in your %PATH% environment variable.
 #
@@ -14,7 +14,7 @@
 #        cd build
 # 3. Run cmake to generate project files for Windows, add more options to enable required third-party libraries.
 #    See thirdparty.inc for more information.
-#        sample command: cmake -G "Visual Studio 16 2019" -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=1 -DWITH_SNAPPY=1 -DWITH_JEMALLOC=1 -DWITH_JNI=1 ..
+#        sample command: cmake -G "Visual Studio 15 Win64" -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=1 -DWITH_SNAPPY=1 -DWITH_JEMALLOC=1 -DWITH_JNI=1 ..
 # 4. Then build the project in debug mode (you may want to add /m[:<N>] flag to run msbuild in <N> parallel threads
 #                                          or simply /m to use all avail cores)
 #        msbuild rocksdb.sln
@@ -27,7 +27,7 @@
 #
 # Linux:
 #
-# 1. Install a recent toolchain if you're on a older distro. C++17 required (GCC >= 7, Clang >= 5)
+# 1. Install a recent toolchain such as devtoolset-3 if you're on a older distro. C++11 required.
 # 2. mkdir build; cd build
 # 3. cmake ..
 # 4. make -j
@@ -40,8 +40,6 @@ include(GoogleTest)
 get_rocksdb_version(rocksdb_VERSION)
 project(rocksdb
   VERSION ${rocksdb_VERSION}
-  DESCRIPTION "An embeddable persistent key-value store for fast storage"
-  HOMEPAGE_URL https://rocksdb.org/
   LANGUAGES CXX C ASM)
 
 if(POLICY CMP0042)
@@ -74,15 +72,27 @@ option(WITH_WINDOWS_UTF8_FILENAMES "use UTF8 as characterset for opening files,
 if (WITH_WINDOWS_UTF8_FILENAMES)
   add_definitions(-DROCKSDB_WINDOWS_UTF8_FILENAMES)
 endif()
-option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
 
 if ($ENV{CIRCLECI})
   message(STATUS "Build for CircieCI env, a few tests may be disabled")
   add_definitions(-DCIRCLECI)
 endif()
 
+# third-party/folly is only validated to work on Linux and Windows for now.
+# So only turn it on there by default.
+if(CMAKE_SYSTEM_NAME MATCHES "Linux|Windows")
+  if(MSVC AND MSVC_VERSION LESS 1910)
+    # Folly does not compile with MSVC older than VS2017
+    option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" OFF)
+  else()
+    option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" ON)
+  endif()
+else()
+  option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" OFF)
+endif()
+
 if( NOT DEFINED CMAKE_CXX_STANDARD )
-  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 11)
 endif()
 
 include(CMakeDependentOption)
@@ -90,11 +100,7 @@ include(CMakeDependentOption)
 if(MSVC)
   option(WITH_GFLAGS "build with GFlags" OFF)
   option(WITH_XPRESS "build with windows built in compression" OFF)
-  option(ROCKSDB_SKIP_THIRDPARTY "skip thirdparty.inc" OFF)
-
-  if(NOT ROCKSDB_SKIP_THIRDPARTY)
-    include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
-  endif()
+  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
 else()
   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND NOT CMAKE_SYSTEM_NAME MATCHES "kFreeBSD")
     # FreeBSD has jemalloc as default malloc
@@ -176,6 +182,26 @@ else()
   endif()
 endif()
 
+string(TIMESTAMP TS "%Y-%m-%d %H:%M:%S" UTC)
+set(BUILD_DATE "${TS}" CACHE STRING "the time we first built rocksdb")
+
+find_package(Git)
+
+if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
+  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_SHA COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD )
+  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" RESULT_VARIABLE GIT_MOD COMMAND "${GIT_EXECUTABLE}" diff-index HEAD --quiet)
+  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_DATE COMMAND "${GIT_EXECUTABLE}" log -1 --date=format:"%Y-%m-%d %T" --format="%ad")
+  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_TAG RESULT_VARIABLE rv COMMAND "${GIT_EXECUTABLE}" symbolic-ref -q --short HEAD OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if (rv AND NOT rv EQUAL 0)
+    execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_TAG COMMAND "${GIT_EXECUTABLE}" describe --tags --exact-match OUTPUT_STRIP_TRAILING_WHITESPACE)
+  endif()
+else()
+  set(GIT_SHA 0)
+  set(GIT_MOD 1)
+endif()
+string(REGEX REPLACE "[^0-9a-fA-F]+" "" GIT_SHA "${GIT_SHA}")
+string(REGEX REPLACE "[^0-9: /-]+" "" GIT_DATE "${GIT_DATE}")
+
 option(WITH_MD_LIBRARY "build with MD" ON)
 if(WIN32 AND MSVC)
   if(WITH_MD_LIBRARY)
@@ -185,17 +211,20 @@ if(WIN32 AND MSVC)
   endif()
 endif()
 
+set(BUILD_VERSION_CC ${CMAKE_BINARY_DIR}/build_version.cc)
+configure_file(util/build_version.cc.in ${BUILD_VERSION_CC} @ONLY)
+
 if(MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4800 /wd4996 /wd4351 /wd4100 /wd4204 /wd4324")
 else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall -pthread")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing -Wno-invalid-offsetof")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing")
   if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
   endif()
   if(MINGW)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format -fno-asynchronous-unwind-tables")
     add_definitions(-D_POSIX_C_SOURCE=1)
   endif()
   if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -245,21 +274,11 @@ 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)
@@ -283,9 +302,6 @@ 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)
@@ -326,7 +342,7 @@ endif()
 
 # Check if -latomic is required or not
 if (NOT MSVC)
-  set(CMAKE_REQUIRED_FLAGS "--std=c++17")
+  set(CMAKE_REQUIRED_FLAGS "--std=c++11")
   CHECK_CXX_SOURCE_COMPILES("
 #include <atomic>
 std::atomic<uint64_t> x(0);
@@ -336,23 +352,44 @@ int main() {
   return 0;
 }
 " BUILTIN_ATOMIC)
-  if (NOT BUILTIN_ATOMIC)
-    #TODO: Check if -latomic exists
-    list(APPEND THIRDPARTY_LIBS atomic)
-  endif()
+if (NOT BUILTIN_ATOMIC)
+  #TODO: Check if -latomic exists
+  list(APPEND THIRDPARTY_LIBS atomic)
+endif()
 endif()
 
 if (WITH_LIBURING)
-  find_package(uring)
-  if (uring_FOUND)
+  set(CMAKE_REQUIRED_FLAGS "-luring")
+  CHECK_CXX_SOURCE_COMPILES("
+#include <liburing.h>
+int main() {
+  struct io_uring ring;
+  io_uring_queue_init(1, &ring, 0);
+  return 0;
+}
+" HAS_LIBURING)
+  if (HAS_LIBURING)
     add_definitions(-DROCKSDB_IOURING_PRESENT)
-    list(APPEND THIRDPARTY_LIBS uring::uring)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -luring")
   endif()
 endif()
 
 # Reset the required flags
 set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
 
+CHECK_CXX_SOURCE_COMPILES("
+#if defined(_MSC_VER) && !defined(__thread)
+#define __thread __declspec(thread)
+#endif
+int main() {
+  static __thread int tls;
+  (void)tls;
+}
+" HAVE_THREAD_LOCAL)
+if(HAVE_THREAD_LOCAL)
+  add_definitions(-DROCKSDB_SUPPORT_THREAD_LOCAL)
+endif()
+
 option(WITH_IOSTATS_CONTEXT "Enable IO stats context" ON)
 if (NOT WITH_IOSTATS_CONTEXT)
   add_definitions(-DNIOSTATS_CONTEXT)
@@ -384,7 +421,7 @@ endif()
 
 option(WITH_TSAN "build with TSAN" OFF)
 if(WITH_TSAN)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread -Wl,-pie")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread -pie")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread -fPIC")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread -fPIC")
   if(WITH_JEMALLOC)
@@ -435,32 +472,30 @@ if (ASSERT_STATUS_CHECKED)
   add_definitions(-DROCKSDB_ASSERT_STATUS_CHECKED)
 endif()
 
-
-# RTTI is by default AUTO which enables it in debug and disables it in release.
-set(USE_RTTI AUTO CACHE STRING "Enable RTTI in builds")
-set_property(CACHE USE_RTTI PROPERTY STRINGS AUTO ON OFF)
-if(USE_RTTI STREQUAL "AUTO")
+if(DEFINED USE_RTTI)
+  if(USE_RTTI)
+    message(STATUS "Enabling RTTI")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DROCKSDB_USE_RTTI")
+  else()
+    if(MSVC)
+      message(STATUS "Disabling RTTI in Release builds. Always on in Debug.")
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
+    else()
+      message(STATUS "Disabling RTTI in Release builds")
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-rtti")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
+    endif()
+  endif()
+else()
   message(STATUS "Enabling RTTI in Debug builds only (default)")
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
   if(MSVC)
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
+     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
   else()
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
   endif()
-elseif(USE_RTTI)
-  message(STATUS "Enabling RTTI in all builds")
-  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DROCKSDB_USE_RTTI")
-else()
-  if(MSVC)
-    message(STATUS "Disabling RTTI in Release builds. Always on in Debug.")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
-  else()
-    message(STATUS "Disabling RTTI in all builds")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-rtti")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
-  endif()
 endif()
 
 # Used to run CI build and tests so we can run faster
@@ -496,6 +531,12 @@ 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")
@@ -583,68 +624,10 @@ if(HAVE_AUXV_GETAUXVAL)
   add_definitions(-DROCKSDB_AUXV_GETAUXVAL_PRESENT)
 endif()
 
-check_cxx_symbol_exists(F_FULLFSYNC "fcntl.h" HAVE_FULLFSYNC)
-if(HAVE_FULLFSYNC)
-  add_definitions(-DHAVE_FULLFSYNC)
-endif()
-
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
-
-if(USE_COROUTINES)
-  if(USE_FOLLY OR USE_FOLLY_LITE)
-    message(FATAL_ERROR "Please specify exactly one of USE_COROUTINES,"
-    " USE_FOLLY, and USE_FOLLY_LITE")
-  endif()
-  set(CMAKE_CXX_STANDARD 20)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcoroutines -Wno-maybe-uninitialized")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-redundant-move")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-invalid-memory-model")
-  add_compile_definitions(USE_COROUTINES)
-  set(USE_FOLLY 1)
-endif()
-
-if(USE_FOLLY)
-  if(USE_FOLLY_LITE)
-    message(FATAL_ERROR "Please specify one of USE_FOLLY or USE_FOLLY_LITE")
-  endif()
-  if(ROCKSDB_BUILD_SHARED)
-    message(FATAL_ERROR "Cannot build RocksDB shared library with folly")
-  endif()
-  set(ROCKSDB_BUILD_SHARED OFF)
-  set(GFLAGS_SHARED FALSE)
-  find_package(folly)
-  # If cmake could not find the folly-config.cmake file, fall back
-  # to looking in third-party/folly for folly and its dependencies
-  if(NOT FOLLY_LIBRARIES)
-    exec_program(python3 ${PROJECT_SOURCE_DIR}/third-party/folly ARGS
-    build/fbcode_builder/getdeps.py show-inst-dir OUTPUT_VARIABLE
-    FOLLY_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../boost* OUTPUT_VARIABLE
-    BOOST_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../fmt* OUTPUT_VARIABLE
-    FMT_INST_PATH)
-    exec_program(ls ARGS -d ${FOLLY_INST_PATH}/../gflags* OUTPUT_VARIABLE
-    GFLAGS_INST_PATH)
-    set(Boost_DIR ${BOOST_INST_PATH}/lib/cmake/Boost-1.78.0)
-    if(EXISTS ${FMT_INST_PATH}/lib64)
-      set(fmt_DIR ${FMT_INST_PATH}/lib64/cmake/fmt)
-    else()
-      set(fmt_DIR ${FMT_INST_PATH}/lib/cmake/fmt)
-    endif()
-    set(gflags_DIR ${GFLAGS_INST_PATH}/lib/cmake/gflags)
-
-    exec_program(sed ARGS -i 's/gflags_shared//g'
-    ${FOLLY_INST_PATH}/lib/cmake/folly/folly-targets.cmake)
-
-    include(${FOLLY_INST_PATH}/lib/cmake/folly/folly-config.cmake)
-  endif()
-
-  add_compile_definitions(USE_FOLLY FOLLY_NO_CONFIG HAVE_CXX11_ATOMIC)
-  list(APPEND THIRDPARTY_LIBS Folly::folly)
-  set(FOLLY_LIBS Folly::folly)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--copy-dt-needed-entries")
+if(WITH_FOLLY_DISTRIBUTED_MUTEX)
+  include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
 endif()
 find_package(Threads REQUIRED)
 
@@ -653,17 +636,11 @@ find_package(Threads REQUIRED)
 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/lru_cache.cc
-        cache/secondary_cache.cc
         cache/sharded_cache.cc
         db/arena_wrapped_db_iter.cc
-        db/blob/blob_contents.cc
         db/blob/blob_fetcher.cc
         db/blob/blob_file_addition.cc
         db/blob/blob_file_builder.cc
@@ -675,8 +652,6 @@ set(SOURCES
         db/blob/blob_log_format.cc
         db/blob/blob_log_sequential_reader.cc
         db/blob/blob_log_writer.cc
-        db/blob/blob_source.cc
-        db/blob/prefetch_buffer_collection.cc
         db/builder.cc
         db/c.cc
         db/column_family.cc
@@ -687,11 +662,7 @@ set(SOURCES
         db/compaction/compaction_picker_fifo.cc
         db/compaction/compaction_picker_level.cc
         db/compaction/compaction_picker_universal.cc
-        db/compaction/compaction_service_job.cc
-        db/compaction/compaction_state.cc
-        db/compaction/compaction_outputs.cc
         db/compaction/sst_partitioner.cc
-        db/compaction/subcompaction_state.cc
         db/convenience.cc
         db/db_filesnapshot.cc
         db/db_impl/compacted_db_impl.cc
@@ -726,11 +697,10 @@ set(SOURCES
         db/merge_helper.cc
         db/merge_operator.cc
         db/output_validator.cc
-        db/periodic_task_scheduler.cc
+        db/periodic_work_scheduler.cc
         db/range_del_aggregator.cc
         db/range_tombstone_fragmenter.cc
         db/repair.cc
-        db/seqno_to_time_mapping.cc
         db/snapshot_impl.cc
         db/table_cache.cc
         db/table_properties_collector.cc
@@ -742,8 +712,6 @@ set(SOURCES
         db/version_set.cc
         db/wal_edit.cc
         db/wal_manager.cc
-        db/wide/wide_column_serialization.cc
-        db/wide/wide_columns.cc
         db/write_batch.cc
         db/write_batch_base.cc
         db/write_controller.cc
@@ -752,6 +720,7 @@ set(SOURCES
         env/env.cc
         env/env_chroot.cc
         env/env_encryption.cc
+        env/env_hdfs.cc
         env/file_system.cc
         env/file_system_tracer.cc
         env/fs_remap.cc
@@ -775,7 +744,6 @@ set(SOURCES
         memory/concurrent_arena.cc
         memory/jemalloc_nodump_allocator.cc
         memory/memkind_kmem_allocator.cc
-        memory/memory_allocator.cc
         memtable/alloc_tracker.cc
         memtable/hash_linklist_rep.cc
         memtable/hash_skiplist_rep.cc
@@ -802,17 +770,16 @@ 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
         table/block_based/block.cc
+        table/block_based/block_based_filter_block.cc
         table/block_based/block_based_table_builder.cc
         table/block_based/block_based_table_factory.cc
         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
@@ -870,12 +837,9 @@ set(SOURCES
         trace_replay/trace_record_result.cc
         trace_replay/trace_record.cc
         trace_replay/trace_replay.cc
-        util/async_file_reader.cc
-        util/cleanable.cc
         util/coding.cc
         util/compaction_job_stats_impl.cc
         util/comparator.cc
-        util/compression.cc
         util/compression_context_cache.cc
         util/concurrent_task_limiter_impl.cc
         util/crc32c.cc
@@ -885,16 +849,15 @@ set(SOURCES
         util/random.cc
         util/rate_limiter.cc
         util/ribbon_config.cc
+        util/regex.cc
         util/slice.cc
         util/file_checksum_helper.cc
         util/status.cc
-        util/stderr_logger.cc
         util/string_util.cc
         util/thread_local.cc
         util/threadpool_imp.cc
         util/xxhash.cc
-        utilities/agg_merge/agg_merge.cc
-        utilities/backup/backup_engine.cc
+        utilities/backupable/backupable_db.cc
         utilities/blob_db/blob_compaction_filter.cc
         utilities/blob_db/blob_db.cc
         utilities/blob_db/blob_db_impl.cc
@@ -909,13 +872,11 @@ set(SOURCES
         utilities/checkpoint/checkpoint_impl.cc
         utilities/compaction_filters.cc
         utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc
-        utilities/counted_fs.cc
         utilities/debug.cc
         utilities/env_mirror.cc
         utilities/env_timed.cc
         utilities/fault_injection_env.cc
         utilities/fault_injection_fs.cc
-        utilities/fault_injection_secondary_cache.cc
         utilities/leveldb_options/leveldb_options.cc
         utilities/memory/memory_util.cc
         utilities/merge_operators.cc
@@ -975,37 +936,6 @@ list(APPEND SOURCES
   utilities/transactions/lock/range/range_tree/lib/util/dbt.cc
   utilities/transactions/lock/range/range_tree/lib/util/memarena.cc)
 
-message(STATUS "ROCKSDB_PLUGINS: ${ROCKSDB_PLUGINS}")
-if ( ROCKSDB_PLUGINS )
-  string(REPLACE " " ";" PLUGINS ${ROCKSDB_PLUGINS})
-  foreach (plugin ${PLUGINS})
-    add_subdirectory("plugin/${plugin}")
-    foreach (src ${${plugin}_SOURCES})
-      list(APPEND SOURCES plugin/${plugin}/${src})
-      set_source_files_properties(
-        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()
-    foreach (lib ${${plugin}_LIBS})
-      list(APPEND THIRDPARTY_LIBS ${lib})
-    endforeach()
-    foreach (link_path ${${plugin}_LINK_PATHS})
-      link_directories(AFTER ${link_path})
-    endforeach()
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${${plugin}_CMAKE_SHARED_LINKER_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${${plugin}_CMAKE_EXE_LINKER_FLAGS}")
-  endforeach()
-endif()
-
 if(HAVE_SSE42 AND NOT MSVC)
   set_source_files_properties(
     util/crc32c.cc
@@ -1049,24 +979,26 @@ else()
     env/io_posix.cc)
 endif()
 
-if(USE_FOLLY_LITE)
+if(WITH_FOLLY_DISTRIBUTED_MUTEX)
   list(APPEND SOURCES
-    third-party/folly/folly/container/detail/F14Table.cpp
     third-party/folly/folly/detail/Futex.cpp
-    third-party/folly/folly/lang/SafeAssert.cpp
-    third-party/folly/folly/lang/ToAscii.cpp
-    third-party/folly/folly/ScopeGuard.cpp
     third-party/folly/folly/synchronization/AtomicNotification.cpp
     third-party/folly/folly/synchronization/DistributedMutex.cpp
-    third-party/folly/folly/synchronization/ParkingLot.cpp)
-  include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
-  add_definitions(-DUSE_FOLLY -DFOLLY_NO_CONFIG)
-  list(APPEND THIRDPARTY_LIBS glog)
+    third-party/folly/folly/synchronization/ParkingLot.cpp
+    third-party/folly/folly/synchronization/WaitOptions.cpp)
 endif()
 
 set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
 set(ROCKSDB_SHARED_LIB rocksdb-shared${ARTIFACT_SUFFIX})
 
+option(ROCKSDB_BUILD_SHARED "Build shared versions of the RocksDB libraries" ON)
+
+option(WITH_LIBRADOS "Build with librados" OFF)
+if(WITH_LIBRADOS)
+  list(APPEND SOURCES
+    utilities/env_librados.cc)
+  list(APPEND THIRDPARTY_LIBS rados)
+endif()
 
 if(WIN32)
   set(SYSTEM_LIBS ${SYSTEM_LIBS} shlwapi.lib rpcrt4.lib)
@@ -1074,65 +1006,6 @@ else()
   set(SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT})
 endif()
 
-set(ROCKSDB_PLUGIN_EXTERNS "")
-set(ROCKSDB_PLUGIN_BUILTINS "")
-message(STATUS "ROCKSDB PLUGINS TO BUILD ${ROCKSDB_PLUGINS}")
-foreach(PLUGIN IN LISTS PLUGINS)
-  set(PLUGIN_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/plugin/${PLUGIN}/")
-  message(STATUS "PLUGIN ${PLUGIN} including rocksb plugin ${PLUGIN_ROOT}")
-  set(PLUGINMKFILE "${PLUGIN_ROOT}${PLUGIN}.mk")
-  if (NOT EXISTS ${PLUGINMKFILE})
-    message(FATAL_ERROR "PLUGIN ${PLUGIN} Missing plugin makefile: ${PLUGINMKFILE}")
-  endif()
-  file(READ ${PLUGINMKFILE} PLUGINMK)
-
-  string(REGEX MATCH "SOURCES = ([^\n]*)" FOO ${PLUGINMK})
-  set(MK_SOURCES ${CMAKE_MATCH_1})
-  separate_arguments(MK_SOURCES)
-  foreach(MK_FILE IN LISTS MK_SOURCES)
-    list(APPEND SOURCES "${PLUGIN_ROOT}${MK_FILE}")
-    message(STATUS "PLUGIN ${PLUGIN} Appending ${PLUGIN_ROOT}${MK_FILE} to SOURCES")
-  endforeach()
-
-  string(REGEX MATCH "_FUNC = ([^\n]*)" FOO ${PLUGINMK})
-  if (NOT ${CMAKE_MATCH_1} STREQUAL "")
-    string(APPEND ROCKSDB_PLUGIN_BUILTINS "{\"${PLUGIN}\", " ${CMAKE_MATCH_1} "},")
-    string(APPEND ROCKSDB_PLUGIN_EXTERNS "int " ${CMAKE_MATCH_1} "(ROCKSDB_NAMESPACE::ObjectLibrary&, const std::string&); ")
-  endif()
-
-  string(REGEX MATCH "_LIBS = ([^\n]*)" FOO ${PLUGINMK})
-  separate_arguments(CMAKE_MATCH_1)
-  foreach(MK_LIB IN LISTS CMAKE_MATCH_1)
-    list(APPEND THIRDPARTY_LIBS "${MK_LIB}")
-  endforeach()
-  message(STATUS "PLUGIN ${PLUGIN} THIRDPARTY_LIBS=${THIRDPARTY_LIBS}")
-
-  #TODO: We need to set any compile/link-time flags and add any link libraries
-endforeach()
-
-string(TIMESTAMP TS "%Y-%m-%d %H:%M:%S" UTC)
-set(BUILD_DATE "${TS}" CACHE STRING "the time we first built rocksdb")
-
-find_package(Git)
-
-if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
-  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_SHA COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD )
-  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" RESULT_VARIABLE GIT_MOD COMMAND "${GIT_EXECUTABLE}" diff-index HEAD --quiet)
-  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_DATE COMMAND "${GIT_EXECUTABLE}" log -1 --date=format:"%Y-%m-%d %T" --format="%ad")
-  execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_TAG RESULT_VARIABLE rv COMMAND "${GIT_EXECUTABLE}" symbolic-ref -q --short HEAD OUTPUT_STRIP_TRAILING_WHITESPACE)
-  if (rv AND NOT rv EQUAL 0)
-    execute_process(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE GIT_TAG COMMAND "${GIT_EXECUTABLE}" describe --tags --exact-match OUTPUT_STRIP_TRAILING_WHITESPACE)
-  endif()
-else()
-  set(GIT_SHA 0)
-  set(GIT_MOD 1)
-endif()
-string(REGEX REPLACE "[^0-9a-fA-F]+" "" GIT_SHA "${GIT_SHA}")
-string(REGEX REPLACE "[^0-9: /-]+" "" GIT_DATE "${GIT_DATE}")
-
-set(BUILD_VERSION_CC ${CMAKE_BINARY_DIR}/build_version.cc)
-configure_file(util/build_version.cc.in ${BUILD_VERSION_CC} @ONLY)
-
 add_library(${ROCKSDB_STATIC_LIB} STATIC ${SOURCES} ${BUILD_VERSION_CC})
 target_link_libraries(${ROCKSDB_STATIC_LIB} PRIVATE
   ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
@@ -1212,20 +1085,8 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
     COMPATIBILITY SameMajorVersion
   )
 
-  configure_file(
-    ${PROJECT_NAME}.pc.in
-    ${PROJECT_NAME}.pc
-    @ONLY
-  )
-
   install(DIRECTORY include/rocksdb COMPONENT devel DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
 
-  foreach (plugin ${PLUGINS})
-    foreach (header ${${plugin}_HEADERS})
-      install(FILES plugin/${plugin}/${header} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/rocksdb/plugin/${plugin})
-    endforeach()
-  endforeach()
-
   install(DIRECTORY "${PROJECT_SOURCE_DIR}/cmake/modules" COMPONENT devel DESTINATION ${package_config_destination})
 
   install(
@@ -1262,13 +1123,6 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
     COMPONENT devel
     DESTINATION ${package_config_destination}
   )
-
-  install(
-    FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
-    COMPONENT devel
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
-  )
 endif()
 
 option(WITH_ALL_TESTS "Build all test, rather than a small subset" ON)
@@ -1290,7 +1144,6 @@ if(WITH_TESTS)
     list(APPEND TESTS
         cache/cache_reservation_manager_test.cc
         cache/cache_test.cc
-        cache/compressed_secondary_cache_test.cc
         cache/lru_cache_test.cc
         db/blob/blob_counting_iterator_test.cc
         db/blob/blob_file_addition_test.cc
@@ -1299,7 +1152,6 @@ if(WITH_TESTS)
         db/blob/blob_file_garbage_test.cc
         db/blob/blob_file_reader_test.cc
         db/blob/blob_garbage_meter_test.cc
-        db/blob/blob_source_test.cc
         db/blob/db_blob_basic_test.cc
         db/blob/db_blob_compaction_test.cc
         db/blob/db_blob_corruption_test.cc
@@ -1312,18 +1164,15 @@ if(WITH_TESTS)
         db/compaction/compaction_iterator_test.cc
         db/compaction/compaction_picker_test.cc
         db/compaction/compaction_service_test.cc
-        db/compaction/tiered_compaction_test.cc
         db/comparator_db_test.cc
         db/corruption_test.cc
         db/cuckoo_table_db_test.cc
-        db/db_readonly_with_timestamp_test.cc
         db/db_with_timestamp_basic_test.cc
         db/db_block_cache_test.cc
         db/db_bloom_filter_test.cc
         db/db_compaction_filter_test.cc
         db/db_compaction_test.cc
         db/db_dynamic_level_test.cc
-        db/db_encryption_test.cc
         db/db_flush_test.cc
         db/db_inplace_update_test.cc
         db/db_io_failure_test.cc
@@ -1338,7 +1187,6 @@ if(WITH_TESTS)
         db/db_options_test.cc
         db/db_properties_test.cc
         db/db_range_del_test.cc
-        db/db_rate_limiter_test.cc
         db/db_secondary_test.cc
         db/db_sst_test.cc
         db/db_statistics_test.cc
@@ -1350,7 +1198,6 @@ if(WITH_TESTS)
         db/db_universal_compaction_test.cc
         db/db_wal_test.cc
         db/db_with_timestamp_compaction_test.cc
-        db/db_write_buffer_manager_test.cc
         db/db_write_test.cc
         db/dbformat_test.cc
         db/deletefile_test.cc
@@ -1362,7 +1209,6 @@ if(WITH_TESTS)
         db/file_indexer_test.cc
         db/filename_test.cc
         db/flush_job_test.cc
-        db/import_column_family_test.cc
         db/listener_test.cc
         db/log_test.cc
         db/manual_compaction_test.cc
@@ -1371,9 +1217,8 @@ if(WITH_TESTS)
         db/merge_test.cc
         db/options_file_test.cc
         db/perf_context_test.cc
-        db/periodic_task_scheduler_test.cc
+        db/periodic_work_scheduler_test.cc
         db/plain_table_db_test.cc
-        db/seqno_time_test.cc
         db/prefix_test.cc
         db/range_del_aggregator_test.cc
         db/range_tombstone_fragmenter_test.cc
@@ -1384,8 +1229,6 @@ if(WITH_TESTS)
         db/version_set_test.cc
         db/wal_manager_test.cc
         db/wal_edit_test.cc
-        db/wide/db_wide_basic_test.cc
-        db/wide/wide_column_serialization_test.cc
         db/write_batch_test.cc
         db/write_callback_test.cc
         db/write_controller_test.cc
@@ -1399,7 +1242,7 @@ if(WITH_TESTS)
         logging/env_logger_test.cc
         logging/event_logger_test.cc
         memory/arena_test.cc
-        memory/memory_allocator_test.cc
+        memory/memkind_kmem_allocator_test.cc
         memtable/inlineskiplist_test.cc
         memtable/skiplist_test.cc
         memtable/write_buffer_manager_test.cc
@@ -1411,6 +1254,7 @@ if(WITH_TESTS)
         options/customizable_test.cc
         options/options_settable_test.cc
         options/options_test.cc
+        table/block_based/block_based_filter_block_test.cc
         table/block_based/block_based_table_reader_test.cc
         table/block_based/block_test.cc
         table/block_based/data_block_hash_index_test.cc
@@ -1453,15 +1297,13 @@ if(WITH_TESTS)
         util/thread_list_test.cc
         util/thread_local_test.cc
         util/work_queue_test.cc
-        utilities/agg_merge/agg_merge_test.cc
-        utilities/backup/backup_engine_test.cc
+        utilities/backupable/backupable_db_test.cc
         utilities/blob_db/blob_db_test.cc
         utilities/cassandra/cassandra_functional_test.cc
         utilities/cassandra/cassandra_format_test.cc
         utilities/cassandra/cassandra_row_merge_test.cc
         utilities/cassandra/cassandra_serialize_test.cc
         utilities/checkpoint/checkpoint_test.cc
-        utilities/env_timed_test.cc
         utilities/memory/memory_test.cc
         utilities/merge_operators/string_append/stringappend_test.cc
         utilities/object_registry_test.cc
@@ -1475,31 +1317,32 @@ if(WITH_TESTS)
         utilities/transactions/optimistic_transaction_test.cc
         utilities/transactions/transaction_test.cc
         utilities/transactions/lock/point/point_lock_manager_test.cc
-        utilities/transactions/write_committed_transaction_ts_test.cc
         utilities/transactions/write_prepared_transaction_test.cc
         utilities/transactions/write_unprepared_transaction_test.cc
         utilities/transactions/lock/range/range_locking_test.cc
-        utilities/transactions/timestamped_snapshot_test.cc
         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()
+  if(WITH_LIBRADOS)
+    list(APPEND TESTS utilities/env_librados_test.cc)
+  endif()
+
+  if(WITH_FOLLY_DISTRIBUTED_MUTEX)
+    list(APPEND TESTS third-party/folly/folly/synchronization/test/DistributedMutexTest.cpp)
+  endif()
 
   set(TESTUTIL_SOURCE
       db/db_test_util.cc
-      db/db_with_timestamp_test_util.cc
       monitoring/thread_status_updater_debug.cc
       table/mock_table.cc
-      utilities/agg_merge/test_agg_merge.cc
       utilities/cassandra/test_utils.cc
   )
   enable_testing()
   add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})
   set(TESTUTILLIB testutillib${ARTIFACT_SUFFIX})
   add_library(${TESTUTILLIB} STATIC ${TESTUTIL_SOURCE})
-  target_link_libraries(${TESTUTILLIB} ${ROCKSDB_LIB} ${FOLLY_LIBS})
+  target_link_libraries(${TESTUTILLIB} ${ROCKSDB_LIB})
   if(MSVC)
     set_target_properties(${TESTUTILLIB} PROPERTIES COMPILE_FLAGS "/Fd${CMAKE_CFG_INTDIR}/testutillib${ARTIFACT_SUFFIX}.pdb")
   endif()
@@ -1523,6 +1366,10 @@ if(WITH_TESTS)
         gtest_discover_tests(${exename} DISCOVERY_TIMEOUT 120)
         add_dependencies(check ${exename}${ARTIFACT_SUFFIX})
       endif()
+      if("${exename}" MATCHES "env_librados_test")
+        # env_librados_test.cc uses librados directly
+        target_link_libraries(${exename}${ARTIFACT_SUFFIX} rados)
+      endif()
   endforeach(sourcefile ${TESTS})
 
   if(WIN32)
@@ -1557,46 +1404,32 @@ if(WITH_BENCHMARK_TOOLS)
     cache/cache_bench.cc
     cache/cache_bench_tool.cc)
   target_link_libraries(cache_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(memtablerep_bench${ARTIFACT_SUFFIX}
     memtable/memtablerep_bench.cc)
   target_link_libraries(memtablerep_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(range_del_aggregator_bench${ARTIFACT_SUFFIX}
     db/range_del_aggregator_bench.cc)
   target_link_libraries(range_del_aggregator_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(table_reader_bench${ARTIFACT_SUFFIX}
     table/table_reader_bench.cc)
   target_link_libraries(table_reader_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} testharness ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} testharness ${GFLAGS_LIB})
 
   add_executable(filter_bench${ARTIFACT_SUFFIX}
     util/filter_bench.cc)
   target_link_libraries(filter_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 
   add_executable(hash_table_bench${ARTIFACT_SUFFIX}
     utilities/persistent_cache/hash_table_bench.cc)
   target_link_libraries(hash_table_bench${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-endif()
-
-option(WITH_TRACE_TOOLS "build with trace tools" ON)
-if(WITH_TRACE_TOOLS)
-  add_executable(block_cache_trace_analyzer${ARTIFACT_SUFFIX}
-    tools/block_cache_analyzer/block_cache_trace_analyzer_tool.cc)
-  target_link_libraries(block_cache_trace_analyzer${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-
-  add_executable(trace_analyzer${ARTIFACT_SUFFIX}
-    tools/trace_analyzer.cc)
-  target_link_libraries(trace_analyzer${ARTIFACT_SUFFIX}
-    ${ROCKSDB_LIB} ${GFLAGS_LIB} ${FOLLY_LIBS})
-
+    ${ROCKSDB_LIB} ${GFLAGS_LIB})
 endif()
 
 if(WITH_CORE_TOOLS OR WITH_TOOLS)

DEFAULT_OPTIONS_HISTORY.md

@@ -1,4 +1,4 @@
-# RocksDB default options change log (NO LONGER MAINTAINED)
+# RocksDB default options change log
 ## Unreleased
 * delayed_write_rate takes the rate given by rate_limiter if not specified.
 

HISTORY.md

@@ -1,576 +1,8 @@
 # Rocksdb Change Log
 ## Unreleased
-
-### 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)
-* 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 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).
-
-### 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
-* `DeleteRange()` now supports user-defined timestamp.
-* Provide support for async_io with tailing iterators when ReadOptions.tailing is enabled during scans.
-* Tiered Storage: allow data moving up from the last level to the penultimate level if the input level is penultimate level or above.
-* Added `DB::Properties::kFastBlockCacheEntryStats`, which is similar to `DB::Properties::kBlockCacheEntryStats`, except returns cached (stale) values in more cases to reduce overhead.
-* FIFO compaction now supports migrating from a multi-level DB via DB::Open(). During the migration phase, FIFO compaction picker will:
-* picks the sst file with the smallest starting key in the bottom-most non-empty level.
-* Note that during the migration phase, the file purge order will only be an approximation of "FIFO" as files in lower-level might sometime contain newer keys than files in upper-level.
-* Added an option `ignore_max_compaction_bytes_for_input` to ignore max_compaction_bytes limit when adding files to be compacted from input level. This should help reduce write amplification. The option is enabled by default.
-* Tiered Storage: allow data moving up from the last level even if it's a last level only compaction, as long as the penultimate level is empty.
-* Add a new option IOOptions.do_not_recurse that can be used by underlying file systems to skip recursing through sub directories and list only files in GetChildren API.
-* Add option `preserve_internal_time_seconds` to preserve the time information for the latest data. Which can be used to determine the age of data when `preclude_last_level_data_seconds` is enabled. The time information is attached with SST in table property `rocksdb.seqno.time.map` which can be parsed by tool ldb or sst_dump.
-
-### Bug Fixes
-* Fix a bug in io_uring_prep_cancel in AbortIO API for posix which expects sqe->addr to match with read request submitted and wrong paramter was being passed.
-* Fixed a regression in iterator performance when the entire DB is a single memtable introduced in #10449. The fix is in #10705 and #10716.
-* Fixed an optimistic transaction validation bug caused by DBImpl::GetLatestSequenceForKey() returning non-latest seq for merge (#10724).
-* Fixed a bug in iterator refresh which could segfault for DeleteRange users (#10739).
-* Fixed a bug causing manual flush with `flush_opts.wait=false` to stall when database has stopped all writes (#10001).
-* Fixed a bug in iterator refresh that was not freeing up SuperVersion, which could cause excessive resource pinniung (#10770).
-* Fixed a bug where RocksDB could be doing compaction endlessly when allow_ingest_behind is true and the bottommost level is not filled (#10767).
-* Fixed a memory safety bug in experimental HyperClockCache (#10768)
-* Fixed some cases where `ldb update_manifest` and `ldb unsafe_remove_sst_file` are not usable because they were requiring the DB files to match the existing manifest state (before updating the manifest to match a desired state).
-
-### Performance Improvements
-* 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.
-
-### 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.
-* Refactor the classes, APIs and data structures for block cache tracing to allow a user provided trace writer to be used. Introduced an abstract BlockCacheTraceWriter class that takes a structured BlockCacheTraceRecord. The BlockCacheTraceWriter implementation can then format and log the record in whatever way it sees fit. The default BlockCacheTraceWriterImpl does file tracing using a user provided TraceWriter. More details in rocksdb/includb/block_cache_trace_writer.h.
-
-## 7.7.0 (09/18/2022)
-### Bug Fixes
-* Fixed a hang when an operation such as `GetLiveFiles` or `CreateNewBackup` is asked to trigger and wait for memtable flush on a read-only DB. Such indirect requests for memtable flush are now ignored on a read-only DB.
-* Fixed bug where `FlushWAL(true /* sync */)` (used by `GetLiveFilesStorageInfo()`, which is used by checkpoint and backup) could cause parallel writes at the tail of a WAL file to never be synced.
-* Fix periodic_task unable to re-register the same task type, which may cause `SetOptions()` fail to update periodical_task time like: `stats_dump_period_sec`, `stats_persist_period_sec`.
-* Fixed a bug in the rocksdb.prefetched.bytes.discarded stat. It was counting the prefetch buffer size, rather than the actual number of bytes discarded from the buffer.
-* Fix bug where the directory containing CURRENT can left unsynced after CURRENT is updated to point to the latest MANIFEST, which leads to risk of unsync data loss of CURRENT.
-* Update rocksdb.multiget.io.batch.size stat in non-async MultiGet as well.
-* Fix a bug in key range overlap checking with concurrent compactions when user-defined timestamp is enabled. User-defined timestamps should be EXCLUDED when checking if two ranges overlap.
-* Fixed a bug where the blob cache prepopulating logic did not consider the secondary cache (see #10603).
-* Fixed the rocksdb.num.sst.read.per.level, rocksdb.num.index.and.filter.blocks.read.per.level and rocksdb.num.level.read.per.multiget stats in the MultiGet coroutines
-
-### Public API changes
-* Add `rocksdb_column_family_handle_get_id`, `rocksdb_column_family_handle_get_name` to get name, id of column family in C API
-* Add a new stat rocksdb.async.prefetch.abort.micros to measure time spent waiting for async prefetch reads to abort
-
-### Java API Changes
-* Add CompactionPriority.RoundRobin.
-* Revert to using the default metadata charge policy when creating an LRU cache via the Java API.
-
-### Behavior Change
-* DBOptions::verify_sst_unique_id_in_manifest is now an on-by-default feature that verifies SST file identity whenever they are opened by a DB, rather than only at DB::Open time.
-* Right now, when the option migration tool (OptionChangeMigration()) migrates to FIFO compaction, it compacts all the data into one single SST file and move to L0. This might create a problem for some users: the giant file may be soon deleted to satisfy max_table_files_size, and might cayse the DB to be almost empty. We change the behavior so that the files are cut to be smaller, but these files might not follow the data insertion order. With the change, after the migration, migrated data might not be dropped by insertion order by FIFO compaction.
-* When a block is firstly found from `CompressedSecondaryCache`, we just insert a dummy block into the primary cache and don’t erase the block from `CompressedSecondaryCache`. A standalone handle is returned to the caller. Only if the block is found again from `CompressedSecondaryCache` before the dummy block is evicted, we erase the block from `CompressedSecondaryCache` and insert it into the primary cache.
-* When a block is firstly evicted from the primary cache to `CompressedSecondaryCache`, we just insert a dummy block in `CompressedSecondaryCache`. Only if it is evicted again before the dummy block is evicted from the cache, it is treated as a hot block and is inserted into `CompressedSecondaryCache`.
-* Improved the estimation of memory used by cached blobs by taking into account the size of the object owning the blob value and also the allocator overhead if `malloc_usable_size` is available (see #10583).
-* Blob values now have their own category in the cache occupancy statistics, as opposed to being lumped into the "Misc" bucket (see #10601).
-* Change the optimize_multiget_for_io experimental ReadOptions flag to default on.
-
-### New Features
-*  RocksDB does internal auto prefetching if it notices 2 sequential reads if readahead_size is not specified. New option `num_file_reads_for_auto_readahead` is added in BlockBasedTableOptions which indicates after how many sequential reads internal auto prefetching should be start (default is 2).
-* Added new perf context counters `block_cache_standalone_handle_count`, `block_cache_real_handle_count`,`compressed_sec_cache_insert_real_count`, `compressed_sec_cache_insert_dummy_count`, `compressed_sec_cache_uncompressed_bytes`, and `compressed_sec_cache_compressed_bytes`.
-* Memory for blobs which are to be inserted into the blob cache is now allocated using the cache's allocator (see #10628 and #10647).
-* HyperClockCache is an experimental, lock-free Cache alternative for block cache that offers much improved CPU efficiency under high parallel load or high contention, with some caveats. As much as 4.5x higher ops/sec vs. LRUCache has been seen in db_bench under high parallel load.
-* `CompressedSecondaryCacheOptions::enable_custom_split_merge` is added for enabling the custom split and merge feature, which split the compressed value into chunks so that they may better fit jemalloc bins.
-
-### Performance Improvements
-* Iterator performance is improved for `DeleteRange()` users. Internally, iterator will skip to the end of a range tombstone when possible, instead of looping through each key and check individually if a key is range deleted.
-* Eliminated some allocations and copies in the blob read path. Also, `PinnableSlice` now only points to the blob value and pins the backing resource (cache entry or buffer) in all cases, instead of containing a copy of the blob value. See #10625 and #10647.
-* In case of scans with async_io enabled, few optimizations have been added to issue more asynchronous requests in parallel in order to avoid synchronous prefetching.
-* `DeleteRange()` users should see improvement in get/iterator performance from mutable memtable (see #10547).
-
-## 7.6.0 (08/19/2022)
-### New Features
-* Added `prepopulate_blob_cache` to ColumnFamilyOptions. If enabled, prepopulate warm/hot blobs which are already in memory into blob cache at the time of flush. On a flush, the blob that is in memory (in memtables) get flushed to the device. If using Direct IO, additional IO is incurred to read this blob back into memory again, which is avoided by enabling this option. This further helps if the workload exhibits high temporal locality, where most of the reads go to recently written data. This also helps in case of the remote file system since it involves network traffic and higher latencies.
-* Support using secondary cache with the blob cache. When creating a blob cache, the user can set a secondary blob cache by configuring `secondary_cache` in LRUCacheOptions.
-* Charge memory usage of blob cache when the backing cache of the blob cache and the block cache are different. If an operation reserving memory for blob cache exceeds the avaible space left in the block cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature, enable charging `CacheEntryRole::kBlobCache` in `BlockBasedTableOptions::cache_usage_options`.
-* Improve subcompaction range partition so that it is likely to be more even. More evenly distribution of subcompaction will improve compaction throughput for some workloads. All input files' index blocks to sample some anchor key points from which we pick positions to partition the input range. This would introduce some CPU overhead in compaction preparation phase, if subcompaction is enabled, but it should be a small fraction of the CPU usage of the whole compaction process. This also brings a behavier change: subcompaction number is much more likely to maxed out than before.
-* Add CompactionPri::kRoundRobin, a compaction picking mode that cycles through all the files with a compact cursor in a round-robin manner. This feature is available since 7.5.
-* Provide support for subcompactions for user_defined_timestamp.
-* Added an option `memtable_protection_bytes_per_key` that turns on memtable per key-value checksum protection. Each memtable entry will be suffixed by a checksum that is computed during writes, and verified in reads/compaction. Detected corruption will be logged and with corruption status returned to user.
-* Added a blob-specific cache priority level - bottom level. Blobs are typically lower-value targets for caching than data blocks, since 1) with BlobDB, data blocks containing blob references conceptually form an index structure which has to be consulted before we can read the blob value, and 2) cached blobs represent only a single key-value, while cached data blocks generally contain multiple KVs. The user can specify the new option `low_pri_pool_ratio` in `LRUCacheOptions` to configure the ratio of capacity reserved for low priority cache entries (and therefore the remaining ratio is the space reserved for the bottom level), or configuring the new argument `low_pri_pool_ratio` in `NewLRUCache()` to achieve the same effect.
-
-### Public API changes
-* Removed Customizable support for RateLimiter and removed its CreateFromString() and Type() functions.
-* `CompactRangeOptions::exclusive_manual_compaction` is now false by default. This ensures RocksDB does not introduce artificial parallelism limitations by default.
-* Tiered Storage: change `bottommost_temperture` to `last_level_temperture`. The old option name is kept only for migration, please use the new option. The behavior is changed to apply temperature for the `last_level` SST files only.
-* Added a new experimental ReadOption flag called optimize_multiget_for_io, which when set attempts to reduce MultiGet latency by spawning coroutines for keys in multiple levels.
-
-### Bug Fixes
-* Fix a bug starting in 7.4.0 in which some fsync operations might be skipped in a DB after any DropColumnFamily on that DB, until it is re-opened. This can lead to data loss on power loss. (For custom FileSystem implementations, this could lead to `FSDirectory::Fsync` or `FSDirectory::Close` after the first `FSDirectory::Close`; Also, valgrind could report call to `close()` with `fd=-1`.)
-* Fix a bug where `GenericRateLimiter` could revert the bandwidth set dynamically using `SetBytesPerSecond()` when a user configures a structure enclosing it, e.g., using `GetOptionsFromString()` to configure an `Options` that references an existing `RateLimiter` object.
-* Fix race conditions in `GenericRateLimiter`.
-* Fix a bug in `FIFOCompactionPicker::PickTTLCompaction` where total_size calculating might cause underflow
-* Fix data race bug in hash linked list memtable. With this bug, read request might temporarily miss an old record in the memtable in a race condition to the hash bucket.
-* Fix a bug that `best_efforts_recovery` may fail to open the db with mmap read.
-* Fixed a bug where blobs read during compaction would pollute the cache.
-* Fixed a data race in LRUCache when used with a secondary_cache.
-* Fixed a bug where blobs read by iterators would be inserted into the cache even with the `fill_cache` read option set to false.
-* Fixed the segfault caused by `AllocateData()` in `CompressedSecondaryCache::SplitValueIntoChunks()` and `MergeChunksIntoValueTest`.
-* Fixed a bug in BlobDB where a mix of inlined and blob values could result in an incorrect value being passed to the compaction filter (see #10391).
-* Fixed a memory leak bug in stress tests caused by `FaultInjectionSecondaryCache`.
-
-### Behavior Change
-* Added checksum handshake during the copying of decompressed WAL fragment. This together with #9875, #10037, #10212, #10114 and #10319 provides end-to-end integrity protection for write batch during recovery.
-* To minimize the internal fragmentation caused by the variable size of the compressed blocks in `CompressedSecondaryCache`, the original block is split according to the jemalloc bin size in `Insert()` and then merged back in `Lookup()`.
-* PosixLogger is removed and by default EnvLogger will be used for info logging. The behavior of the two loggers should be very similar when using the default Posix Env.
-* Remove [min|max]_timestamp from VersionEdit for now since they are not tracked in MANIFEST anyway but consume two empty std::string (up to 64 bytes) for each file. Should they be added back in the future, we should store them more compactly.
-* Improve universal tiered storage compaction picker to avoid extra major compaction triggered by size amplification. If `preclude_last_level_data_seconds` is enabled, the size amplification is calculated within non last_level data only which skip the last level and use the penultimate level as the size base.
-* If an error is hit when writing to a file (append, sync, etc), RocksDB is more strict with not issuing more operations to it, except closing the file, with exceptions of some WAL file operations in error recovery path.
-* A `WriteBufferManager` constructed with `allow_stall == false` will no longer trigger write stall implicitly by thrashing until memtable count limit is reached. Instead, a column family can continue accumulating writes while that CF is flushing, which means memory may increase. Users who prefer stalling writes must now explicitly set `allow_stall == true`.
-* Add `CompressedSecondaryCache` into the stress tests.
-* Block cache keys have changed, which will cause any persistent caches to miss between versions.
-
-### Performance Improvements
-* Instead of constructing `FragmentedRangeTombstoneList` during every read operation, it is now constructed once and stored in immutable memtables. This improves speed of querying range tombstones from immutable memtables.
-* When using iterators with the integrated BlobDB implementation, blob cache handles are now released immediately when the iterator's position changes.
-* MultiGet can now do more IO in parallel by reading data blocks from SST files in multiple levels, if the optimize_multiget_for_io ReadOption flag is set.
-
-## 7.5.0 (07/15/2022)
-### New Features
-* Mempurge option flag `experimental_mempurge_threshold` is now a ColumnFamilyOptions and can now be dynamically configured using `SetOptions()`.
-* Support backward iteration when `ReadOptions::iter_start_ts` is set.
-* Provide support for ReadOptions.async_io with direct_io to improve Seek latency by using async IO to parallelize child iterator seek and doing asynchronous prefetching on sequential scans.
-* Added support for blob caching in order to cache frequently used blobs for BlobDB.
-  * User can configure the new ColumnFamilyOptions `blob_cache` to enable/disable blob caching.
-  * Either sharing the backend cache with the block cache or using a completely separate cache is supported.
-  * A new abstraction interface called `BlobSource` for blob read logic gives all users access to blobs, whether they are in the blob cache, secondary cache, or (remote) storage. Blobs can be potentially read both while handling user reads (`Get`, `MultiGet`, or iterator) and during compaction (while dealing with compaction filters, Merges, or garbage collection) but eventually all blob reads go through `Version::GetBlob` or, for MultiGet, `Version::MultiGetBlob` (and then get dispatched to the interface -- `BlobSource`).
-* Add experimental tiered compaction feature `AdvancedColumnFamilyOptions::preclude_last_level_data_seconds`, which makes sure the new data inserted within preclude_last_level_data_seconds won't be placed on cold tier (the feature is not complete).
-
-### Public API changes
-* Add metadata related structs and functions in C API, including
-  * `rocksdb_get_column_family_metadata()` and `rocksdb_get_column_family_metadata_cf()` to obtain `rocksdb_column_family_metadata_t`.
-  * `rocksdb_column_family_metadata_t` and its get functions & destroy function.
-  * `rocksdb_level_metadata_t` and its and its get functions & destroy function.
-  * `rocksdb_file_metadata_t` and its and get functions & destroy functions.
-* Add suggest_compact_range() and suggest_compact_range_cf() to C API.
-* When using block cache strict capacity limit (`LRUCache` with `strict_capacity_limit=true`), DB operations now fail with Status code `kAborted` subcode `kMemoryLimit` (`IsMemoryLimit()`) instead of `kIncomplete` (`IsIncomplete()`) when the capacity limit is reached, because Incomplete can mean other specific things for some operations. In more detail, `Cache::Insert()` now returns the updated Status code and this usually propagates through RocksDB to the user on failure.
-* NewClockCache calls temporarily return an LRUCache (with similar characteristics as the desired ClockCache). This is because ClockCache is being replaced by a new version (the old one had unknown bugs) but this is still under development.
-* Add two functions `int ReserveThreads(int threads_to_be_reserved)` and `int ReleaseThreads(threads_to_be_released)` into `Env` class. In the default implementation, both return 0. Newly added `xxxEnv` class that inherits `Env` should implement these two functions for thread reservation/releasing features.
-* Add `rocksdb_options_get_prepopulate_blob_cache` and `rocksdb_options_set_prepopulate_blob_cache` to C API.
-* Add `prepopulateBlobCache` and `setPrepopulateBlobCache` to Java API.
-
-### Bug Fixes
-* Fix a bug in which backup/checkpoint can include a WAL deleted by RocksDB.
-* Fix a bug where concurrent compactions might cause unnecessary further write stalling. In some cases, this might cause write rate to drop to minimum.
-* Fix a bug in Logger where if dbname and db_log_dir are on different filesystems, dbname creation would fail wrt to db_log_dir path returning an error and fails to open the DB.
-* Fix a CPU and memory efficiency issue introduce by https://github.com/facebook/rocksdb/pull/8336 which made InternalKeyComparator configurable as an unintended side effect.
-
-## Behavior Change
-* In leveled compaction with dynamic levelling, level multiplier is not anymore adjusted due to oversized L0. Instead, compaction score is adjusted by increasing size level target by adding incoming bytes from upper levels. This would deprioritize compactions from upper levels if more data from L0 is coming. This is to fix some unnecessary full stalling due to drastic change of level targets, while not wasting write bandwidth for compaction while writes are overloaded.
-* For track_and_verify_wals_in_manifest, revert to the original behavior before #10087: syncing of live WAL file is not tracked, and we track only the synced sizes of **closed** WALs. (PR #10330).
-* WAL compression now computes/verifies checksum during compression/decompression.
-
-### Performance Improvements
-* Rather than doing total sort against all files in a level, SortFileByOverlappingRatio() to only find the top 50 files based on score. This can improve write throughput for the use cases where data is loaded in increasing key order and there are a lot of files in one LSM-tree, where applying compaction results is the bottleneck.
-* In leveled compaction, L0->L1 trivial move will allow more than one file to be moved in one compaction. This would allow L0 files to be moved down faster when data is loaded in sequential order, making slowdown or stop condition harder to hit. Also seek L0->L1 trivial move when only some files qualify.
-* In leveled compaction, try to trivial move more than one files if possible, up to 4 files or max_compaction_bytes. This is to allow higher write throughput for some use cases where data is loaded in sequential order, where appying compaction results is the bottleneck.
-
-## 7.4.0 (06/19/2022)
-### Bug Fixes
-* Fixed a bug in calculating key-value integrity protection for users of in-place memtable updates. In particular, the affected users would be those who configure `protection_bytes_per_key > 0` on `WriteBatch` or `WriteOptions`, and configure `inplace_callback != nullptr`.
-* Fixed a bug where a snapshot taken during SST file ingestion would be unstable.
-* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution, RocksDB will persist the new MANIFEST after successfully syncing the new WAL. If a future recovery starts from the new MANIFEST, then it means the new WAL is successfully synced. Due to the sentinel empty write batch at the beginning, kPointInTimeRecovery of WAL is guaranteed to go after this point. If future recovery starts from the old MANIFEST, it means the writing the new MANIFEST failed. We won't have the "SST ahead of WAL" error.
-* Fixed a bug where RocksDB DB::Open() may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful.
-* Fix a race condition in WAL size tracking which is caused by an unsafe iterator access after container is changed.
-* Fix unprotected concurrent accesses to `WritableFileWriter::filesize_` by `DB::SyncWAL()` and `DB::Put()` in two write queue mode.
-* Fix a bug in WAL tracking. Before this PR (#10087), calling `SyncWAL()` on the only WAL file of the db will not log the event in MANIFEST, thus allowing a subsequent `DB::Open` even if the WAL file is missing or corrupted.
-* Fix a bug that could return wrong results with `index_type=kHashSearch` and using `SetOptions` to change the `prefix_extractor`.
-* Fixed a bug in WAL tracking with wal_compression. WAL compression writes a kSetCompressionType record which is not associated with any sequence number. As result, WalManager::GetSortedWalsOfType() will skip these WALs and not return them to caller, e.g. Checkpoint, Backup, causing the operations to fail.
-* Avoid a crash if the IDENTITY file is accidentally truncated to empty. A new DB ID will be written and generated on Open.
-* Fixed a possible corruption for users of `manual_wal_flush` and/or `FlushWAL(true /* sync */)`, together with `track_and_verify_wals_in_manifest == true`. For those users, losing unsynced data (e.g., due to power loss) could make future DB opens fail with a `Status::Corruption` complaining about missing WAL data.
-* Fixed a bug in `WriteBatchInternal::Append()` where WAL termination point in write batch was not considered and the function appends an incorrect number of checksums.
-* Fixed a crash bug introduced in 7.3.0 affecting users of MultiGet with `kDataBlockBinaryAndHash`.
-
-### Public API changes
-* Add new API GetUnixTime in Snapshot class which returns the unix time at which Snapshot is taken.
-* Add transaction `get_pinned` and `multi_get` to C API.
-* Add two-phase commit support to C API.
-* Add `rocksdb_transaction_get_writebatch_wi` and `rocksdb_transaction_rebuild_from_writebatch` to C API.
-* Add `rocksdb_options_get_blob_file_starting_level` and `rocksdb_options_set_blob_file_starting_level` to C API.
-* Add `blobFileStartingLevel` and `setBlobFileStartingLevel` to Java API.
-* Add SingleDelete for DB in C API
-* Add User Defined Timestamp in C API.
-  * `rocksdb_comparator_with_ts_create` to create timestamp aware comparator
-  * Put, Get, Delete, SingleDelete, MultiGet APIs has corresponding timestamp aware APIs with suffix `with_ts`
-  * And Add C API's for Transaction, SstFileWriter, Compaction as mentioned [here](https://github.com/facebook/rocksdb/wiki/User-defined-Timestamp-(Experimental))
-* The contract for implementations of Comparator::IsSameLengthImmediateSuccessor has been updated to work around a design bug in `auto_prefix_mode`.
-* The API documentation for `auto_prefix_mode` now notes some corner cases in which it returns different results than `total_order_seek`, due to design bugs that are not easily fixed. Users using built-in comparators and keys at least the size of a fixed prefix length are not affected.
-* Obsoleted the NUM_DATA_BLOCKS_READ_PER_LEVEL stat and introduced the NUM_LEVEL_READ_PER_MULTIGET and MULTIGET_COROUTINE_COUNT stats
-* Introduced `WriteOptions::protection_bytes_per_key`, which can be used to enable key-value integrity protection for live updates.
-
-### New Features
-* Add FileSystem::ReadAsync API in io_tracing
-* Add blob garbage collection parameters `blob_garbage_collection_policy` and `blob_garbage_collection_age_cutoff` to both force-enable and force-disable GC, as well as selectively override age cutoff when using CompactRange.
-* Add an extra sanity check in `GetSortedWalFiles()` (also used by `GetLiveFilesStorageInfo()`, `BackupEngine`, and `Checkpoint`) to reduce risk of successfully created backup or checkpoint failing to open because of missing WAL file.
-* Add a new column family option `blob_file_starting_level` to enable writing blob files during flushes and compactions starting from the specified LSM tree level.
-* Add support for timestamped snapshots (#9879)
-* Provide support for AbortIO in posix to cancel submitted asynchronous requests using io_uring.
-* Add support for rate-limiting batched `MultiGet()` APIs
-* Added several new tickers, perf context statistics, and DB properties to BlobDB
-  * Added new DB properties "rocksdb.blob-cache-capacity", "rocksdb.blob-cache-usage", "rocksdb.blob-cache-pinned-usage" to show blob cache usage.
-  * Added new perf context statistics `blob_cache_hit_count`, `blob_read_count`, `blob_read_byte`, `blob_read_time`, `blob_checksum_time` and `blob_decompress_time`.
-  * Added new tickers `BLOB_DB_CACHE_MISS`, `BLOB_DB_CACHE_HIT`, `BLOB_DB_CACHE_ADD`, `BLOB_DB_CACHE_ADD_FAILURES`, `BLOB_DB_CACHE_BYTES_READ` and `BLOB_DB_CACHE_BYTES_WRITE`.
-
-### Behavior changes
-* DB::Open(), DB::OpenAsSecondary() will fail if a Logger cannot be created (#9984)
-* DB::Write does not hold global `mutex_` if this db instance does not need to switch wal and mem-table (#7516).
-* Removed support for reading Bloom filters using obsolete block-based filter format. (Support for writing such filters was dropped in 7.0.) For good read performance on old DBs using these filters, a full compaction is required.
-* Per KV checksum in write batch is verified before a write batch is written to WAL to detect any corruption to the write batch (#10114).
-
-### Performance Improvements
-* When compiled with folly (Meta-internal integration; experimental in open source build), improve the locking performance (CPU efficiency) of LRUCache by using folly DistributedMutex in place of standard mutex.
-
-## 7.3.0 (05/20/2022)
-### Bug Fixes
-* Fixed a bug where manual flush would block forever even though flush options had wait=false.
-* Fixed a bug where RocksDB could corrupt DBs with `avoid_flush_during_recovery == true` by removing valid WALs, leading to `Status::Corruption` with message like "SST file is ahead of WALs" when attempting to reopen.
-* Fixed a bug in async_io path where incorrect length of data is read by FilePrefetchBuffer if data is consumed from two populated buffers and request for more data is sent.
-* Fixed a CompactionFilter bug. Compaction filter used to use `Delete` to remove keys, even if the keys should be removed with `SingleDelete`. Mixing `Delete` and `SingleDelete` may cause undefined behavior.
-* Fixed a bug in `WritableFileWriter::WriteDirect` and `WritableFileWriter::WriteDirectWithChecksum`. The rate_limiter_priority specified in ReadOptions was not passed to the RateLimiter when requesting a token.
-* Fixed a bug which might cause process crash when I/O error happens when reading an index block in MultiGet().
-
-### New Features
-* DB::GetLiveFilesStorageInfo is ready for production use.
-* Add new stats PREFETCHED_BYTES_DISCARDED which records number of prefetched bytes discarded by RocksDB FilePrefetchBuffer on destruction and POLL_WAIT_MICROS records wait time for FS::Poll API completion.
-* RemoteCompaction supports table_properties_collector_factories override on compaction worker.
-* Start tracking SST unique id in MANIFEST, which will be used to verify with SST properties during DB open to make sure the SST file is not overwritten or misplaced. A db option `verify_sst_unique_id_in_manifest` is introduced to enable/disable the verification, if enabled all SST files will be opened during DB-open to verify the unique id (default is false), so it's recommended to use it with `max_open_files = -1` to pre-open the files.
-* Added the ability to concurrently read data blocks from multiple files in a level in batched MultiGet. This can be enabled by setting the async_io option in ReadOptions. Using this feature requires a FileSystem that supports ReadAsync (PosixFileSystem is not supported yet for this), and for RocksDB to be compiled with folly and c++20.
-* Charge memory usage of file metadata. RocksDB holds one file metadata structure in-memory per on-disk table file. If an operation reserving memory for file metadata exceeds the avaible space left in the block
-cache at some point (i.e, causing a cache full under `LRUCacheOptions::strict_capacity_limit` = true), creation will fail with `Status::MemoryLimit()`. To opt in this feature,  enable charging `CacheEntryRole::kFileMetadata` in `BlockBasedTableOptions::cache_usage_options`.
-
-### Public API changes
-* Add rollback_deletion_type_callback to TransactionDBOptions so that write-prepared transactions know whether to issue a Delete or SingleDelete to cancel a previous key written during prior prepare phase. The PR aims to prevent mixing SingleDeletes and Deletes for the same key that can lead to undefined behaviors for write-prepared transactions.
-* EXPERIMENTAL: Add new API AbortIO in file_system to abort the read requests submitted asynchronously.
-* CompactionFilter::Decision has a new value: kRemoveWithSingleDelete. If CompactionFilter returns this decision, then CompactionIterator will use `SingleDelete` to mark a key as removed.
-* Renamed CompactionFilter::Decision::kRemoveWithSingleDelete to kPurge since the latter sounds more general and hides the implementation details of how compaction iterator handles keys.
-* Added ability to specify functions for Prepare and Validate to OptionsTypeInfo.  Added methods to OptionTypeInfo to set the functions via an API.  These methods are intended for RocksDB plugin developers for configuration management.
-* Added a new immutable db options, enforce_single_del_contracts. If set to false (default is true), compaction will NOT fail due to a single delete followed by a delete for the same key. The purpose of this temporay option is to help existing use cases migrate.
-* Introduce `BlockBasedTableOptions::cache_usage_options` and use that to replace `BlockBasedTableOptions::reserve_table_builder_memory` and  `BlockBasedTableOptions::reserve_table_reader_memory`.
-* Changed `GetUniqueIdFromTableProperties` to return a 128-bit unique identifier, which will be the standard size now. The old functionality (192-bit) is available from `GetExtendedUniqueIdFromTableProperties`. Both functions are no longer "experimental" and are ready for production use.
-* In IOOptions, mark `prio` as deprecated for future removal.
-* In `file_system.h`, mark `IOPriority` as deprecated for future removal.
-* Add an option, `CompressionOptions::use_zstd_dict_trainer`, to indicate whether zstd dictionary trainer should be used for generating zstd compression dictionaries. The default value of this option is true for backward compatibility. When this option is set to false, zstd API `ZDICT_finalizeDictionary` is used to generate compression dictionaries.
-* Seek API which positions itself every LevelIterator on the correct data block in the correct SST file which can be parallelized if ReadOptions.async_io option is enabled.
-* Add new stat number_async_seek in PerfContext that indicates number of async calls made by seek to prefetch data.
-* Add support for user-defined timestamps to read only DB.
-
-### Bug Fixes
-* RocksDB calls FileSystem::Poll API during FilePrefetchBuffer destruction which impacts performance as it waits for read requets completion which is not needed anymore. Calling FileSystem::AbortIO to abort those requests instead fixes that performance issue.
-* Fixed unnecessary block cache contention when queries within a MultiGet batch and across parallel batches access the same data block, which previously could cause severely degraded performance in this unusual case. (In more typical MultiGet cases, this fix is expected to yield a small or negligible performance improvement.)
-
-### Behavior changes
-* Enforce the existing contract of SingleDelete so that SingleDelete cannot be mixed with Delete because it leads to undefined behavior. Fix a number of unit tests that violate the contract but happen to pass.
-* ldb `--try_load_options` default to true if `--db` is specified and not creating a new DB, the user can still explicitly disable that by `--try_load_options=false` (or explicitly enable that by `--try_load_options`).
-* During Flush write or Compaction write/read, the WriteController is used to determine whether DB writes are stalled or slowed down. The priority (Env::IOPriority) can then be determined accordingly and be passed in IOOptions to the file system.
-
-### Performance Improvements
-* Avoid calling malloc_usable_size() in LRU Cache's mutex.
-* Reduce DB mutex holding time when finding obsolete files to delete. When a file is trivial moved to another level, the internal files will be referenced twice internally and sometimes opened twice too. If a deletion candidate file is not the last reference, we need to destroy the reference and close the file but not deleting the file. Right now we determine it by building a set of all live files. With the improvement, we check the file against all live LSM-tree versions instead.
-
-## 7.2.0 (04/15/2022)
-### Bug Fixes
-* Fixed bug which caused rocksdb failure in the situation when rocksdb was accessible using UNC path
-* Fixed a race condition when 2PC is disabled and WAL tracking in the MANIFEST is enabled. The race condition is between two background flush threads trying to install flush results, causing a WAL deletion not tracked in the MANIFEST. A future DB open may fail.
-* Fixed a heap use-after-free race with DropColumnFamily.
-* Fixed a bug that `rocksdb.read.block.compaction.micros` cannot track compaction stats (#9722).
-* Fixed `file_type`, `relative_filename` and `directory` fields returned by `GetLiveFilesMetaData()`, which were added in inheriting from `FileStorageInfo`.
-* Fixed a bug 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 (#9766).
-* Fix segfault in FilePrefetchBuffer with async_io as it doesn't wait for pending jobs to complete on destruction.
-* Fix ERROR_HANDLER_AUTORESUME_RETRY_COUNT stat whose value was set wrong in portal.h
-* Fixed a bug for non-TransactionDB with avoid_flush_during_recovery = true and TransactionDB where in case of crash, min_log_number_to_keep may not change on recovery and persisting a new MANIFEST with advanced log_numbers for some column families, results in "column family inconsistency" error on second recovery. As a solution the corrupted WALs whose numbers are larger than the corrupted wal and smaller than the new WAL will be moved to archive folder.
-* Fixed a bug in RocksDB DB::Open() which may creates and writes to two new MANIFEST files even before recovery succeeds. Now writes to MANIFEST are persisted only after recovery is successful.
-
-### New Features
-* For db_bench when --seed=0 or --seed is not set then it uses the current time as the seed value. Previously it used the value 1000.
-* For db_bench when --benchmark lists multiple tests and each test uses a seed for a RNG then the seeds across tests will no longer be repeated.
-* Added an option to dynamically charge an updating estimated memory usage of block-based table reader to block cache if block cache available. To enable this feature, set `BlockBasedTableOptions::reserve_table_reader_memory = true`.
-* Add new stat ASYNC_READ_BYTES that calculates number of bytes read during async read call and users can check if async code path is being called by RocksDB internal automatic prefetching for sequential reads.
-* Enable async prefetching if ReadOptions.readahead_size is set along with ReadOptions.async_io in FilePrefetchBuffer.
-* Add event listener support on remote compaction compactor side.
-* Added a dedicated integer DB property `rocksdb.live-blob-file-garbage-size` that exposes the total amount of garbage in the blob files in the current version.
-* RocksDB does internal auto prefetching if it notices sequential reads. It starts with readahead size `initial_auto_readahead_size` which now can be configured through BlockBasedTableOptions.
-* Add a merge operator that allows users to register specific aggregation function so that they can does aggregation using different aggregation types for different keys. See comments in include/rocksdb/utilities/agg_merge.h for actual usage. The feature is experimental and the format is subject to change and we won't provide a migration tool.
-* Meta-internal / Experimental: Improve CPU performance by replacing many uses of std::unordered_map with folly::F14FastMap when RocksDB is compiled together with Folly.
-* Experimental: Add CompressedSecondaryCache, a concrete implementation of rocksdb::SecondaryCache, that integrates with compression libraries (e.g. LZ4) to hold compressed blocks.
-
-### Behavior changes
-* Disallow usage of commit-time-write-batch for write-prepared/write-unprepared transactions if TransactionOptions::use_only_the_last_commit_time_batch_for_recovery is false to prevent two (or more) uncommitted versions of the same key in the database. Otherwise, bottommost compaction may violate the internal key uniqueness invariant of SSTs if the sequence numbers of both internal keys are zeroed out (#9794).
-* Make DB::GetUpdatesSince() return NotSupported early for write-prepared/write-unprepared transactions, as the API contract indicates.
-
-### Public API changes
-* Exposed APIs to examine results of block cache stats collections in a structured way. In particular, users of `GetMapProperty()` with property `kBlockCacheEntryStats` can now use the functions in `BlockCacheEntryStatsMapKeys` to find stats in the map.
-* Add `fail_if_not_bottommost_level` to IngestExternalFileOptions so that ingestion will fail if the file(s) cannot be ingested to the bottommost level.
-* Add output parameter `is_in_sec_cache` to `SecondaryCache::Lookup()`. It is to indicate whether the handle is possibly erased from the secondary cache after the Lookup.
-
-## 7.1.0 (03/23/2022)
-### New Features
-* Allow WriteBatchWithIndex to index a WriteBatch that includes keys with user-defined timestamps. The index itself does not have timestamp.
-* Add support for user-defined timestamps to write-committed transaction without API change. The `TransactionDB` layer APIs do not allow timestamps because we require that all user-defined-timestamps-aware operations go through the `Transaction` APIs.
-* Added BlobDB options to `ldb`
-* `BlockBasedTableOptions::detect_filter_construct_corruption` can now be dynamically configured using `DB::SetOptions`.
-* Automatically recover from retryable read IO errors during backgorund flush/compaction.
-* Experimental support for preserving file Temperatures through backup and restore, and for updating DB metadata for outside changes to file Temperature (`UpdateManifestForFilesState` or `ldb update_manifest --update_temperatures`).
-* Experimental support for async_io in ReadOptions which is used by FilePrefetchBuffer to prefetch some of the data asynchronously,  if reads are sequential and auto readahead is enabled by rocksdb internally.
-
-### Bug Fixes
-* Fixed a major performance bug in which Bloom filters generated by pre-7.0 releases are not read by early 7.0.x releases (and vice-versa) due to changes to FilterPolicy::Name() in #9590. This can severely impact read performance and read I/O on upgrade or downgrade with existing DB, but not data correctness.
-* Fixed a data race on `versions_` between `DBImpl::ResumeImpl()` and threads waiting for recovery to complete (#9496)
-* Fixed a bug caused by race among flush, incoming writes and taking snapshots. Queries to snapshots created with these race condition can return incorrect result, e.g. resurfacing deleted data.
-* Fixed a bug that DB flush uses `options.compression` even `options.compression_per_level` is set.
-* Fixed a bug that DisableManualCompaction may assert when disable an unscheduled manual compaction.
-* Fix a race condition when cancel manual compaction with `DisableManualCompaction`. Also DB close can cancel the manual compaction thread.
-* Fixed a potential timer crash when open close DB concurrently.
-* Fixed a race condition for `alive_log_files_` in non-two-write-queues mode. The race is between the write_thread_ in WriteToWAL() and another thread executing `FindObsoleteFiles()`. The race condition will be caught if `__glibcxx_requires_nonempty` is enabled.
-* Fixed a bug that `Iterator::Refresh()` reads stale keys after DeleteRange() performed.
-* Fixed a race condition when disable and re-enable manual compaction.
-* Fixed automatic error recovery failure in atomic flush.
-* Fixed a race condition when mmaping a WritableFile on POSIX.
-
-### Public API changes
-* Added pure virtual FilterPolicy::CompatibilityName(), which is needed for fixing major performance bug involving FilterPolicy naming in SST metadata without affecting Customizable aspect of FilterPolicy. This change only affects those with their own custom or wrapper FilterPolicy classes.
-* `options.compression_per_level` is dynamically changeable with `SetOptions()`.
-* Added `WriteOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for writes associated with the API to which the `WriteOptions` was provided. Currently the support covers automatic WAL flushes, which happen during live updates (`Put()`, `Write()`, `Delete()`, etc.) when `WriteOptions::disableWAL == false` and `DBOptions::manual_wal_flush == false`.
-* Add DB::OpenAndTrimHistory API. This API will open DB and trim data to the timestamp specified by trim_ts (The data with timestamp larger than specified trim bound will be removed). This API should only be used at a timestamp-enabled column families recovery. If the column family doesn't have timestamp enabled, this API won't trim any data on that column family. This API is not compatible with avoid_flush_during_recovery option.
-* Remove BlockBasedTableOptions.hash_index_allow_collision which already takes no effect.
-
-## 7.0.0 (02/20/2022)
-### Bug Fixes
-* Fixed a major bug in which batched MultiGet could return old values for keys deleted by DeleteRange when memtable Bloom filter is enabled (memtable_prefix_bloom_size_ratio > 0). (The fix includes a substantial MultiGet performance improvement in the unusual case of both memtable_whole_key_filtering and prefix_extractor.)
-* Fixed more cases of EventListener::OnTableFileCreated called with OK status, file_size==0, and no SST file kept. Now the status is Aborted.
-* Fixed a read-after-free bug in `DB::GetMergeOperands()`.
-* Fix a data loss bug for 2PC write-committed transaction caused by concurrent transaction commit and memtable switch (#9571).
-* Fixed NUM_INDEX_AND_FILTER_BLOCKS_READ_PER_LEVEL, NUM_DATA_BLOCKS_READ_PER_LEVEL, and NUM_SST_READ_PER_LEVEL stats to be reported once per MultiGet batch per level.
-
-### Performance Improvements
-* Mitigated the overhead of building the file location hash table used by the online LSM tree consistency checks, which can improve performance for certain workloads (see #9351).
-* Switched to using a sorted `std::vector` instead of `std::map` for storing the metadata objects for blob files, which can improve performance for certain workloads, especially when the number of blob files is high.
-* DisableManualCompaction() doesn't have to wait scheduled manual compaction to be executed in thread-pool to cancel the job.
-
-### Public API changes
-* Require C++17 compatible compiler (GCC >= 7, Clang >= 5, Visual Studio >= 2017) for compiling RocksDB and any code using RocksDB headers. See #9388.
-* Added `ReadOptions::rate_limiter_priority`. When set to something other than `Env::IO_TOTAL`, the internal rate limiter (`DBOptions::rate_limiter`) will be charged at the specified priority for file reads associated with the API to which the `ReadOptions` was provided.
-* Remove HDFS support from main repo.
-* Remove librados support from main repo.
-* Remove obsolete backupable_db.h and type alias `BackupableDBOptions`. Use backup_engine.h and `BackupEngineOptions`. Similar renamings are in the C and Java APIs.
-* Removed obsolete utility_db.h and `UtilityDB::OpenTtlDB`. Use db_ttl.h and `DBWithTTL::Open`.
-* Remove deprecated API DB::AddFile from main repo.
-* Remove deprecated API ObjectLibrary::Register() and the (now obsolete) Regex public API. Use ObjectLibrary::AddFactory() with PatternEntry instead.
-* Remove deprecated option DBOption::table_cache_remove_scan_count_limit.
-* Remove deprecated API AdvancedColumnFamilyOptions::soft_rate_limit.
-* Remove deprecated API AdvancedColumnFamilyOptions::hard_rate_limit.
-* Remove deprecated API DBOption::base_background_compactions.
-* Remove deprecated API DBOptions::purge_redundant_kvs_while_flush.
-* Remove deprecated overloads of API DB::CompactRange.
-* Remove deprecated option DBOptions::skip_log_error_on_recovery.
-* Remove ReadOptions::iter_start_seqnum which has been deprecated.
-* Remove DBOptions::preserved_deletes and DB::SetPreserveDeletesSequenceNumber().
-* Remove deprecated API AdvancedColumnFamilyOptions::rate_limit_delay_max_milliseconds.
-* Removed timestamp from WriteOptions. Accordingly, added to DB APIs Put, Delete, SingleDelete, etc. accepting an additional argument 'timestamp'. Added Put, Delete, SingleDelete, etc to WriteBatch accepting an additional argument 'timestamp'. Removed WriteBatch::AssignTimestamps(vector<Slice>) API. Renamed WriteBatch::AssignTimestamp() to WriteBatch::UpdateTimestamps() with clarified comments.
-* Changed type of cache buffer passed to `Cache::CreateCallback` from `void*` to `const void*`.
-* Significant updates to FilterPolicy-related APIs and configuration:
-  * Remove public API support for deprecated, inefficient block-based filter (use_block_based_builder=true).
-    * Old code and configuration strings that would enable it now quietly enable full filters instead, though any built-in FilterPolicy can still read block-based filters. This includes changing the longstanding default behavior of the Java API.
-    * Remove deprecated FilterPolicy::CreateFilter() and FilterPolicy::KeyMayMatch()
-    * Remove `rocksdb_filterpolicy_create()` from C API, as the only C API support for custom filter policies is now obsolete.
-    * If temporary memory usage in full filter creation is a problem, consider using partitioned filters, smaller SST files, or setting reserve_table_builder_memory=true.
-  * Remove support for "filter_policy=experimental_ribbon" configuration
-  string. Use something like "filter_policy=ribbonfilter:10" instead.
-  * Allow configuration string like "filter_policy=bloomfilter:10" without
-  bool, to minimize acknowledgement of obsolete block-based filter.
-  * Made FilterPolicy Customizable. Configuration of filter_policy is now accurately saved in OPTIONS file and can be loaded with LoadOptionsFromFile. (Loading an OPTIONS file generated by a previous version only enables reading and using existing filters, not generating new filters. Previously, no filter_policy would be configured from a saved OPTIONS file.)
-  * Change meaning of nullptr return from GetBuilderWithContext() from "use
-    block-based filter" to "generate no filter in this case."
-    * Also, when user specifies bits_per_key < 0.5, we now round this down
-    to "no filter" because we expect a filter with >= 80% FP rate is
-    unlikely to be worth the CPU cost of accessing it (esp with
-    cache_index_and_filter_blocks=1 or partition_filters=1).
-    * bits_per_key >= 0.5 and < 1.0 is still rounded up to 1.0 (for 62% FP
-    rate)
-  * Remove class definitions for FilterBitsBuilder and FilterBitsReader from
-    public API, so these can evolve more easily as implementation details.
-    Custom FilterPolicy can still decide what kind of built-in filter to use
-    under what conditions.
-  * Also removed deprecated functions
-    * FilterPolicy::GetFilterBitsBuilder()
-    * NewExperimentalRibbonFilterPolicy()
-  * Remove default implementations of
-    * FilterPolicy::GetBuilderWithContext()
-* Remove default implementation of Name() from FileSystemWrapper.
-* Rename `SizeApproximationOptions.include_memtabtles` to `SizeApproximationOptions.include_memtables`.
-* Remove deprecated option DBOptions::max_mem_compaction_level.
-* Return Status::InvalidArgument from ObjectRegistry::NewObject if a factory exists but the object ould not be created (returns NotFound if the factory is missing).
-* Remove deprecated overloads of API DB::GetApproximateSizes.
-* Remove deprecated option DBOptions::new_table_reader_for_compaction_inputs.
-* Add Transaction::SetReadTimestampForValidation() and Transaction::SetCommitTimestamp(). Default impl returns NotSupported().
-* Add support for decimal patterns to ObjectLibrary::PatternEntry
-* Remove deprecated remote compaction APIs `CompactionService::Start()` and `CompactionService::WaitForComplete()`. Please use `CompactionService::StartV2()`, `CompactionService::WaitForCompleteV2()` instead, which provides the same information plus extra data like priority, db_id, etc.
-* `ColumnFamilyOptions::OldDefaults` and `DBOptions::OldDefaults` are marked deprecated, as they are no longer maintained.
-* Add subcompaction callback APIs: `OnSubcompactionBegin()` and `OnSubcompactionCompleted()`.
-* Add file Temperature information to `FileOperationInfo` in event listener API.
-* Change the type of SizeApproximationFlags from enum to enum class. Also update the signature of DB::GetApproximateSizes API from uint8_t to SizeApproximationFlags.
-* Add Temperature hints information from RocksDB in API `NewSequentialFile()`. backup and checkpoint operations need to open the source files with `NewSequentialFile()`, which will have the temperature hints. Other operations are not covered.
-
-### Behavior Changes
-* Disallow the combination of DBOptions.use_direct_io_for_flush_and_compaction == true and DBOptions.writable_file_max_buffer_size == 0. This combination can cause WritableFileWriter::Append() to loop forever, and it does not make much sense in direct IO.
-* `ReadOptions::total_order_seek` no longer affects `DB::Get()`. The original motivation for this interaction has been obsolete since RocksDB has been able to detect whether the current prefix extractor is compatible with that used to generate table files, probably RocksDB 5.14.0.
-
-## New Features
-* Introduced an option `BlockBasedTableOptions::detect_filter_construct_corruption` for detecting corruption during Bloom Filter (format_version >= 5) and Ribbon Filter construction.
-* Improved the SstDumpTool to read the comparator from table properties and use it to read the SST File.
-* Extended the column family statistics in the info log so the total amount of garbage in the blob files and the blob file space amplification factor are also logged. Also exposed the blob file space amp via the `rocksdb.blob-stats` DB property.
-* Introduced the API rocksdb_create_dir_if_missing in c.h that calls underlying file system's CreateDirIfMissing API to create the directory.
-* Added last level and non-last level read statistics: `LAST_LEVEL_READ_*`, `NON_LAST_LEVEL_READ_*`.
-* Experimental: Add support for new APIs ReadAsync in FSRandomAccessFile that reads the data asynchronously and Poll API in FileSystem that checks if requested read request has completed or not. ReadAsync takes a callback function. Poll API checks for completion of read IO requests and  should call callback functions to indicate completion of read requests.
-
-## 6.29.0 (01/21/2022)
-Note: The next release will be major release 7.0. See https://github.com/facebook/rocksdb/issues/9390 for more info.
-### Public API change
-* Added values to `TraceFilterType`: `kTraceFilterIteratorSeek`, `kTraceFilterIteratorSeekForPrev`, and `kTraceFilterMultiGet`. They can be set in `TraceOptions` to filter out the operation types after which they are named.
-* Added `TraceOptions::preserve_write_order`. When enabled it  guarantees write records are traced in the same order they are logged to WAL and applied to the DB. By default it is disabled (false) to match the legacy behavior and prevent regression.
-* Made the Env class extend the Customizable class.  Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method.
-* `Options::OldDefaults` is marked deprecated, as it is no longer maintained.
-* Add ObjectLibrary::AddFactory and ObjectLibrary::PatternEntry classes.  This method and associated class are the preferred mechanism for registering factories with the ObjectLibrary going forward.  The ObjectLibrary::Register method, which uses regular expressions and may be problematic, is deprecated and will be in a future release.
-* Changed `BlockBasedTableOptions::block_size` from `size_t` to `uint64_t`.
-* Added API warning against using `Iterator::Refresh()` together with `DB::DeleteRange()`, which are incompatible and have always risked causing the refreshed iterator to return incorrect results.
-* Made `AdvancedColumnFamilyOptions.bottommost_temperature` dynamically changeable with `SetOptions()`.
-
-### Behavior Changes
-* `DB::DestroyColumnFamilyHandle()` will return Status::InvalidArgument() if called with `DB::DefaultColumnFamily()`.
-* On 32-bit platforms, mmap reads are no longer quietly disabled, just discouraged.
-
-### New Features
-* Added `Options::DisableExtraChecks()` that can be used to improve peak write performance by disabling checks that should not be necessary in the absence of software logic errors or CPU+memory hardware errors. (Default options are slowly moving toward some performance overheads for extra correctness checking.)
-
-### Performance Improvements
-* Improved read performance when a prefix extractor is used (Seek, Get, MultiGet), even compared to version 6.25 baseline (see bug fix below), by optimizing the common case of prefix extractor compatible with table file and unchanging.
-
-### Bug Fixes
-* Fix a bug that FlushMemTable may return ok even flush not succeed.
-* Fixed a bug of Sync() and Fsync() not using `fcntl(F_FULLFSYNC)` on OS X and iOS.
-* Fixed a significant performance regression in version 6.26 when a prefix extractor is used on the read path (Seek, Get, MultiGet). (Excessive time was spent in SliceTransform::AsString().)
-* Fixed a race condition in SstFileManagerImpl error recovery code that can cause a crash during process shutdown.
-
-### New Features
-* Added RocksJava support for MacOS universal binary (ARM+x86)
-
-## 6.28.0 (2021-12-17)
-### New Features
-* Introduced 'CommitWithTimestamp' as a new tag. Currently, there is no API for user to trigger a write with this tag to the WAL. This is part of the efforts to support write-commited transactions with user-defined timestamps.
-* Introduce SimulatedHybridFileSystem which can help simulating HDD latency in db_bench. Tiered Storage latency simulation can be enabled using -simulate_hybrid_fs_file (note that it doesn't work if db_bench is interrupted in the middle). -simulate_hdd can also be used to simulate all files on HDD.
-
-### Bug Fixes
-* Fixed a bug in rocksdb automatic implicit prefetching which got broken because of new feature adaptive_readahead and internal prefetching got disabled when iterator moves from one file to next.
-* Fixed a bug in TableOptions.prepopulate_block_cache which causes segmentation fault when used with TableOptions.partition_filters = true and TableOptions.cache_index_and_filter_blocks = true.
-* Fixed a bug affecting custom memtable factories which are not registered with the `ObjectRegistry`. The bug could result in failure to save the OPTIONS file.
-* Fixed a bug causing two duplicate entries to be appended to a file opened in non-direct mode and tracked by `FaultInjectionTestFS`.
-* Fixed a bug in TableOptions.prepopulate_block_cache to support block-based filters also.
-* Block cache keys no longer use `FSRandomAccessFile::GetUniqueId()` (previously used when available), so a filesystem recycling unique ids can no longer lead to incorrect result or crash (#7405). For files generated by RocksDB >= 6.24, the cache keys are stable across DB::Open and DB directory move / copy / import / export / migration, etc. Although collisions are still theoretically possible, they are (a) impossible in many common cases, (b) not dependent on environmental factors, and (c) much less likely than a CPU miscalculation while executing RocksDB.
-* Fixed a bug in C bindings causing iterator to return incorrect result (#9343).
-
-### Behavior Changes
-* MemTableList::TrimHistory now use allocated bytes when max_write_buffer_size_to_maintain > 0(default in TrasactionDB, introduced in PR#5022) Fix #8371.
-
-### Public API change
-* Extend WriteBatch::AssignTimestamp and AssignTimestamps API so that both functions can accept an optional `checker` argument that performs additional checking on timestamp sizes.
-* Introduce a new EventListener callback that will be called upon the end of automatic error recovery.
-* Add IncreaseFullHistoryTsLow API so users can advance each column family's full_history_ts_low seperately.
-* Add GetFullHistoryTsLow API so users can query current full_history_low value of specified column family.
-
-### Performance Improvements
-* Replaced map property `TableProperties::properties_offsets`  with uint64_t property `external_sst_file_global_seqno_offset` to save table properties's memory.
-* Block cache accesses are faster by RocksDB using cache keys of fixed size (16 bytes).
-
-### Java API Changes
-* Removed Java API `TableProperties.getPropertiesOffsets()` as it exposed internal details to external users.
-
-## 6.27.0 (2021-11-19)
 ### New Features
 * Added new ChecksumType kXXH3 which is faster than kCRC32c on almost all x86\_64 hardware.
 * Added a new online consistency check for BlobDB which validates that the number/total size of garbage blobs does not exceed the number/total size of all blobs in any given blob file.
-* Provided support for tracking per-sst user-defined timestamp information in MANIFEST.
-* Added new option "adaptive_readahead" in ReadOptions. For iterators, RocksDB does auto-readahead on noticing sequential reads and by enabling this option, readahead_size of current file (if reads are sequential) will be carried forward to next file instead of starting from the scratch at each level (except L0 level files). If reads are not sequential it will fall back to 8KB. This option is applicable only for RocksDB internal prefetch buffer and isn't supported with underlying file system prefetching.
-* Added the read count and read bytes related stats to Statistics for tiered storage hot, warm, and cold file reads.
-* Added an option to dynamically charge an updating estimated memory usage of block-based table building to block cache if block cache available. It currently only includes charging memory usage of constructing (new) Bloom Filter and Ribbon Filter to block cache. To enable this feature, set `BlockBasedTableOptions::reserve_table_builder_memory = true`.
-* Add a new API OnIOError in listener.h that notifies listeners when an IO error occurs during FileSystem operation along with filename, status etc.
-* Added compaction readahead support for blob files to the integrated BlobDB implementation, which can improve compaction performance when the database resides on higher-latency storage like HDDs or remote filesystems. Readahead can be configured using the column family option `blob_compaction_readahead_size`.
 
 ### Bug Fixes
 * Prevent a `CompactRange()` with `CompactRangeOptions::change_level == true` from possibly causing corruption to the LSM state (overlapping files within a level) when run in parallel with another manual compaction. Note that setting `force_consistency_checks == true` (the default) would cause the DB to enter read-only mode in this scenario and return `Status::Corruption`, rather than committing any corruption.
@@ -579,38 +11,23 @@ Note: The next release will be major release 7.0. See https://github.com/faceboo
 * EventListener::OnTableFileCreated was previously called with OK status and file_size==0 in cases of no SST file contents written (because there was no content to add) and the empty file deleted before calling the listener. Now the status is Aborted.
 * Fixed a bug in CompactionIterator when write-preared transaction is used. Releasing earliest_snapshot during compaction may cause a SingleDelete to be output after a PUT of the same user key whose seq has been zeroed.
 * Added input sanitization on negative bytes passed into `GenericRateLimiter::Request`.
-* Fixed an assertion failure in CompactionIterator when write-prepared transaction is used. We prove that certain operations can lead to a Delete being followed by a SingleDelete (same user key). We can drop the SingleDelete.
-* Fixed a bug of timestamp-based GC which can cause all versions of a key under full_history_ts_low to be dropped. This bug will be triggered when some of the ikeys' timestamps are lower than full_history_ts_low, while others are newer.
-* In some cases outside of the DB read and compaction paths, SST block checksums are now checked where they were not before.
-* Explicitly check for and disallow the `BlockBasedTableOptions` if insertion into one of {`block_cache`, `block_cache_compressed`, `persistent_cache`} can show up in another of these. (RocksDB expects to be able to use the same key for different physical data among tiers.)
-* Users who configured a dedicated thread pool for bottommost compactions by explicitly adding threads to the `Env::Priority::BOTTOM` pool will no longer see RocksDB schedule automatic compactions exceeding the DB's compaction concurrency limit. For details on per-DB compaction concurrency limit, see API docs of `max_background_compactions` and `max_background_jobs`.
-* Fixed a bug of background flush thread picking more memtables to flush and prematurely advancing column family's log_number.
-* Fixed an assertion failure in ManifestTailer.
-* Fixed a bug that could, with WAL enabled, cause backups, checkpoints, and `GetSortedWalFiles()` to fail randomly with an error like `IO error: 001234.log: No such file or directory`
 
 ### Behavior Changes
 * `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files.
-* `TransactionUtil::CheckKeyForConflicts` can also perform conflict-checking based on user-defined timestamps in addition to sequence numbers.
-* Removed `GenericRateLimiter`'s minimum refill bytes per period previously enforced.
+
+### Public Interface Change
+* When options.ttl is used with leveled compaction with compactinon priority kMinOverlappingRatio, files exceeding half of TTL value will be prioritized more, so that by the time TTL is reached, fewer extra compactions will be scheduled to clear them up. At the same time, when compacting files with data older than half of TTL, output files may be cut off based on those files' boundaries, in order for the early TTL compaction to work properly.
 
 ### Public API change
-* When options.ttl is used with leveled compaction with compactinon priority kMinOverlappingRatio, files exceeding half of TTL value will be prioritized more, so that by the time TTL is reached, fewer extra compactions will be scheduled to clear them up. At the same time, when compacting files with data older than half of TTL, output files may be cut off based on those files' boundaries, in order for the early TTL compaction to work properly.
-* Made FileSystem and RateLimiter extend the Customizable class and added a CreateFromString method.  Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method.
+* Made FileSystem extend the Customizable class and added a CreateFromString method.  Implementations need to be registered with the ObjectRegistry and to implement a Name() method in order to be created via this method.
 * Clarified in API comments that RocksDB is not exception safe for callbacks and custom extensions. An exception propagating into RocksDB can lead to undefined behavior, including data loss, unreported corruption, deadlocks, and more.
 * Marked `WriteBufferManager` as `final` because it is not intended for extension.
-* Removed unimportant implementation details from table_properties.h
 * Add API `FSDirectory::FsyncWithDirOptions()`, which provides extra information like directory fsync reason in `DirFsyncOptions`. File system like btrfs is using that to skip directory fsync for creating a new file, or when renaming a file, fsync the target file instead of the directory, which improves the `DB::Open()` speed by ~20%.
 * `DB::Open()` is not going be blocked by obsolete file purge if `DBOptions::avoid_unnecessary_blocking_io` is set to true.
-* In builds where glibc provides `gettid()`, info log ("LOG" file) lines now print a system-wide thread ID from `gettid()` instead of the process-local `pthread_self()`. For all users, the thread ID format is changed from hexadecimal to decimal integer.
-* In builds where glibc provides `pthread_setname_np()`, the background thread names no longer contain an ID suffix. For example, "rocksdb:bottom7" (and all other threads in the `Env::Priority::BOTTOM` pool) are now named "rocksdb:bottom". Previously large thread pools could breach the name size limit (e.g., naming "rocksdb:bottom10" would fail).
-* Deprecating `ReadOptions::iter_start_seqnum` and `DBOptions::preserve_deletes`, please try using user defined timestamp feature instead. The options will be removed in a future release, currently it logs a warning message when using.
 
 ### Performance Improvements
 * Released some memory related to filter construction earlier in `BlockBasedTableBuilder` for `FullFilter` and `PartitionedFilter` case (#9070)
 
-### Behavior Changes
-* `NUM_FILES_IN_SINGLE_COMPACTION` was only counting the first input level files, now it's including all input files.
-
 ## 6.26.0 (2021-10-20)
 ### Bug Fixes
 * Fixes a bug in directed IO mode when calling MultiGet() for blobs in the same blob file. The bug is caused by not sorting the blob read requests by file offsets.
@@ -622,7 +39,6 @@ Note: The next release will be major release 7.0. See https://github.com/faceboo
 * Fixed a bug where stalled writes would remain stalled forever after the user calls `WriteBufferManager::SetBufferSize()` with `new_size == 0` to dynamically disable memory limiting.
 * Make `DB::close()` thread-safe.
 * Fix a bug in atomic flush where one bg flush thread will wait forever for a preceding bg flush thread to commit its result to MANIFEST but encounters an error which is mapped to a soft error (DB not stopped).
-* Fix a bug in `BackupEngine` where some internal callers of `GenericRateLimiter::Request()` do not honor `bytes <= GetSingleBurstBytes()`.
 
 ### New Features
 * Print information about blob files when using "ldb list_live_files_metadata"
@@ -2039,7 +1455,7 @@ if set to something > 0 user will see 2 changes in iterators behavior 1) only ke
 * Added a new way to report QPS from db_bench (check out --report_file and --report_interval_seconds)
 * Added a cache for individual rows. See DBOptions::row_cache for more info.
 * Several new features on EventListener (see include/rocksdb/listener.h):
- - OnCompactionCompleted() now returns per-compaction job statistics, defined in include/rocksdb/compaction_job_stats.h.
+ - OnCompationCompleted() now returns per-compaction job statistics, defined in include/rocksdb/compaction_job_stats.h.
  - Added OnTableFileCreated() and OnTableFileDeleted().
 * Add compaction_options_universal.enable_trivial_move to true, to allow trivial move while performing universal compaction. Trivial move will happen only when all the input files are non overlapping.
 

INSTALL.md

@@ -6,7 +6,7 @@ than release mode.
 
 RocksDB's library should be able to compile without any dependency installed,
 although we recommend installing some compression libraries (see below).
-We do depend on newer gcc/clang with C++17 support (GCC >= 7, Clang >= 5).
+We do depend on newer gcc/clang with C++11 support.
 
 There are few options when compiling RocksDB:
 
@@ -47,12 +47,10 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
 
 * If you wish to build the RocksJava static target, then cmake is required for building Snappy.
 
-* If you wish to run microbench (e.g, `make microbench`, `make ribbon_bench` or `cmake -DWITH_BENCHMARK=1`), Google benchmark >= 1.6.0 is needed.
-
 ## Supported platforms
 
 * **Linux - Ubuntu**
-    * Upgrade your gcc to version at least 7 to get C++17 support.
+    * Upgrade your gcc to version at least 4.8 to get C++11 support.
     * Install gflags. First, try: `sudo apt-get install libgflags-dev`
       If this doesn't work and you're using Ubuntu, here's a nice tutorial:
       (http://askubuntu.com/questions/312173/installing-gflags-12-04)
@@ -64,7 +62,8 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
     * Install zstandard: `sudo apt-get install libzstd-dev`.
 
 * **Linux - CentOS / RHEL**
-    * Upgrade your gcc to version at least 7 to get C++17 support
+    * Upgrade your gcc to version at least 4.8 to get C++11 support:
+      `yum install gcc48-c++`
     * Install gflags:
 
               git clone https://github.com/gflags/gflags.git
@@ -114,11 +113,11 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
               make && sudo make install
 
 * **OS X**:
-    * Install latest C++ compiler that supports C++ 17:
+    * Install latest C++ compiler that supports C++ 11:
         * Update XCode:  run `xcode-select --install` (or install it from XCode App's settting).
         * Install via [homebrew](http://brew.sh/).
             * If you're first time developer in MacOS, you still need to run: `xcode-select --install` in your command line.
-            * run `brew tap homebrew/versions; brew install gcc7 --use-llvm` to install gcc 7 (or higher).
+            * run `brew tap homebrew/versions; brew install gcc48 --use-llvm` to install gcc 4.8 (or higher).
     * run `brew install rocksdb`
 
 * **FreeBSD** (11.01):
@@ -161,7 +160,7 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
 
     * Install the dependencies for RocksDB:
 
-        pkg_add gmake gflags snappy bzip2 lz4 zstd git jdk bash findutils gnuwatch
+        pkg_add gmake gflags snappy bzip2 lz4 zstd git jdk bash findutils gnuwatch 
 
     * Build RocksDB from source:
 
@@ -178,17 +177,18 @@ 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 an important pre-processing macros: `IOS_CROSS_COMPILE`.
+  * 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`.
 
-* **Windows** (Visual Studio 2017 to up):
+* **Windows**:
+  * For building with MS Visual Studio 13 you will need Update 4 installed.
   * Read and follow the instructions at CMakeLists.txt
-  * Or install via [vcpkg](https://github.com/microsoft/vcpkg)
+  * Or install via [vcpkg](https://github.com/microsoft/vcpkg) 
        * run `vcpkg install rocksdb:x64-windows`
 
 * **AIX 6.1**
     * Install AIX Toolbox rpms with gcc
     * Use these environment variables:
-
+  
              export PORTABLE=1
              export CC=gcc
              export AR="ar -X64"
@@ -199,9 +199,9 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
              export LIBPATH=/opt/freeware/lib
              export JAVA_HOME=/usr/java8_64
              export PATH=/opt/freeware/bin:$PATH
-
+  
 * **Solaris Sparc**
-    * Install GCC 7 and higher.
+    * Install GCC 4.8.2 and higher.
     * Use these environment variables:
 
              export CC=gcc
@@ -210,3 +210,4 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
              export EXTRA_LDFLAGS=-m64
              export PORTABLE=1
              export PLATFORM_LDFLAGS="-static-libstdc++ -static-libgcc"
+

LANGUAGE-BINDINGS.md

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

PLUGINS.md

@@ -1,7 +1,4 @@
 This is the list of all known third-party plugins for RocksDB. If something is missing, please open a pull request to add it.
 
 * [Dedupfs](https://github.com/ajkr/dedupfs): an example for plugin developers to reference
-* [HDFS](https://github.com/riversand963/rocksdb-hdfs-env): an Env used for interacting with HDFS. Migrated from main RocksDB repo
 * [ZenFS](https://github.com/westerndigitalcorporation/zenfs): a file system for zoned block devices
-* [RADOS](https://github.com/riversand963/rocksdb-rados-env): an Env used for interacting with RADOS. Migrated from RocksDB main repo.
-* [PMEM](https://github.com/pmem/pmem-rocksdb-plugin): a collection of plugins to enable Persistent Memory on RocksDB.

README.md

@@ -1,6 +1,7 @@
 ## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage
 
 [![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
+[![TravisCI Status](https://api.travis-ci.com/facebook/rocksdb.svg?branch=main)](https://travis-ci.com/github/facebook/rocksdb)
 [![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/main?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/main)
 [![PPC64le Build Status](http://140-211-168-68-openstack.osuosl.org:8080/buildStatus/icon?job=rocksdb&style=plastic)](http://140-211-168-68-openstack.osuosl.org:8080/job/rocksdb)
 
@@ -24,7 +25,7 @@ The public interface is in `include/`.  Callers should not include or
 rely on the details of any other header files in this package.  Those
 internal APIs may be changed without warning.
 
-Questions and discussions are welcome on the [RocksDB Developers Public](https://www.facebook.com/groups/rocksdb.dev/) Facebook group and [email list](https://groups.google.com/g/rocksdb) on Google Groups.
+Design discussions are conducted in https://www.facebook.com/groups/rocksdb.dev/ and https://rocksdb.slack.com/
 
 ## License
 

ROCKSDB_LITE.md

@@ -0,0 +1,21 @@
+# 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 backupable DB
+* 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. :)

USERS.md

@@ -79,9 +79,6 @@ 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.
 
@@ -124,8 +121,6 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed
 ## Kafka
 [Kafka](https://kafka.apache.org/) is an open-source distributed event streaming platform, it uses RocksDB to store state in Kafka Streams: https://www.confluent.io/blog/how-to-tune-rocksdb-kafka-streams-state-stores-performance/.
 
-## Solana Labs
-[Solana](https://github.com/solana-labs/solana) is a fast, secure, scalable, and decentralized blockchain.  It uses RocksDB as the underlying storage for its ledger store.
-
 ## Others
 More databases using RocksDB can be found at [dbdb.io](https://dbdb.io/browse?embeds=rocksdb).
+

appveyor.yml

@@ -0,0 +1,77 @@
+version: 1.0.{build}
+
+image: Visual Studio 2019
+
+environment:
+  JAVA_HOME: C:\Program Files\Java\jdk1.8.0
+  THIRDPARTY_HOME: $(APPVEYOR_BUILD_FOLDER)\thirdparty
+  SNAPPY_HOME: $(THIRDPARTY_HOME)\snappy-1.1.7
+  SNAPPY_INCLUDE: $(SNAPPY_HOME);$(SNAPPY_HOME)\build
+  SNAPPY_LIB_DEBUG: $(SNAPPY_HOME)\build\Debug\snappy.lib
+  SNAPPY_LIB_RELEASE: $(SNAPPY_HOME)\build\Release\snappy.lib
+  LZ4_HOME: $(THIRDPARTY_HOME)\lz4-1.8.3
+  LZ4_INCLUDE: $(LZ4_HOME)\lib
+  LZ4_LIB_DEBUG: $(LZ4_HOME)\visual\VS2010\bin\x64_Debug\liblz4_static.lib
+  LZ4_LIB_RELEASE: $(LZ4_HOME)\visual\VS2010\bin\x64_Release\liblz4_static.lib
+  ZSTD_HOME: $(THIRDPARTY_HOME)\zstd-1.4.0
+  ZSTD_INCLUDE: $(ZSTD_HOME)\lib;$(ZSTD_HOME)\lib\dictBuilder
+  ZSTD_LIB_DEBUG: $(ZSTD_HOME)\build\VS2010\bin\x64_Debug\libzstd_static.lib
+  ZSTD_LIB_RELEASE: $(ZSTD_HOME)\build\VS2010\bin\x64_Release\libzstd_static.lib
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_GENERATOR: Visual Studio 14 Win64
+      DEV_ENV: C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.com
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_GENERATOR: Visual Studio 15 Win64
+      DEV_ENV: C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\devenv.com
+
+install:
+  - md %THIRDPARTY_HOME%
+  - echo "Building Snappy dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output snappy-1.1.7.zip --location https://github.com/google/snappy/archive/1.1.7.zip
+  - unzip snappy-1.1.7.zip
+  - cd snappy-1.1.7
+  - mkdir build
+  - cd build
+  - if DEFINED CMAKE_PLATEFORM_NAME (set "PLATEFORM_OPT=-A %CMAKE_PLATEFORM_NAME%")
+  - cmake .. -G "%CMAKE_GENERATOR%" %PLATEFORM_OPT%
+  - msbuild Snappy.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild Snappy.sln /p:Configuration=Release /p:Platform=x64
+  - echo "Building LZ4 dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output lz4-1.8.3.zip --location https://github.com/lz4/lz4/archive/v1.8.3.zip
+  - unzip lz4-1.8.3.zip
+  - cd lz4-1.8.3\visual\VS2010
+  - ps: $CMD="$Env:DEV_ENV"; & $CMD lz4.sln /upgrade
+  - msbuild lz4.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild lz4.sln /p:Configuration=Release /p:Platform=x64
+  - echo "Building ZStd dependency..."
+  - cd %THIRDPARTY_HOME%
+  - curl --fail --silent --show-error --output zstd-1.4.0.zip --location https://github.com/facebook/zstd/archive/v1.4.0.zip
+  - unzip zstd-1.4.0.zip
+  - cd zstd-1.4.0\build\VS2010
+  - ps: $CMD="$Env:DEV_ENV"; & $CMD zstd.sln /upgrade
+  - msbuild zstd.sln /p:Configuration=Debug /p:Platform=x64
+  - msbuild zstd.sln /p:Configuration=Release /p:Platform=x64
+
+before_build:
+  - md %APPVEYOR_BUILD_FOLDER%\build
+  - cd %APPVEYOR_BUILD_FOLDER%\build
+  - if DEFINED CMAKE_PLATEFORM_NAME (set "PLATEFORM_OPT=-A %CMAKE_PLATEFORM_NAME%")
+  - cmake .. -G "%CMAKE_GENERATOR%" %PLATEFORM_OPT% %CMAKE_OPT% -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE=1 -DSNAPPY=1 -DLZ4=1 -DZSTD=1 -DXPRESS=1 -DJNI=1 -DWITH_ALL_TESTS=0
+  - cd ..
+
+build:
+  project: build\rocksdb.sln
+  parallel: true
+  verbosity: normal
+
+test:
+
+test_script:
+  - ps: build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,env_basic_test -Concurrency 8
+
+on_failure:
+  - cmd: 7z a build-failed.zip %APPVEYOR_BUILD_FOLDER%\build\ && appveyor PushArtifact build-failed.zip
+

buckifier/buckify_rocksdb.py

@@ -1,18 +1,18 @@
-#!/usr/bin/env python3
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-from __future__ import absolute_import, division, print_function, unicode_literals
-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 try:
     from builtins import str
 except ImportError:
     from __builtin__ import str
-import fnmatch
+from targets_builder import TARGETSBuilder
 import json
 import os
+import fnmatch
 import sys
 
-from targets_builder import TARGETSBuilder
-
 from util import ColorString
 
 # This script generates TARGETS file for Buck.
@@ -26,7 +26,7 @@ from util import ColorString
 # $python3 buckifier/buckify_rocksdb.py \
 #        '{"fake": {
 #                      "extra_deps": [":test_dep", "//fakes/module:mock1"],
-#                      "extra_compiler_flags": ["-DFOO_BAR", "-Os"]
+#                      "extra_compiler_flags": ["-DROCKSDB_LITE", "-Os"]
 #                  }
 #         }'
 # (Generated TARGETS file has test_dep and mock1 as dependencies for RocksDB
@@ -43,13 +43,13 @@ def parse_src_mk(repo_path):
     src_files = {}
     for line in open(src_mk):
         line = line.strip()
-        if len(line) == 0 or line[0] == "#":
+        if len(line) == 0 or line[0] == '#':
             continue
-        if "=" in line:
-            current_src = line.split("=")[0].strip()
+        if '=' in line:
+            current_src = line.split('=')[0].strip()
             src_files[current_src] = []
-        elif ".c" in line:
-            src_path = line.split("\\")[0].strip()
+        elif '.c' in line:
+            src_path = line.split('\\')[0].strip()
             src_files[current_src].append(src_path)
     return src_files
 
@@ -57,16 +57,14 @@ def parse_src_mk(repo_path):
 # get all .cc / .c files
 def get_cc_files(repo_path):
     cc_files = []
-    for root, _dirnames, filenames in os.walk(
-        repo_path
-    ):  # noqa: B007 T25377293 Grandfathered in
-        root = root[(len(repo_path) + 1) :]
+    for root, dirnames, filenames in os.walk(repo_path):  # noqa: B007 T25377293 Grandfathered in
+        root = root[(len(repo_path) + 1):]
         if "java" in root:
             # Skip java
             continue
-        for filename in fnmatch.filter(filenames, "*.cc"):
+        for filename in fnmatch.filter(filenames, '*.cc'):
             cc_files.append(os.path.join(root, filename))
-        for filename in fnmatch.filter(filenames, "*.c"):
+        for filename in fnmatch.filter(filenames, '*.c'):
             cc_files.append(os.path.join(root, filename))
     return cc_files
 
@@ -94,10 +92,14 @@ def get_non_parallel_tests(repo_path):
 
     return s
 
-
 # Parse extra dependencies passed by user from command line
 def get_dependencies():
-    deps_map = {"": {"extra_deps": [], "extra_compiler_flags": []}}
+    deps_map = {
+        '': {
+            'extra_deps': [],
+            'extra_compiler_flags': []
+        }
+    }
     if len(sys.argv) < 2:
         return deps_map
 
@@ -108,7 +110,6 @@ def get_dependencies():
                 v = encode_dict(v)
             rv[k] = v
         return rv
-
     extra_deps = json.loads(sys.argv[1], object_hook=encode_dict)
     for target_alias, deps in extra_deps.items():
         deps_map[target_alias] = deps
@@ -141,139 +142,66 @@ def generate_targets(repo_path, deps_map):
         "rocksdb_lib",
         src_mk["LIB_SOURCES"] +
         # always add range_tree, it's only excluded on ppc64, which we don't use internally
-        src_mk["RANGE_TREE_SOURCES"] + src_mk["TOOL_LIB_SOURCES"],
-        deps=[
-            "//folly/container:f14_hash",
-            "//folly/experimental/coro:blocking_wait",
-            "//folly/experimental/coro:collect",
-            "//folly/experimental/coro:coroutine",
-            "//folly/experimental/coro:task",
-            "//folly/synchronization:distributed_mutex",
-        ],
-    )
+        src_mk["RANGE_TREE_SOURCES"] +
+        src_mk["TOOL_LIB_SOURCES"])
     # rocksdb_whole_archive_lib
     TARGETS.add_library(
         "rocksdb_whole_archive_lib",
         src_mk["LIB_SOURCES"] +
         # always add range_tree, it's only excluded on ppc64, which we don't use internally
-        src_mk["RANGE_TREE_SOURCES"] + src_mk["TOOL_LIB_SOURCES"],
-        deps=[
-            "//folly/container:f14_hash",
-            "//folly/experimental/coro:blocking_wait",
-            "//folly/experimental/coro:collect",
-            "//folly/experimental/coro:coroutine",
-            "//folly/experimental/coro:task",
-            "//folly/synchronization:distributed_mutex",
-        ],
+        src_mk["RANGE_TREE_SOURCES"] +
+        src_mk["TOOL_LIB_SOURCES"],
+        deps=None,
         headers=None,
         extra_external_deps="",
-        link_whole=True,
-    )
+        link_whole=True)
     # rocksdb_test_lib
     TARGETS.add_library(
         "rocksdb_test_lib",
-        src_mk.get("MOCK_LIB_SOURCES", [])
-        + src_mk.get("TEST_LIB_SOURCES", [])
-        + src_mk.get("EXP_LIB_SOURCES", [])
-        + src_mk.get("ANALYZER_LIB_SOURCES", []),
+        src_mk.get("MOCK_LIB_SOURCES", []) +
+        src_mk.get("TEST_LIB_SOURCES", []) +
+        src_mk.get("EXP_LIB_SOURCES", []) +
+        src_mk.get("ANALYZER_LIB_SOURCES", []),
         [":rocksdb_lib"],
-        extra_test_libs=True,
-    )
+        extra_external_deps=""" + [
+        ("googletest", None, "gtest"),
+    ]""")
     # rocksdb_tools_lib
     TARGETS.add_library(
         "rocksdb_tools_lib",
-        src_mk.get("BENCH_LIB_SOURCES", [])
-        + src_mk.get("ANALYZER_LIB_SOURCES", [])
-        + ["test_util/testutil.cc"],
-        [":rocksdb_lib"],
-    )
+        src_mk.get("BENCH_LIB_SOURCES", []) +
+        src_mk.get("ANALYZER_LIB_SOURCES", []) +
+        ["test_util/testutil.cc"],
+        [":rocksdb_lib"])
     # rocksdb_cache_bench_tools_lib
     TARGETS.add_library(
         "rocksdb_cache_bench_tools_lib",
         src_mk.get("CACHE_BENCH_LIB_SOURCES", []),
-        [":rocksdb_lib"],
-    )
+        [":rocksdb_lib"])
     # rocksdb_stress_lib
     TARGETS.add_rocksdb_library(
         "rocksdb_stress_lib",
         src_mk.get("ANALYZER_LIB_SOURCES", [])
-        + src_mk.get("STRESS_LIB_SOURCES", [])
-        + ["test_util/testutil.cc"],
-    )
-    # db_stress binary
-    TARGETS.add_binary(
-        "db_stress", ["db_stress_tool/db_stress.cc"], [":rocksdb_stress_lib"]
-    )
-    # bench binaries
-    for src in src_mk.get("MICROBENCH_SOURCES", []):
-        name = src.rsplit("/", 1)[1].split(".")[0] if "/" in src else src.split(".")[0]
-        TARGETS.add_binary(name, [src], [], extra_bench_libs=True)
+        + src_mk.get('STRESS_LIB_SOURCES', [])
+        + ["test_util/testutil.cc"])
+
     print("Extra dependencies:\n{0}".format(json.dumps(deps_map)))
 
     # Dictionary test executable name -> relative source file path
     test_source_map = {}
+    print(src_mk)
 
     # c_test.c is added through TARGETS.add_c_test(). If there
     # are more than one .c test file, we need to extend
     # TARGETS.add_c_test() to include other C tests too.
     for test_src in src_mk.get("TEST_MAIN_SOURCES_C", []):
-        if test_src != "db/c_test.c":
+        if test_src != 'db/c_test.c':
             print("Don't know how to deal with " + test_src)
             return False
     TARGETS.add_c_test()
 
-    try:
-        with open(f"{repo_path}/buckifier/bench.json") as json_file:
-            fast_fancy_bench_config_list = json.load(json_file)
-            for config_dict in fast_fancy_bench_config_list:
-                clean_benchmarks = {}
-                benchmarks = config_dict["benchmarks"]
-                for binary, benchmark_dict in benchmarks.items():
-                    clean_benchmarks[binary] = {}
-                    for benchmark, overloaded_metric_list in benchmark_dict.items():
-                        clean_benchmarks[binary][benchmark] = []
-                        for metric in overloaded_metric_list:
-                            if not isinstance(metric, dict):
-                                clean_benchmarks[binary][benchmark].append(metric)
-                TARGETS.add_fancy_bench_config(
-                    config_dict["name"],
-                    clean_benchmarks,
-                    False,
-                    config_dict["expected_runtime_one_iter"],
-                    config_dict["sl_iterations"],
-                    config_dict["regression_threshold"],
-                )
-
-        with open(f"{repo_path}/buckifier/bench-slow.json") as json_file:
-            slow_fancy_bench_config_list = json.load(json_file)
-            for config_dict in slow_fancy_bench_config_list:
-                clean_benchmarks = {}
-                benchmarks = config_dict["benchmarks"]
-                for binary, benchmark_dict in benchmarks.items():
-                    clean_benchmarks[binary] = {}
-                    for benchmark, overloaded_metric_list in benchmark_dict.items():
-                        clean_benchmarks[binary][benchmark] = []
-                        for metric in overloaded_metric_list:
-                            if not isinstance(metric, dict):
-                                clean_benchmarks[binary][benchmark].append(metric)
-            for config_dict in slow_fancy_bench_config_list:
-                TARGETS.add_fancy_bench_config(
-                    config_dict["name"] + "_slow",
-                    clean_benchmarks,
-                    True,
-                    config_dict["expected_runtime_one_iter"],
-                    config_dict["sl_iterations"],
-                    config_dict["regression_threshold"],
-                )
-    # it is better servicelab experiments break
-    # than rocksdb github ci
-    except Exception:
-        pass
-
-    TARGETS.add_test_header()
-
     for test_src in src_mk.get("TEST_MAIN_SOURCES", []):
-        test = test_src.split(".c")[0].strip().split("/")[-1].strip()
+        test = test_src.split('.c')[0].strip().split('/')[-1].strip()
         test_source_map[test] = test_src
         print("" + test + " " + test_src)
 
@@ -283,29 +211,19 @@ def generate_targets(repo_path, deps_map):
                 print(ColorString.warning("Failed to get test name for %s" % test_src))
                 continue
 
-            test_target_name = test if not target_alias else test + "_" + target_alias
+            test_target_name = \
+                test if not target_alias else test + "_" + target_alias
+            TARGETS.register_test(
+                test_target_name,
+                test_src,
+                test not in non_parallel_tests,
+                json.dumps(deps['extra_deps']),
+                json.dumps(deps['extra_compiler_flags']))
 
             if test in _EXPORTED_TEST_LIBS:
                 test_library = "%s_lib" % test_target_name
-                TARGETS.add_library(
-                    test_library,
-                    [test_src],
-                    deps=[":rocksdb_test_lib"],
-                    extra_test_libs=True,
-                )
-                TARGETS.register_test(
-                    test_target_name,
-                    test_src,
-                    deps=json.dumps(deps["extra_deps"] + [":" + test_library]),
-                    extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
-                )
-            else:
-                TARGETS.register_test(
-                    test_target_name,
-                    test_src,
-                    deps=json.dumps(deps["extra_deps"] + [":rocksdb_test_lib"]),
-                    extra_compiler_flags=json.dumps(deps["extra_compiler_flags"]),
-                )
+                TARGETS.add_library(test_library, [test_src], [":rocksdb_test_lib"])
+    TARGETS.flush_tests()
 
     print(ColorString.info("Generated TARGETS Summary:"))
     print(ColorString.info("- %d libs" % TARGETS.total_lib))
@@ -318,7 +236,8 @@ def get_rocksdb_path():
     # rocksdb = {script_dir}/..
     script_dir = os.path.dirname(sys.argv[0])
     script_dir = os.path.abspath(script_dir)
-    rocksdb_path = os.path.abspath(os.path.join(script_dir, "../"))
+    rocksdb_path = os.path.abspath(
+        os.path.join(script_dir, "../"))
 
     return rocksdb_path
 
@@ -335,6 +254,5 @@ def main():
     if not ok:
         exit_with_error("Failed to generate TARGETS files")
 
-
 if __name__ == "__main__":
     main()

buckifier/targets_builder.py

@@ -1,150 +1,124 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-from __future__ import absolute_import, division, print_function, unicode_literals
-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 try:
-    from builtins import object, str
+    from builtins import object
+    from builtins import str
 except ImportError:
-    from __builtin__ import object, str
-import pprint
-
+    from __builtin__ import object
+    from __builtin__ import str
 import targets_cfg
 
-
 def pretty_list(lst, indent=8):
     if lst is None or len(lst) == 0:
         return ""
 
     if len(lst) == 1:
-        return '"%s"' % lst[0]
+        return "\"%s\"" % lst[0]
 
-    separator = '",\n%s"' % (" " * indent)
+    separator = "\",\n%s\"" % (" " * indent)
     res = separator.join(sorted(lst))
-    res = "\n" + (" " * indent) + '"' + res + '",\n' + (" " * (indent - 4))
+    res = "\n" + (" " * indent) + "\"" + res + "\",\n" + (" " * (indent - 4))
     return res
 
 
 class TARGETSBuilder(object):
     def __init__(self, path, extra_argv):
         self.path = path
+        self.targets_file = open(path, 'wb')
         header = targets_cfg.rocksdb_target_header_template.format(
-            extra_argv=extra_argv
-        )
-        with open(path, "wb") as targets_file:
-            targets_file.write(header.encode("utf-8"))
+            extra_argv=extra_argv)
+        self.targets_file.write(header.encode("utf-8"))
         self.total_lib = 0
         self.total_bin = 0
         self.total_test = 0
         self.tests_cfg = ""
 
-    def add_library(
-        self,
-        name,
-        srcs,
-        deps=None,
-        headers=None,
-        extra_external_deps="",
-        link_whole=False,
-        external_dependencies=None,
-        extra_test_libs=False,
-    ):
-        if headers is not None:
+    def __del__(self):
+        self.targets_file.close()
+
+    def add_library(self, name, srcs, deps=None, headers=None,
+                    extra_external_deps="", link_whole=False):
+        headers_attr_prefix = ""
+        if headers is None:
+            headers_attr_prefix = "auto_"
+            headers = "AutoHeaders.RECURSIVE_GLOB"
+        else:
             headers = "[" + pretty_list(headers) + "]"
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                targets_cfg.library_template.format(
-                    name=name,
-                    srcs=pretty_list(srcs),
-                    headers=headers,
-                    deps=pretty_list(deps),
-                    extra_external_deps=extra_external_deps,
-                    link_whole=link_whole,
-                    external_dependencies=pretty_list(external_dependencies),
-                    extra_test_libs=extra_test_libs,
-                ).encode("utf-8")
-            )
+        self.targets_file.write(targets_cfg.library_template.format(
+            name=name,
+            srcs=pretty_list(srcs),
+            headers_attr_prefix=headers_attr_prefix,
+            headers=headers,
+            deps=pretty_list(deps),
+            extra_external_deps=extra_external_deps,
+            link_whole=link_whole).encode("utf-8"))
         self.total_lib = self.total_lib + 1
 
-    def add_rocksdb_library(self, name, srcs, headers=None, external_dependencies=None):
-        if headers is not None:
+    def add_rocksdb_library(self, name, srcs, headers=None):
+        headers_attr_prefix = ""
+        if headers is None:
+            headers_attr_prefix = "auto_"
+            headers = "AutoHeaders.RECURSIVE_GLOB"
+        else:
             headers = "[" + pretty_list(headers) + "]"
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                targets_cfg.rocksdb_library_template.format(
-                    name=name,
-                    srcs=pretty_list(srcs),
-                    headers=headers,
-                    external_dependencies=pretty_list(external_dependencies),
-                ).encode("utf-8")
-            )
+        self.targets_file.write(targets_cfg.rocksdb_library_template.format(
+            name=name,
+            srcs=pretty_list(srcs),
+            headers_attr_prefix=headers_attr_prefix,
+            headers=headers).encode("utf-8"))
         self.total_lib = self.total_lib + 1
 
-    def add_binary(
-        self,
-        name,
-        srcs,
-        deps=None,
-        extra_preprocessor_flags=None,
-        extra_bench_libs=False,
-    ):
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                targets_cfg.binary_template.format(
-                    name=name,
-                    srcs=pretty_list(srcs),
-                    deps=pretty_list(deps),
-                    extra_preprocessor_flags=pretty_list(extra_preprocessor_flags),
-                    extra_bench_libs=extra_bench_libs,
-                ).encode("utf-8")
-            )
+    def add_binary(self, name, srcs, deps=None):
+        self.targets_file.write(targets_cfg.binary_template.format(
+            name=name,
+            srcs=pretty_list(srcs),
+            deps=pretty_list(deps)).encode("utf-8"))
         self.total_bin = self.total_bin + 1
 
     def add_c_test(self):
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                b"""
-add_c_test_wrapper()
-"""
-            )
+        self.targets_file.write(b"""
+cpp_binary(
+    name = "c_test_bin",
+    srcs = ["db/c_test.c"],
+    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+    compiler_flags = ROCKSDB_COMPILER_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    deps = [":rocksdb_test_lib"],
+) if not is_opt_mode else None
 
-    def add_test_header(self):
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                b"""
-        # Generate a test rule for each entry in ROCKS_TESTS
-        # Do not build the tests in opt mode, since SyncPoint and other test code
-        # will not be included.
-"""
-            )
+custom_unittest(
+    name = "c_test",
+    command = [
+        native.package_name() + "/buckifier/rocks_test_runner.sh",
+        "$(location :{})".format("c_test_bin"),
+    ],
+    type = "simple",
+) if not is_opt_mode else None
+""")
 
-    def add_fancy_bench_config(
-        self,
-        name,
-        bench_config,
-        slow,
-        expected_runtime,
-        sl_iterations,
-        regression_threshold,
-    ):
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                targets_cfg.fancy_bench_template.format(
-                    name=name,
-                    bench_config=pprint.pformat(bench_config),
-                    slow=slow,
-                    expected_runtime=expected_runtime,
-                    sl_iterations=sl_iterations,
-                    regression_threshold=regression_threshold,
-                ).encode("utf-8")
-            )
+    def register_test(self,
+                      test_name,
+                      src,
+                      is_parallel,
+                      extra_deps,
+                      extra_compiler_flags):
+        exec_mode = "serial"
+        if is_parallel:
+            exec_mode = "parallel"
+        self.tests_cfg += targets_cfg.test_cfg_template % (
+            test_name,
+            str(src),
+            str(exec_mode),
+            extra_deps,
+            extra_compiler_flags)
 
-    def register_test(self, test_name, src, deps, extra_compiler_flags):
-        with open(self.path, "ab") as targets_file:
-            targets_file.write(
-                targets_cfg.unittests_template.format(
-                    test_name=test_name,
-                    test_cc=str(src),
-                    deps=deps,
-                    extra_compiler_flags=extra_compiler_flags,
-                ).encode("utf-8")
-            )
         self.total_test = self.total_test + 1
+
+    def flush_tests(self):
+        self.targets_file.write(targets_cfg.unittests_template.format(tests=self.tests_cfg).encode("utf-8"))
+        self.tests_cfg = ""

buckifier/targets_cfg.py

@@ -1,41 +1,232 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
-rocksdb_target_header_template = """# This file \100generated by:
+rocksdb_target_header_template = \
+    """# This file \100generated by:
 #$ python3 buckifier/buckify_rocksdb.py{extra_argv}
 # --> DO NOT EDIT MANUALLY <--
 # This file is a Facebook-specific integration for buck builds, so can
 # only be validated by Facebook employees.
 #
-# @noautodeps @nocodemods
-load("//rocks/buckifier:defs.bzl", "cpp_library_wrapper","rocks_cpp_library_wrapper","cpp_binary_wrapper","cpp_unittest_wrapper","fancy_bench_wrapper","add_c_test_wrapper")
+load("@fbcode_macros//build_defs:auto_headers.bzl", "AutoHeaders")
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+load(":defs.bzl", "test_binary")
 
+REPO_PATH = package_name() + "/"
+
+ROCKSDB_COMPILER_FLAGS_0 = [
+    "-fno-builtin-memcmp",
+    # Needed to compile in fbcode
+    "-Wno-expansion-to-defined",
+    # Added missing flags from output of build_detect_platform
+    "-Wnarrowing",
+    "-DROCKSDB_NO_DYNAMIC_EXTENSION",
+]
+
+ROCKSDB_EXTERNAL_DEPS = [
+    ("bzip2", None, "bz2"),
+    ("snappy", None, "snappy"),
+    ("zlib", None, "z"),
+    ("gflags", None, "gflags"),
+    ("lz4", None, "lz4"),
+    ("zstd", None, "zstd"),
+]
+
+ROCKSDB_OS_DEPS_0 = [
+    (
+        "linux",
+        [
+            "third-party//numa:numa",
+            "third-party//liburing:uring",
+            "third-party//tbb:tbb",
+        ],
+    ),
+    (
+        "macos",
+        ["third-party//tbb:tbb"],
+    ),
+]
+
+ROCKSDB_OS_PREPROCESSOR_FLAGS_0 = [
+    (
+        "linux",
+        [
+            "-DOS_LINUX",
+            "-DROCKSDB_FALLOCATE_PRESENT",
+            "-DROCKSDB_MALLOC_USABLE_SIZE",
+            "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
+            "-DROCKSDB_RANGESYNC_PRESENT",
+            "-DROCKSDB_SCHED_GETCPU_PRESENT",
+            "-DROCKSDB_IOURING_PRESENT",
+            "-DHAVE_SSE42",
+            "-DLIBURING",
+            "-DNUMA",
+            "-DROCKSDB_PLATFORM_POSIX",
+            "-DROCKSDB_LIB_IO_POSIX",
+            "-DTBB",
+        ],
+    ),
+    (
+        "macos",
+        [
+            "-DOS_MACOSX",
+            "-DROCKSDB_PLATFORM_POSIX",
+            "-DROCKSDB_LIB_IO_POSIX",
+            "-DTBB",
+        ],
+    ),
+    (
+        "windows",
+        [
+            "-DOS_WIN",
+            "-DWIN32",
+            "-D_MBCS",
+            "-DWIN64",
+            "-DNOMINMAX",
+        ],
+    ),
+]
+
+ROCKSDB_PREPROCESSOR_FLAGS = [
+    "-DROCKSDB_SUPPORT_THREAD_LOCAL",
+
+    # Flags to enable libs we include
+    "-DSNAPPY",
+    "-DZLIB",
+    "-DBZIP2",
+    "-DLZ4",
+    "-DZSTD",
+    "-DZSTD_STATIC_LINKING_ONLY",
+    "-DGFLAGS=gflags",
+
+    # Added missing flags from output of build_detect_platform
+    "-DROCKSDB_BACKTRACE",
+]
+
+# Directories with files for #include
+ROCKSDB_INCLUDE_PATHS = [
+    "",
+    "include",
+]
+
+ROCKSDB_ARCH_PREPROCESSOR_FLAGS = {{
+    "x86_64": [
+        "-DHAVE_PCLMUL",
+    ],
+}}
+
+build_mode = read_config("fbcode", "build_mode")
+
+is_opt_mode = build_mode.startswith("opt")
+
+# -DNDEBUG is added by default in opt mode in fbcode. But adding it twice
+# doesn't harm and avoid forgetting to add it.
+ROCKSDB_COMPILER_FLAGS = ROCKSDB_COMPILER_FLAGS_0 + (["-DNDEBUG"] if is_opt_mode else [])
+
+sanitizer = read_config("fbcode", "sanitizer")
+
+# Do not enable jemalloc if sanitizer presents. RocksDB will further detect
+# whether the binary is linked with jemalloc at runtime.
+ROCKSDB_OS_PREPROCESSOR_FLAGS = ROCKSDB_OS_PREPROCESSOR_FLAGS_0 + ([(
+    "linux",
+    ["-DROCKSDB_JEMALLOC"],
+)] if sanitizer == "" else [])
+
+ROCKSDB_OS_DEPS = ROCKSDB_OS_DEPS_0 + ([(
+    "linux",
+    ["third-party//jemalloc:headers"],
+)] if sanitizer == "" else [])
+
+ROCKSDB_LIB_DEPS = [
+    ":rocksdb_lib",
+    ":rocksdb_test_lib",
+] if not is_opt_mode else [":rocksdb_lib"]
 """
 
 
 library_template = """
-cpp_library_wrapper(name="{name}", srcs=[{srcs}], deps=[{deps}], headers={headers}, link_whole={link_whole}, extra_test_libs={extra_test_libs})
+cpp_library(
+    name = "{name}",
+    srcs = [{srcs}],
+    {headers_attr_prefix}headers = {headers},
+    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+    compiler_flags = ROCKSDB_COMPILER_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    link_whole = {link_whole},
+    os_deps = ROCKSDB_OS_DEPS,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    unexported_deps_by_default = False,
+    deps = [{deps}],
+    external_deps = ROCKSDB_EXTERNAL_DEPS{extra_external_deps},
+)
 """
 
 rocksdb_library_template = """
-rocks_cpp_library_wrapper(name="{name}", srcs=[{srcs}], headers={headers})
-
+cpp_library(
+    name = "{name}",
+    srcs = [{srcs}],
+    {headers_attr_prefix}headers = {headers},
+    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+    compiler_flags = ROCKSDB_COMPILER_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    os_deps = ROCKSDB_OS_DEPS,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    unexported_deps_by_default = False,
+    deps = ROCKSDB_LIB_DEPS,
+    external_deps = ROCKSDB_EXTERNAL_DEPS,
+)
 """
 
-
 binary_template = """
-cpp_binary_wrapper(name="{name}", srcs=[{srcs}], deps=[{deps}], extra_preprocessor_flags=[{extra_preprocessor_flags}], extra_bench_libs={extra_bench_libs})
+cpp_binary(
+    name = "{name}",
+    srcs = [{srcs}],
+    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+    compiler_flags = ROCKSDB_COMPILER_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    deps = [{deps}],
+    external_deps = ROCKSDB_EXTERNAL_DEPS,
+)
+"""
+
+test_cfg_template = """    [
+        "%s",
+        "%s",
+        "%s",
+        %s,
+        %s,
+    ],
 """
 
 unittests_template = """
-cpp_unittest_wrapper(name="{test_name}",
-            srcs=["{test_cc}"],
-            deps={deps},
-            extra_compiler_flags={extra_compiler_flags})
-
-"""
-
-fancy_bench_template = """
-fancy_bench_wrapper(suite_name="{name}", binary_to_bench_to_metric_list_map={bench_config}, slow={slow}, expected_runtime={expected_runtime}, sl_iterations={sl_iterations}, regression_threshold={regression_threshold})
+# [test_name, test_src, test_type, extra_deps, extra_compiler_flags]
+ROCKS_TESTS = [
+{tests}]
 
+# Generate a test rule for each entry in ROCKS_TESTS
+# Do not build the tests in opt mode, since SyncPoint and other test code
+# will not be included.
+[
+    cpp_unittest(
+        name = test_name,
+        srcs = [test_cc],
+        arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
+        compiler_flags = ROCKSDB_COMPILER_FLAGS + extra_compiler_flags,
+        include_paths = ROCKSDB_INCLUDE_PATHS,
+        os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+        preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+        deps = [":rocksdb_test_lib"] + extra_deps,
+        external_deps = ROCKSDB_EXTERNAL_DEPS + [
+            ("googletest", None, "gtest"),
+        ],
+    )
+    for test_name, test_cc, parallelism, extra_deps, extra_compiler_flags in ROCKS_TESTS
+    if not is_opt_mode
+]
 """

buckifier/util.py

@@ -2,35 +2,37 @@
 """
 This module keeps commonly used components.
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
-
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 try:
     from builtins import object
 except ImportError:
     from __builtin__ import object
-import os
 import subprocess
 import sys
+import os
 import time
 
-
 class ColorString(object):
-    """Generate colorful strings on terminal"""
-
-    HEADER = "\033[95m"
-    BLUE = "\033[94m"
-    GREEN = "\033[92m"
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
+    """ Generate colorful strings on terminal """
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    GREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
 
     @staticmethod
     def _make_color_str(text, color):
         # In Python2, default encoding for unicode string is ASCII
         if sys.version_info.major <= 2:
-            return "".join([color, text.encode("utf-8"), ColorString.ENDC])
+            return "".join(
+                [color, text.encode('utf-8'), ColorString.ENDC])
         # From Python3, default encoding for unicode string is UTF-8
-        return "".join([color, text, ColorString.ENDC])
+        return "".join(
+            [color, text, ColorString.ENDC])
 
     @staticmethod
     def ok(text):
@@ -66,38 +68,37 @@ class ColorString(object):
 
 
 def run_shell_command(shell_cmd, cmd_dir=None):
-    """Run a single shell command.
-    @returns a tuple of shell command return code, stdout, stderr"""
+    """ Run a single shell command.
+        @returns a tuple of shell command return code, stdout, stderr """
 
     if cmd_dir is not None and not os.path.exists(cmd_dir):
         run_shell_command("mkdir -p %s" % cmd_dir)
 
     start = time.time()
     print("\t>>> Running: " + shell_cmd)
-    p = subprocess.Popen(  # noqa
-        shell_cmd,
-        shell=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        cwd=cmd_dir,
-    )
+    p = subprocess.Popen(shell_cmd,
+                         shell=True,
+                         stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE,
+                         cwd=cmd_dir)
     stdout, stderr = p.communicate()
     end = time.time()
 
     # Report time if we spent more than 5 minutes executing a command
     execution_time = end - start
     if execution_time > (60 * 5):
-        mins = execution_time / 60
-        secs = execution_time % 60
+        mins = (execution_time / 60)
+        secs = (execution_time % 60)
         print("\t>time spent: %d minutes %d seconds" % (mins, secs))
 
+
     return p.returncode, stdout, stderr
 
 
 def run_shell_commands(shell_cmds, cmd_dir=None, verbose=False):
-    """Execute a sequence of shell commands, which is equivalent to
-    running `cmd1 && cmd2 && cmd3`
-    @returns boolean indication if all commands succeeds.
+    """ Execute a sequence of shell commands, which is equivalent to
+        running `cmd1 && cmd2 && cmd3`
+        @returns boolean indication if all commands succeeds.
     """
 
     if cmd_dir:

build_tools/amalgamate.py

@@ -28,15 +28,14 @@
 from __future__ import print_function
 
 import argparse
+from os import path
 import re
 import sys
-from os import path
 
 include_re = re.compile('^[ \t]*#include[ \t]+"(.*)"[ \t]*$')
 included = set()
 excluded = set()
 
-
 def find_header(name, abs_path, include_paths):
     samedir = path.join(path.dirname(abs_path), name)
     if path.exists(samedir):
@@ -47,31 +46,17 @@ def find_header(name, abs_path, include_paths):
             return include_path
     return None
 
-
-def expand_include(
-    include_path,
-    f,
-    abs_path,
-    source_out,
-    header_out,
-    include_paths,
-    public_include_paths,
-):
+def expand_include(include_path, f, abs_path, source_out, header_out, include_paths, public_include_paths):
     if include_path in included:
         return False
 
     included.add(include_path)
     with open(include_path) as f:
         print('#line 1 "{}"'.format(include_path), file=source_out)
-        process_file(
-            f, include_path, source_out, header_out, include_paths, public_include_paths
-        )
+        process_file(f, include_path, source_out, header_out, include_paths, public_include_paths)
     return True
 
-
-def process_file(
-    f, abs_path, source_out, header_out, include_paths, public_include_paths
-):
+def process_file(f, abs_path, source_out, header_out, include_paths, public_include_paths):
     for (line, text) in enumerate(f):
         m = include_re.match(text)
         if m:
@@ -83,15 +68,7 @@ def process_file(
                     source_out.write(text)
                     expanded = False
                 else:
-                    expanded = expand_include(
-                        include_path,
-                        f,
-                        abs_path,
-                        source_out,
-                        header_out,
-                        include_paths,
-                        public_include_paths,
-                    )
+                    expanded = expand_include(include_path, f, abs_path, source_out, header_out, include_paths, public_include_paths)
             else:
                 # now try public headers
                 include_path = find_header(filename, abs_path, public_include_paths)
@@ -101,52 +78,23 @@ def process_file(
                     if include_path in excluded:
                         source_out.write(text)
                     else:
-                        expand_include(
-                            include_path,
-                            f,
-                            abs_path,
-                            header_out,
-                            None,
-                            public_include_paths,
-                            [],
-                        )
+                        expand_include(include_path, f, abs_path, header_out, None, public_include_paths, [])
                 else:
-                    sys.exit(
-                        "unable to find {}, included in {} on line {}".format(
-                            filename, abs_path, line
-                        )
-                    )
+                    sys.exit("unable to find {}, included in {} on line {}".format(filename, abs_path, line))
 
             if expanded:
-                print('#line {} "{}"'.format(line + 1, abs_path), file=source_out)
+                print('#line {} "{}"'.format(line+1, abs_path), file=source_out)
         elif text != "#pragma once\n":
             source_out.write(text)
 
-
 def main():
-    parser = argparse.ArgumentParser(
-        description="Transform a unity build into an amalgamation"
-    )
+    parser = argparse.ArgumentParser(description="Transform a unity build into an amalgamation")
     parser.add_argument("source", help="source file")
-    parser.add_argument(
-        "-I",
-        action="append",
-        dest="include_paths",
-        help="include paths for private headers",
-    )
-    parser.add_argument(
-        "-i",
-        action="append",
-        dest="public_include_paths",
-        help="include paths for public headers",
-    )
-    parser.add_argument(
-        "-x", action="append", dest="excluded", help="excluded header files"
-    )
+    parser.add_argument("-I", action="append", dest="include_paths", help="include paths for private headers")
+    parser.add_argument("-i", action="append", dest="public_include_paths", help="include paths for public headers")
+    parser.add_argument("-x", action="append", dest="excluded", help="excluded header files")
     parser.add_argument("-o", dest="source_out", help="output C++ file", required=True)
-    parser.add_argument(
-        "-H", dest="header_out", help="output C++ header file", required=True
-    )
+    parser.add_argument("-H", dest="header_out", help="output C++ header file", required=True)
     args = parser.parse_args()
 
     include_paths = list(map(path.abspath, args.include_paths or []))
@@ -154,15 +102,10 @@ def main():
     excluded.update(map(path.abspath, args.excluded or []))
     filename = args.source
     abs_path = path.abspath(filename)
-    with open(filename) as f, open(args.source_out, "w") as source_out, open(
-        args.header_out, "w"
-    ) as header_out:
+    with open(filename) as f, open(args.source_out, 'w') as source_out, open(args.header_out, 'w') as header_out:
         print('#line 1 "{}"'.format(filename), file=source_out)
         print('#include "{}"'.format(header_out.name), file=source_out)
-        process_file(
-            f, abs_path, source_out, header_out, include_paths, public_include_paths
-        )
-
+        process_file(f, abs_path, source_out, header_out, include_paths, public_include_paths)
 
 if __name__ == "__main__":
     main()

build_tools/benchmark_log_tool.py

@@ -1,238 +0,0 @@
-#!/usr/bin/env python3
-#  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).
-
-"""Access the results of benchmark runs
-Send these results on to OpenSearch graphing service
-"""
-
-import argparse
-import itertools
-import logging
-import os
-import re
-import sys
-
-import requests
-from dateutil import parser
-
-logging.basicConfig(level=logging.DEBUG)
-
-
-class Configuration:
-    opensearch_user = os.environ["ES_USER"]
-    opensearch_pass = os.environ["ES_PASS"]
-
-
-class BenchmarkResultException(Exception):
-    def __init__(self, message, content):
-        super().__init__(self, message)
-        self.content = content
-
-
-class BenchmarkUtils:
-
-    expected_keys = [
-        "ops_sec",
-        "mb_sec",
-        "lsm_sz",
-        "blob_sz",
-        "c_wgb",
-        "w_amp",
-        "c_mbps",
-        "c_wsecs",
-        "c_csecs",
-        "b_rgb",
-        "b_wgb",
-        "usec_op",
-        "p50",
-        "p99",
-        "p99.9",
-        "p99.99",
-        "pmax",
-        "uptime",
-        "stall%",
-        "Nstall",
-        "u_cpu",
-        "s_cpu",
-        "rss",
-        "test",
-        "date",
-        "version",
-        "job_id",
-    ]
-
-    def sanity_check(row):
-        if "test" not in row:
-            logging.debug(f"not 'test' in row: {row}")
-            return False
-        if row["test"] == "":
-            logging.debug(f"row['test'] == '': {row}")
-            return False
-        if "date" not in row:
-            logging.debug(f"not 'date' in row: {row}")
-            return False
-        if "ops_sec" not in row:
-            logging.debug(f"not 'ops_sec' in row: {row}")
-            return False
-        try:
-            _ = int(row["ops_sec"])
-        except (ValueError, TypeError):
-            logging.debug(f"int(row['ops_sec']): {row}")
-            return False
-        try:
-            (_, _) = parser.parse(row["date"], fuzzy_with_tokens=True)
-        except (parser.ParserError):
-            logging.error(
-                f"parser.parse((row['date']): not a valid format for date in row: {row}"
-            )
-            return False
-        return True
-
-    def conform_opensearch(row):
-        (dt, _) = parser.parse(row["date"], fuzzy_with_tokens=True)
-        # create a test_date field, which was previously what was expected
-        # repair the date field, which has what can be a WRONG ISO FORMAT, (no leading 0 on single-digit day-of-month)
-        # e.g. 2022-07-1T00:14:55 should be 2022-07-01T00:14:55
-        row["test_date"] = dt.isoformat()
-        row["date"] = dt.isoformat()
-        return {key.replace(".", "_"): value for key, value in row.items()}
-
-
-class ResultParser:
-    def __init__(self, field="(\w|[+-:.%])+", intrafield="(\s)+", separator="\t"):
-        self.field = re.compile(field)
-        self.intra = re.compile(intrafield)
-        self.sep = re.compile(separator)
-
-    def ignore(self, l_in: str):
-        if len(l_in) == 0:
-            return True
-        if l_in[0:1] == "#":
-            return True
-        return False
-
-    def line(self, line_in: str):
-        """Parse a line into items
-        Being clever about separators
-        """
-        line = line_in
-        row = []
-        while line != "":
-            match_item = self.field.match(line)
-            if match_item:
-                item = match_item.group(0)
-                row.append(item)
-                line = line[len(item) :]
-            else:
-                match_intra = self.intra.match(line)
-                if match_intra:
-                    intra = match_intra.group(0)
-                    # Count the separators
-                    # If there are >1 then generate extra blank fields
-                    # White space with no true separators fakes up a single separator
-                    tabbed = self.sep.split(intra)
-                    sep_count = len(tabbed) - 1
-                    if sep_count == 0:
-                        sep_count = 1
-                    for _ in range(sep_count - 1):
-                        row.append("")
-                    line = line[len(intra) :]
-                else:
-                    raise BenchmarkResultException(
-                        "Invalid TSV line", f"{line_in} at {line}"
-                    )
-        return row
-
-    def parse(self, lines):
-        """Parse something that iterates lines"""
-        rows = [self.line(line) for line in lines if not self.ignore(line)]
-        header = rows[0]
-        width = len(header)
-        records = [
-            {k: v for (k, v) in itertools.zip_longest(header, row[:width])}
-            for row in rows[1:]
-        ]
-        return records
-
-
-def load_report_from_tsv(filename: str):
-    file = open(filename, "r")
-    contents = file.readlines()
-    file.close()
-    parser = ResultParser()
-    report = parser.parse(contents)
-    logging.debug(f"Loaded TSV Report: {report}")
-    return report
-
-
-def push_report_to_opensearch(report, esdocument):
-    sanitized = [
-        BenchmarkUtils.conform_opensearch(row)
-        for row in report
-        if BenchmarkUtils.sanity_check(row)
-    ]
-    logging.debug(
-        f"upload {len(sanitized)} sane of {len(report)} benchmarks to opensearch"
-    )
-    for single_benchmark in sanitized:
-        logging.debug(f"upload benchmark: {single_benchmark}")
-        response = requests.post(
-            esdocument,
-            json=single_benchmark,
-            auth=(os.environ["ES_USER"], os.environ["ES_PASS"]),
-        )
-        logging.debug(
-            f"Sent to OpenSearch, status: {response.status_code}, result: {response.text}"
-        )
-        response.raise_for_status()
-
-
-def push_report_to_null(report):
-
-    for row in report:
-        if BenchmarkUtils.sanity_check(row):
-            logging.debug(f"row {row}")
-            conformed = BenchmarkUtils.conform_opensearch(row)
-            logging.debug(f"conformed row {conformed}")
-
-
-def main():
-    """Tool for fetching, parsing and uploading benchmark results to OpenSearch / ElasticSearch
-    This tool will
-
-    (1) Open a local tsv benchmark report file
-    (2) Upload to OpenSearch document, via https/JSON
-    """
-
-    parser = argparse.ArgumentParser(description="CircleCI benchmark scraper.")
-
-    # --tsvfile is the name of the file to read results from
-    # --esdocument is the ElasticSearch document to push these results into
-    #
-    parser.add_argument(
-        "--tsvfile",
-        default="build_tools/circle_api_scraper_input.txt",
-        help="File from which to read tsv report",
-    )
-    parser.add_argument(
-        "--esdocument",
-        help="ElasticSearch/OpenSearch document URL to upload report into",
-    )
-    parser.add_argument(
-        "--upload", choices=["opensearch", "none"], default="opensearch"
-    )
-
-    args = parser.parse_args()
-    logging.debug(f"Arguments: {args}")
-    reports = load_report_from_tsv(args.tsvfile)
-    if args.upload == "opensearch":
-        push_report_to_opensearch(reports, args.esdocument)
-    else:
-        push_report_to_null(reports)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

build_tools/build_detect_platform

@@ -45,11 +45,11 @@ if test -z "$OUTPUT"; then
   exit 1
 fi
 
-# we depend on C++17, but should be compatible with newer standards
+# we depend on C++11, but should be compatible with newer standards
 if [ "$ROCKSDB_CXX_STANDARD" ]; then
   PLATFORM_CXXFLAGS="-std=$ROCKSDB_CXX_STANDARD"
 else
-  PLATFORM_CXXFLAGS="-std=c++17"
+  PLATFORM_CXXFLAGS="-std=c++11"
 fi
 
 # we currently depend on POSIX platform
@@ -58,13 +58,15 @@ COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX"
 # Default to fbcode gcc on internal fb machines
 if [ -z "$ROCKSDB_NO_FBCODE" -a -d /mnt/gvfs/third-party ]; then
     FBCODE_BUILD="true"
-    # If we're compiling with TSAN or shared lib, we need pic build
+    # If we're compiling with TSAN we need pic build
     PIC_BUILD=$COMPILE_WITH_TSAN
-    if [ "$LIB_MODE" == "shared" ]; then
-      PIC_BUILD=1
-    fi
-    if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM010" ]; then
-      source "$PWD/build_tools/fbcode_config_platform010.sh"
+    if [ -n "$ROCKSDB_FBCODE_BUILD_WITH_481" ]; then
+      # we need this to build with MySQL. Don't use for other purposes.
+      source "$PWD/build_tools/fbcode_config4.8.1.sh"
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_5xx" ]; then
+      source "$PWD/build_tools/fbcode_config.sh"
+    elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM007" ]; then
+      source "$PWD/build_tools/fbcode_config_platform007.sh"
     elif [ -n "$ROCKSDB_FBCODE_BUILD_WITH_PLATFORM009" ]; then
       source "$PWD/build_tools/fbcode_config_platform009.sh"
     else
@@ -154,7 +156,7 @@ case "$TARGET_OS" in
         ;;
     IOS)
         PLATFORM=IOS
-        COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE "
+        COMMON_FLAGS="$COMMON_FLAGS -DOS_MACOSX -DIOS_CROSS_COMPILE -DROCKSDB_LITE"
         PLATFORM_SHARED_EXT=dylib
         PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name "
         CROSS_COMPILE=true
@@ -174,7 +176,7 @@ case "$TARGET_OS" in
         fi
         if test "$ROCKSDB_USE_IO_URING" -ne 0; then
             # check for liburing
-            $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o test.o 2>/dev/null  <<EOF
+            $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
               #include <liburing.h>
               int main() {
                 struct io_uring ring;
@@ -269,7 +271,7 @@ esac
 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS ${CXXFLAGS}"
 JAVA_LDFLAGS="$PLATFORM_LDFLAGS"
 JAVA_STATIC_LDFLAGS="$PLATFORM_LDFLAGS"
-JAVAC_ARGS="-source 8"
+JAVAC_ARGS="-source 7"
 
 if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
     # Cross-compiling; do not try any compilation tests.
@@ -277,13 +279,12 @@ if [ "$CROSS_COMPILE" = "true" -o "$FBCODE_BUILD" = "true" ]; then
     if [ "$FBCODE_BUILD" = "true" ]; then
       # Enable backtrace on fbcode since the necessary libraries are present
       COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
-      FOLLY_DIR="third-party/folly"
     fi
     true
 else
     if ! test $ROCKSDB_DISABLE_FALLOCATE; then
         # Test whether fallocate is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <fcntl.h>
           #include <linux/falloc.h>
           int main() {
@@ -299,7 +300,7 @@ EOF
     if ! test $ROCKSDB_DISABLE_SNAPPY; then
         # Test whether Snappy library is installed
         # http://code.google.com/p/snappy/
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <snappy.h>
           int main() {}
 EOF
@@ -314,7 +315,7 @@ EOF
         # Test whether gflags library is installed
         # http://gflags.github.io/gflags/
         # check if the namespace is gflags
-        if $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+        if $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
           #include <gflags/gflags.h>
           using namespace GFLAGS_NAMESPACE;
           int main() {}
@@ -323,7 +324,7 @@ EOF
           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1"
           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
         # check if namespace is gflags
-        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
             #include <gflags/gflags.h>
             using namespace gflags;
             int main() {}
@@ -332,7 +333,7 @@ EOF
           COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=1 -DGFLAGS_NAMESPACE=gflags"
           PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
         # check if namespace is google
-        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null << EOF
+        elif $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null << EOF
             #include <gflags/gflags.h>
             using namespace google;
             int main() {}
@@ -345,7 +346,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_ZLIB; then
         # Test whether zlib library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <zlib.h>
           int main() {}
 EOF
@@ -358,7 +359,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_BZIP; then
         # Test whether bzip library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <bzlib.h>
           int main() {}
 EOF
@@ -371,7 +372,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_LZ4; then
         # Test whether lz4 library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <lz4.h>
           #include <lz4hc.h>
           int main() {}
@@ -398,7 +399,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_NUMA; then
         # Test whether numa is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -lnuma 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lnuma 2>/dev/null  <<EOF
           #include <numa.h>
           #include <numaif.h>
           int main() {}
@@ -412,7 +413,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_TBB; then
         # Test whether tbb is available
-        $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -ltbb 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o /dev/null -ltbb 2>/dev/null  <<EOF
           #include <tbb/tbb.h>
           int main() {}
 EOF
@@ -425,7 +426,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_JEMALLOC; then
         # Test whether jemalloc is available
-        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -ljemalloc \
+        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -ljemalloc \
           2>/dev/null; then
             # This will enable some preprocessor identifiers in the Makefile
             JEMALLOC=1
@@ -446,7 +447,7 @@ EOF
     fi
     if ! test $JEMALLOC && ! test $ROCKSDB_DISABLE_TCMALLOC; then
         # jemalloc is not available. Let's try tcmalloc
-        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o \
+        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null \
           -ltcmalloc 2>/dev/null; then
             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc"
             JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc"
@@ -455,7 +456,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_MALLOC_USABLE_SIZE; then
         # Test whether malloc_usable_size is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <malloc.h>
           int main() {
             size_t res = malloc_usable_size(0);
@@ -470,7 +471,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_MEMKIND; then
         # Test whether memkind library is installed
-        $CXX $PLATFORM_CXXFLAGS $LDFLAGS -x c++ - -o test.o -lmemkind 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -lmemkind -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <memkind.h>
           int main() {
             memkind_malloc(MEMKIND_DAX_KMEM, 1024);
@@ -486,7 +487,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_PTHREAD_MUTEX_ADAPTIVE_NP; then
         # Test whether PTHREAD_MUTEX_ADAPTIVE_NP mutex type is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <pthread.h>
           int main() {
             int x = PTHREAD_MUTEX_ADAPTIVE_NP;
@@ -501,7 +502,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_BACKTRACE; then
         # Test whether backtrace is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <execinfo.h>
           int main() {
             void* frames[1];
@@ -513,7 +514,7 @@ EOF
             COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_BACKTRACE"
         else
             # Test whether execinfo library is installed
-            $CXX $PLATFORM_CXXFLAGS -lexecinfo -x c++ - -o test.o 2>/dev/null  <<EOF
+            $CXX $PLATFORM_CXXFLAGS -lexecinfo -x c++ - -o /dev/null 2>/dev/null  <<EOF
               #include <execinfo.h>
               int main() {
                 void* frames[1];
@@ -530,7 +531,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_PG; then
         # Test if -pg is supported
-        $CXX $PLATFORM_CXXFLAGS -pg -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -pg -x c++ - -o /dev/null 2>/dev/null  <<EOF
           int main() {
             return 0;
           }
@@ -542,7 +543,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_SYNC_FILE_RANGE; then
         # Test whether sync_file_range is supported for compatibility with an old glibc
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <fcntl.h>
           int main() {
             int fd = open("/dev/null", 0);
@@ -556,7 +557,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_SCHED_GETCPU; then
         # Test whether sched_getcpu is supported
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <sched.h>
           int main() {
             int cpuid = sched_getcpu();
@@ -570,7 +571,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_AUXV_GETAUXVAL; then
         # Test whether getauxval is supported
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
           #include <sys/auxv.h>
           int main() {
             uint64_t auxv = getauxval(AT_HWCAP);
@@ -584,7 +585,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_ALIGNED_NEW; then
         # Test whether c++17 aligned-new is supported
-        $CXX $PLATFORM_CXXFLAGS -faligned-new -x c++ - -o test.o 2>/dev/null <<EOF
+        $CXX $PLATFORM_CXXFLAGS -faligned-new -x c++ - -o /dev/null 2>/dev/null <<EOF
             struct alignas(1024) t {int a;};
             int main() {}
 EOF
@@ -594,7 +595,7 @@ EOF
     fi
     if ! test $ROCKSDB_DISABLE_BENCHMARK; then
         # Test whether google benchmark is available
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lbenchmark -lpthread 2>/dev/null  <<EOF
+        $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -lbenchmark 2>/dev/null  <<EOF
           #include <benchmark/benchmark.h>
           int main() {}
 EOF
@@ -602,24 +603,13 @@ EOF
             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbenchmark"
         fi
     fi
-    if test $USE_FOLLY; then
-        # Test whether libfolly library is installed
-        $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null  <<EOF
-          #include <folly/synchronization/DistributedMutex.h>
-          int main() {}
-EOF
-        if [ "$?" != 0 ]; then
-          FOLLY_DIR="./third-party/folly"
-        fi
-    fi
-
 fi
 
 # TODO(tec): Fix -Wshorten-64-to-32 errors on FreeBSD and enable the warning.
 # -Wshorten-64-to-32 breaks compilation on FreeBSD aarch64 and i386
 if ! { [ "$TARGET_OS" = FreeBSD ] && [ "$TARGET_ARCHITECTURE" = arm64 -o "$TARGET_ARCHITECTURE" = i386 ]; }; then
   # Test whether -Wshorten-64-to-32 is available
-  $CXX $PLATFORM_CXXFLAGS -x c++ - -o test.o -Wshorten-64-to-32 2>/dev/null  <<EOF
+  $CXX $PLATFORM_CXXFLAGS -x c++ - -o /dev/null -Wshorten-64-to-32 2>/dev/null  <<EOF
     int main() {}
 EOF
   if [ "$?" = 0 ]; then
@@ -627,6 +617,22 @@ EOF
   fi
 fi
 
+# shall we use HDFS?
+
+if test "$USE_HDFS"; then
+  if test -z "$JAVA_HOME"; then
+    echo "JAVA_HOME has to be set for HDFS usage." >&2
+    exit 1
+  fi
+  HDFS_CCFLAGS="$HDFS_CCFLAGS -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -DUSE_HDFS -I$HADOOP_HOME/include"
+  HDFS_LDFLAGS="$HDFS_LDFLAGS -lhdfs -L$JAVA_HOME/jre/lib/amd64 -L$HADOOP_HOME/lib/native"
+  HDFS_LDFLAGS="$HDFS_LDFLAGS -L$JAVA_HOME/jre/lib/amd64/server -L$GLIBC_RUNTIME_PATH/lib"
+  HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm"
+  COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS"
+  PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $HDFS_LDFLAGS"
+  JAVA_LDFLAGS="$JAVA_LDFLAGS $HDFS_LDFLAGS"
+fi
+
 if test "0$PORTABLE" -eq 0; then
   if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
     # Tune for this POWER processor, treating '+' models as base models
@@ -639,15 +645,12 @@ if test "0$PORTABLE" -eq 0; then
     COMMON_FLAGS="$COMMON_FLAGS"
   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
     if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS -x c++ \
-      -march=native - -o /dev/null 2>/dev/null; then
+      -fsyntax-only -march=native - -o /dev/null 2>/dev/null; then
       COMMON_FLAGS="$COMMON_FLAGS -march=native "
     else
       COMMON_FLAGS="$COMMON_FLAGS -march=z196 "
     fi
     COMMON_FLAGS="$COMMON_FLAGS"
-  elif test -n "`echo $TARGET_ARCHITECTURE | grep ^riscv64`"; then
-    RISC_ISA=$(cat /proc/cpuinfo | grep isa | head -1 | cut --delimiter=: -f 2 | cut -b 2-)
-    COMMON_FLAGS="$COMMON_FLAGS -march=${RISC_ISA}"
   elif [ "$TARGET_OS" == "IOS" ]; then
     COMMON_FLAGS="$COMMON_FLAGS"
   elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then
@@ -668,19 +671,13 @@ else
     COMMON_FLAGS="$COMMON_FLAGS -march=z196 "
   fi
 
-  if test -n "`echo $TARGET_ARCHITECTURE | grep ^riscv64`"; then
-    RISC_ISA=$(cat /proc/cpuinfo | grep isa | head -1 | cut --delimiter=: -f 2 | cut -b 2-)
-    COMMON_FLAGS="$COMMON_FLAGS -march=${RISC_ISA}"
-  fi
-
   if [[ "${PLATFORM}" == "OS_MACOSX" ]]; then
-    # For portability compile for macOS 10.13 (2017) or newer
-    COMMON_FLAGS="$COMMON_FLAGS -mmacosx-version-min=10.13"
-    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -mmacosx-version-min=10.13"
-    # -mmacosx-version-min must come first here.
-    PLATFORM_SHARED_LDFLAGS="-mmacosx-version-min=10.13 $PLATFORM_SHARED_LDFLAGS"
-    PLATFORM_CMAKE_FLAGS="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13"
-    JAVA_STATIC_DEPS_COMMON_FLAGS="-mmacosx-version-min=10.13"
+    # For portability compile for macOS 10.12 (2016) or newer
+    COMMON_FLAGS="$COMMON_FLAGS -mmacosx-version-min=10.12"
+    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -mmacosx-version-min=10.12"
+    PLATFORM_SHARED_LDFLAGS="$PLATFORM_SHARED_LDFLAGS -mmacosx-version-min=10.12"
+    PLATFORM_CMAKE_FLAGS="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.12"
+    JAVA_STATIC_DEPS_COMMON_FLAGS="-mmacosx-version-min=10.12"
     JAVA_STATIC_DEPS_LDFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
     JAVA_STATIC_DEPS_CCFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
     JAVA_STATIC_DEPS_CXXFLAGS="$JAVA_STATIC_DEPS_COMMON_FLAGS"
@@ -725,7 +722,7 @@ if test "$TRY_SSE_ETC"; then
   TRY_LZCNT="-mlzcnt"
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   #include <nmmintrin.h>
   int main() {
@@ -739,7 +736,7 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   #include <wmmintrin.h>
   int main() {
@@ -756,7 +753,7 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_AVX2 -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   #include <immintrin.h>
   int main() {
@@ -771,7 +768,7 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use AVX2 intrinsics, disabling" >&2
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_BMI -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   #include <immintrin.h>
   int main(int argc, char *argv[]) {
@@ -785,7 +782,7 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use BMI intrinsics, disabling" >&2
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_LZCNT -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   #include <immintrin.h>
   int main(int argc, char *argv[]) {
@@ -799,7 +796,7 @@ elif test "$USE_SSE"; then
   echo "warning: USE_SSE specified but compiler could not use LZCNT intrinsics, disabling" >&2
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   int main() {
     uint64_t a = 0xffffFFFFffffFFFF;
@@ -812,12 +809,31 @@ if [ "$?" = 0 ]; then
   COMMON_FLAGS="$COMMON_FLAGS -DHAVE_UINT128_EXTENSION"
 fi
 
+# iOS doesn't support thread-local storage, but this check would erroneously
+# succeed because the cross-compiler flags are added by the Makefile, not this
+# script.
+if [ "$PLATFORM" != IOS ]; then
+  $CXX $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
+  #if defined(_MSC_VER) && !defined(__thread)
+  #define __thread __declspec(thread)
+  #endif
+  int main() {
+    static __thread int tls;
+    (void)tls;
+  }
+EOF
+  if [ "$?" = 0 ]; then
+    COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_SUPPORT_THREAD_LOCAL"
+  fi
+fi
+
+
 if [ "$FBCODE_BUILD" != "true" -a "$PLATFORM" = OS_LINUX ]; then
   $CXX $COMMON_FLAGS $PLATFORM_SHARED_CFLAGS -x c++ -c - -o test_dl.o 2>/dev/null <<EOF
   void dummy_func() {}
 EOF
   if [ "$?" = 0 ]; then
-    $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o test.o 2>/dev/null
+    $CXX $COMMON_FLAGS $PLATFORM_SHARED_LDFLAGS test_dl.o -o /dev/null 2>/dev/null
     if [ "$?" = 0 ]; then
       EXEC_LDFLAGS+="-ldl"
       rm -f test_dl.o
@@ -825,27 +841,6 @@ EOF
   fi
 fi
 
-# check for F_FULLFSYNC
-$CXX $PLATFORM_CXXFALGS -x c++ - -o test.o 2>/dev/null  <<EOF
-  #include <fcntl.h>
-  int main() {
-    fcntl(0, F_FULLFSYNC);
-    return 0;
-  }
-EOF
-if [ "$?" = 0 ]; then
-  COMMON_FLAGS="$COMMON_FLAGS -DHAVE_FULLFSYNC"
-fi
-
-rm -f test.o test_dl.o
-
-# Get the path for the folly installation dir
-if [ "$USE_FOLLY" ]; then
-  if [ "$FOLLY_DIR" ]; then
-    FOLLY_PATH=`cd $FOLLY_DIR && $PYTHON build/fbcode_builder/getdeps.py show-inst-dir folly`
-  fi
-fi
-
 PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
 PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"
 
@@ -885,8 +880,6 @@ echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
 echo "FIND=$FIND" >> "$OUTPUT"
 echo "WATCH=$WATCH" >> "$OUTPUT"
-echo "FOLLY_PATH=$FOLLY_PATH" >> "$OUTPUT"
-
 # This will enable some related identifiers for the preprocessor
 if test -n "$JEMALLOC"; then
   echo "JEMALLOC=1" >> "$OUTPUT"
@@ -898,8 +891,8 @@ if test -n "$WITH_JEMALLOC_FLAG"; then
   echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT"
 fi
 echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"
-if test -n "$USE_FOLLY"; then
-  echo "USE_FOLLY=$USE_FOLLY" >> "$OUTPUT"
+if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
+  echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT"
 fi
 if test -n "$PPC_LIBC_IS_GNU"; then
   echo "PPC_LIBC_IS_GNU=$PPC_LIBC_IS_GNU" >> "$OUTPUT"

build_tools/check-sources.sh

@@ -5,44 +5,24 @@
 
 BAD=""
 
-git grep -n 'namespace rocksdb' -- '*.[ch]*'
+git grep 'namespace rocksdb' -- '*.[ch]*'
 if [ "$?" != "1" ]; then
   echo "^^^^^ Do not hardcode namespace rocksdb. Use ROCKSDB_NAMESPACE"
   BAD=1
 fi
 
-git grep -n -i 'nocommit' -- ':!build_tools/check-sources.sh'
+git grep -i 'nocommit' -- ':!build_tools/check-sources.sh'
 if [ "$?" != "1" ]; then
   echo "^^^^^ Code was not intended to be committed"
   BAD=1
 fi
 
-git grep -n 'include <rocksdb/' -- ':!build_tools/check-sources.sh'
+git grep '<rocksdb/' -- ':!build_tools/check-sources.sh'
 if [ "$?" != "1" ]; then
   echo '^^^^^ Use double-quotes as in #include "rocksdb/something.h"'
   BAD=1
 fi
 
-git grep -n 'include "include/rocksdb/' -- ':!build_tools/check-sources.sh'
-if [ "$?" != "1" ]; then
-  echo '^^^^^ Use #include "rocksdb/something.h" instead of #include "include/rocksdb/something.h"'
-  BAD=1
-fi
-
-git grep -n 'using namespace' -- ':!build_tools' ':!docs' \
-    ':!third-party/folly/folly/lang/Align.h' \
-    ':!third-party/gtest-1.8.1/fused-src/gtest/gtest.h'
-if [ "$?" != "1" ]; then
-  echo '^^^^ Do not use "using namespace"'
-  BAD=1
-fi
-
-git grep -n -P "[\x80-\xFF]" -- ':!docs' ':!*.md'
-if [ "$?" != "1" ]; then
-  echo '^^^^ Use only ASCII characters in source files'
-  BAD=1
-fi
-
 if [ "$BAD" ]; then
   exit 1
 fi

build_tools/dependencies.sh

@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/5.x/centos7-native/c447969
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/1bd23f9917738974ad0ff305aa23eb5f93f18305/9.0.0/centos7-native/c9f9104
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/5.x/gcc-5-glibc-2.23/339d858
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.23/gcc-5-glibc-2.23/ca1d1c0
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/gcc-5-glibc-2.23/9bc6787
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/gcc-5-glibc-2.23/9bc6787
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/gcc-5-glibc-2.23/9bc6787
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/gcc-5-glibc-2.23/9bc6787
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/gcc-5-glibc-2.23/03859b5
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/gcc-5-glibc-2.23/9bc6787
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/gcc-5-glibc-2.23/0c8f76d
+NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/gcc-5-glibc-2.23/9bc6787
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/gcc-5-glibc-2.23/b443de1
+TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/gcc-5-glibc-2.23/9bc6787
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/4.0.9-36_fbk5_2933_gd092e3f/gcc-5-glibc-2.23/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/2e3cb7d119b3cea5f1e738cc13a1ac69f49eb875/2.29.1/centos7-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/gcc-5-glibc-2.23/9bc6787
+LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.2.3/gcc-5-glibc-2.23/65372bd

build_tools/dependencies_4.8.1.sh

@@ -0,0 +1,20 @@
+# shellcheck disable=SC2148
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+GCC_BASE=/mnt/gvfs/third-party2/gcc/cf7d14c625ce30bae1a4661c2319c5a283e4dd22/4.8.1/centos6-native/cc6c9dc
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/8598c375b0e94e1448182eb3df034704144a838d/stable/centos6-native/3f16ddd
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/d6e0a7da6faba45f5e5b1638f9edd7afc2f34e7d/4.8.1/gcc-4.8.1-glibc-2.17/8aac7fc
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/d282e6e8f3d20f4e40a516834847bdc038e07973/2.17/gcc-4.8.1-glibc-2.17/99df8fc
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/8c38a4c1e52b4c2cc8a9cdc31b9c947ed7dbfcb4/1.1.3/gcc-4.8.1-glibc-2.17/c3f970a
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/0882df3713c7a84f15abe368dc004581f20b39d7/1.2.8/gcc-4.8.1-glibc-2.17/c3f970a
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/740325875f6729f42d28deaa2147b0854f3a347e/1.0.6/gcc-4.8.1-glibc-2.17/c3f970a
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0e790b441e2d9acd68d51e1d2e028f88c6a79ddf/r131/gcc-4.8.1-glibc-2.17/c3f970a
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/9455f75ff7f4831dc9fda02a6a0f8c68922fad8f/1.0.0/gcc-4.8.1-glibc-2.17/c3f970a
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/f001a51b2854957676d07306ef3abf67186b5c8b/2.1.1/gcc-4.8.1-glibc-2.17/c3f970a
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/fc8a13ca1fffa4d0765c716c5a0b49f0c107518f/master/gcc-4.8.1-glibc-2.17/8d31e51
+NUMA_BASE=/mnt/gvfs/third-party2/numa/17c514c4d102a25ca15f4558be564eeed76f4b6a/2.0.8/gcc-4.8.1-glibc-2.17/c3f970a
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/ad576de2a1ea560c4d3434304f0fc4e079bede42/trunk/gcc-4.8.1-glibc-2.17/675d945
+TBB_BASE=/mnt/gvfs/third-party2/tbb/9d9a554877d0c5bef330fe818ab7178806dd316a/4.0_update2/gcc-4.8.1-glibc-2.17/c3f970a
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/7c111ff27e0c466235163f00f280a9d617c3d2ec/4.0.9-36_fbk5_2933_gd092e3f/gcc-4.8.1-glibc-2.17/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/b7fd454c4b10c6a81015d4524ed06cdeab558490/2.26/centos6-native/da39a3e
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d7f4d4d86674a57668e3a96f76f0e17dd0eb8765/3.8.1/gcc-4.8.1-glibc-2.17/c3f970a
+LUA_BASE=/mnt/gvfs/third-party2/lua/61e4abf5813bbc39bc4f548757ccfcadde175a48/5.2.3/centos6-native/730f94e

build_tools/dependencies_platform007.sh

@@ -0,0 +1,20 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/7.x/centos7-native/b2ef2b6
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/963d9aeda70cc4779885b1277484fe7544a04e3e/9.0.0/platform007/9e92d53/
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/7.x/platform007/5620abc
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.26/platform007/f259413
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/platform007/ca4da3d
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/platform007/ca4da3d
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/platform007/ca4da3d
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/platform007/ca4da3d
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/platform007/15a3614
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/platform007/ca4da3d
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/platform007/c26c002
+NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/platform007/ca4da3d
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/platform007/6f3e0a9
+TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/platform007/ca4da3d
+LIBURING_BASE=/mnt/gvfs/third-party2/liburing/79427253fd0d42677255aacfe6d13bfe63f752eb/20190828/platform007/ca4da3d
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/fb/platform007/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/ab9f09bba370e7066cafd4eb59752db93f2e8312/2.29.1/platform007/15a3614
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/platform007/ca4da3d
+LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.3.4/platform007/5007832

build_tools/dependencies_platform009.sh

@@ -6,10 +6,10 @@ GLIBC_BASE=/mnt/gvfs/third-party2/glibc/45ce3375cdc77ecb2520bbf8f0ecddd3f98efd7a
 SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/be4de3205e029101b18aa8103daa696c2bef3b19/1.1.3/platform009/7f3b187
 ZLIB_BASE=/mnt/gvfs/third-party2/zlib/3c160ac5c67e257501e24c6c1d00ad5e01d73db6/1.2.8/platform009/7f3b187
 BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/73a237ac5bc0a5f5d67b39b8d253cfebaab88684/1.0.6/platform009/7f3b187
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/6ca38d3c390be2774d61a300f151464bbd632d62/1.9.1/platform009/7f3b187
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/ec6573523b0ce55ef6373a4801189027cf07bb2c/1.9.1/platform009/7f3b187
 ZSTD_BASE=/mnt/gvfs/third-party2/zstd/64c58a207d2495e83abc57a500a956df09b79a7c/1.4.x/platform009/ba86d1f
 GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/824d0a8a5abb5b121afd1b35fc3896407ea50092/2.2.0/platform009/7f3b187
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/b62912d333ef33f9760efa6219dbe3fe6abb3b0e/master/platform009/c305944
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/d9aef9feb850b168a68736420f217b01cce11a89/master/platform009/c305944
 NUMA_BASE=/mnt/gvfs/third-party2/numa/0af65f71e23a67bf65dc91b11f95caa39325c432/2.0.11/platform009/7f3b187
 LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/02486dac347645d31dce116f44e1de3177315be2/1.4/platform009/5191652
 TBB_BASE=/mnt/gvfs/third-party2/tbb/2e0ec671e550bfca347300bf3f789d9c0fff24ad/2018_U5/platform009/7f3b187
@@ -18,5 +18,4 @@ KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/32b8a2407b634df3f8f948
 BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/08634589372fa5f237bfd374e8c644a8364e78c1/2.32/platform009/ba86d1f/
 VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/6ae525939ad02e5e676855082fbbc7828dbafeac/3.15.0/platform009/7f3b187
 LUA_BASE=/mnt/gvfs/third-party2/lua/162efd9561a3d21f6869f4814011e9cf1b3ff4dc/5.3.4/platform009/a6271c4
-BENCHMARK_BASE=/mnt/gvfs/third-party2/benchmark/30bf49ad6414325e17f3425b0edcb64239427ae3/1.6.1/platform009/7f3b187
-GLOG_BASE=/mnt/gvfs/third-party2/glog/32d751bd5673375b438158717ab6a57c1cc57e3d/0.3.2_fb/platform009/10a364d
+BENCHMARK_BASE=/mnt/gvfs/third-party2/benchmark/bce8d9564eaf161700aa3a20b1051564acf555fb/1.5.5/platform009/7f3b187

build_tools/dependencies_platform010.sh

@@ -1,22 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-# The file is generated using update_dependencies.sh.
-GCC_BASE=/mnt/gvfs/third-party2/gcc/e40bde78650fa91b8405a857e3f10bf336633fb0/11.x/centos7-native/886b5eb
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/2043340983c032915adbb6f78903dc855b65aee8/12/platform010/9520e0f
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/c00dcc6a3e4125c7e8b248e9a79c14b78ac9e0ca/11.x/platform010/5684a5a
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/0b9c8e4b060eda62f3bc1c6127bbe1256697569b/2.34/platform010/f259413
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/bc9647f7912b131315827d65cb6189c21f381d05/1.1.3/platform010/76ebdda
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/a6f5f3f1d063d2d00cd02fc12f0f05fc3ab3a994/1.2.11/platform010/76ebdda
-BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/09703139cfc376bd8a82642385a0e97726b28287/1.0.6/platform010/76ebdda
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/60220d6a5bf7722b9cc239a1368c596619b12060/1.9.1/platform010/76ebdda
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/50eace8143eaaea9473deae1f3283e0049e05633/1.4.x/platform010/64091f4
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/5d27e5919771603da06000a027b12f799e58a4f7/2.2.0/platform010/76ebdda
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/b62912d333ef33f9760efa6219dbe3fe6abb3b0e/master/platform010/f57cc4a
-NUMA_BASE=/mnt/gvfs/third-party2/numa/6b412770957aa3c8a87e5e0dcd8cc2f45f393bc0/2.0.11/platform010/76ebdda
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/52f69816e936e147664ad717eb71a1a0e9dc973a/1.4/platform010/5074a48
-TBB_BASE=/mnt/gvfs/third-party2/tbb/c9cc192099fa84c0dcd0ffeedd44a373ad6e4925/2018_U5/platform010/76ebdda
-LIBURING_BASE=/mnt/gvfs/third-party2/liburing/a98e2d137007e3ebf7f33bd6f99c2c56bdaf8488/20210212/platform010/76ebdda
-BENCHMARK_BASE=/mnt/gvfs/third-party2/benchmark/780c7a0f9cf0967961e69ad08e61cddd85d61821/trunk/platform010/76ebdda
-KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/02d9f76aaaba580611cf75e741753c800c7fdc12/fb/platform010/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/938dc3f064ef3a48c0446f5b11d788d50b3eb5ee/2.37/centos7-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/429a6b3203eb415f1599bd15183659153129188e/3.15.0/platform010/76ebdda
-LUA_BASE=/mnt/gvfs/third-party2/lua/363787fa5cac2a8aa20638909210443278fa138e/5.3.4/platform010/9079c97

build_tools/error_filter.py

@@ -3,13 +3,16 @@
 #  COPYING file in the root directory) and Apache 2.0 License
 #  (found in the LICENSE.Apache file in the root directory).
 
-"""Filter for error messages in test output:
+'''Filter for error messages in test output:
     - Receives merged stdout/stderr from test on stdin
     - Finds patterns of known error messages for test name (first argument)
     - Prints those error messages to stdout
-"""
+'''
 
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
 import re
 import sys
@@ -17,24 +20,23 @@ import sys
 
 class ErrorParserBase(object):
     def parse_error(self, line):
-        """Parses a line of test output. If it contains an error, returns a
+        '''Parses a line of test output. If it contains an error, returns a
         formatted message describing the error; otherwise, returns None.
         Subclasses must override this method.
-        """
+        '''
         raise NotImplementedError
 
 
 class GTestErrorParser(ErrorParserBase):
-    """A parser that remembers the last test that began running so it can print
+    '''A parser that remembers the last test that began running so it can print
     that test's name upon detecting failure.
-    """
-
-    _GTEST_NAME_PATTERN = re.compile(r"\[ RUN      \] (\S+)$")
+    '''
+    _GTEST_NAME_PATTERN = re.compile(r'\[ RUN      \] (\S+)$')
     # format: '<filename or "unknown file">:<line #>: Failure'
-    _GTEST_FAIL_PATTERN = re.compile(r"(unknown file|\S+:\d+): Failure$")
+    _GTEST_FAIL_PATTERN = re.compile(r'(unknown file|\S+:\d+): Failure$')
 
     def __init__(self):
-        self._last_gtest_name = "Unknown test"
+        self._last_gtest_name = 'Unknown test'
 
     def parse_error(self, line):
         gtest_name_match = self._GTEST_NAME_PATTERN.match(line)
@@ -43,13 +45,14 @@ class GTestErrorParser(ErrorParserBase):
             return None
         gtest_fail_match = self._GTEST_FAIL_PATTERN.match(line)
         if gtest_fail_match:
-            return "%s failed: %s" % (self._last_gtest_name, gtest_fail_match.group(1))
+            return '%s failed: %s' % (
+                    self._last_gtest_name, gtest_fail_match.group(1))
         return None
 
 
 class MatchErrorParser(ErrorParserBase):
-    """A simple parser that returns the whole line if it matches the pattern."""
-
+    '''A simple parser that returns the whole line if it matches the pattern.
+    '''
     def __init__(self, pattern):
         self._pattern = re.compile(pattern)
 
@@ -66,104 +69,97 @@ class CompilerErrorParser(MatchErrorParser):
         # format (link error):
         #   '<filename>:<line #>: error: <error msg>'
         # The below regex catches both
-        super(CompilerErrorParser, self).__init__(r"\S+:\d+: error:")
+        super(CompilerErrorParser, self).__init__(r'\S+:\d+: error:')
 
 
 class ScanBuildErrorParser(MatchErrorParser):
     def __init__(self):
-        super(ScanBuildErrorParser, self).__init__(r"scan-build: \d+ bugs found.$")
+        super(ScanBuildErrorParser, self).__init__(
+                r'scan-build: \d+ bugs found.$')
 
 
 class DbCrashErrorParser(MatchErrorParser):
     def __init__(self):
-        super(DbCrashErrorParser, self).__init__(r"\*\*\*.*\^$|TEST FAILED.")
+        super(DbCrashErrorParser, self).__init__(r'\*\*\*.*\^$|TEST FAILED.')
 
 
 class WriteStressErrorParser(MatchErrorParser):
     def __init__(self):
         super(WriteStressErrorParser, self).__init__(
-            r"ERROR: write_stress died with exitcode=\d+"
-        )
+                r'ERROR: write_stress died with exitcode=\d+')
 
 
 class AsanErrorParser(MatchErrorParser):
     def __init__(self):
-        super(AsanErrorParser, self).__init__(r"==\d+==ERROR: AddressSanitizer:")
+        super(AsanErrorParser, self).__init__(
+                r'==\d+==ERROR: AddressSanitizer:')
 
 
 class UbsanErrorParser(MatchErrorParser):
     def __init__(self):
         # format: '<filename>:<line #>:<column #>: runtime error: <error msg>'
-        super(UbsanErrorParser, self).__init__(r"\S+:\d+:\d+: runtime error:")
+        super(UbsanErrorParser, self).__init__(r'\S+:\d+:\d+: runtime error:')
 
 
 class ValgrindErrorParser(MatchErrorParser):
     def __init__(self):
         # just grab the summary, valgrind doesn't clearly distinguish errors
         # from other log messages.
-        super(ValgrindErrorParser, self).__init__(r"==\d+== ERROR SUMMARY:")
+        super(ValgrindErrorParser, self).__init__(r'==\d+== ERROR SUMMARY:')
 
 
 class CompatErrorParser(MatchErrorParser):
     def __init__(self):
-        super(CompatErrorParser, self).__init__(r"==== .*[Ee]rror.* ====$")
+        super(CompatErrorParser, self).__init__(r'==== .*[Ee]rror.* ====$')
 
 
 class TsanErrorParser(MatchErrorParser):
     def __init__(self):
-        super(TsanErrorParser, self).__init__(r"WARNING: ThreadSanitizer:")
+        super(TsanErrorParser, self).__init__(r'WARNING: ThreadSanitizer:')
 
 
 _TEST_NAME_TO_PARSERS = {
-    "punit": [CompilerErrorParser, GTestErrorParser],
-    "unit": [CompilerErrorParser, GTestErrorParser],
-    "release": [CompilerErrorParser, GTestErrorParser],
-    "unit_481": [CompilerErrorParser, GTestErrorParser],
-    "release_481": [CompilerErrorParser, GTestErrorParser],
-    "clang_unit": [CompilerErrorParser, GTestErrorParser],
-    "clang_release": [CompilerErrorParser, GTestErrorParser],
-    "clang_analyze": [CompilerErrorParser, ScanBuildErrorParser],
-    "code_cov": [CompilerErrorParser, GTestErrorParser],
-    "unity": [CompilerErrorParser, GTestErrorParser],
-    "lite": [CompilerErrorParser],
-    "lite_test": [CompilerErrorParser, GTestErrorParser],
-    "stress_crash": [CompilerErrorParser, DbCrashErrorParser],
-    "stress_crash_with_atomic_flush": [CompilerErrorParser, DbCrashErrorParser],
-    "stress_crash_with_txn": [CompilerErrorParser, DbCrashErrorParser],
-    "write_stress": [CompilerErrorParser, WriteStressErrorParser],
-    "asan": [CompilerErrorParser, GTestErrorParser, AsanErrorParser],
-    "asan_crash": [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
-    "asan_crash_with_atomic_flush": [
-        CompilerErrorParser,
-        AsanErrorParser,
-        DbCrashErrorParser,
-    ],
-    "asan_crash_with_txn": [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
-    "ubsan": [CompilerErrorParser, GTestErrorParser, UbsanErrorParser],
-    "ubsan_crash": [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
-    "ubsan_crash_with_atomic_flush": [
-        CompilerErrorParser,
-        UbsanErrorParser,
-        DbCrashErrorParser,
-    ],
-    "ubsan_crash_with_txn": [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
-    "valgrind": [CompilerErrorParser, GTestErrorParser, ValgrindErrorParser],
-    "tsan": [CompilerErrorParser, GTestErrorParser, TsanErrorParser],
-    "format_compatible": [CompilerErrorParser, CompatErrorParser],
-    "run_format_compatible": [CompilerErrorParser, CompatErrorParser],
-    "no_compression": [CompilerErrorParser, GTestErrorParser],
-    "run_no_compression": [CompilerErrorParser, GTestErrorParser],
-    "regression": [CompilerErrorParser],
-    "run_regression": [CompilerErrorParser],
+    'punit': [CompilerErrorParser, GTestErrorParser],
+    'unit': [CompilerErrorParser, GTestErrorParser],
+    'release': [CompilerErrorParser, GTestErrorParser],
+    'unit_481': [CompilerErrorParser, GTestErrorParser],
+    'release_481': [CompilerErrorParser, GTestErrorParser],
+    'clang_unit': [CompilerErrorParser, GTestErrorParser],
+    'clang_release': [CompilerErrorParser, GTestErrorParser],
+    'clang_analyze': [CompilerErrorParser, ScanBuildErrorParser],
+    'code_cov': [CompilerErrorParser, GTestErrorParser],
+    'unity': [CompilerErrorParser, GTestErrorParser],
+    'lite': [CompilerErrorParser],
+    'lite_test': [CompilerErrorParser, GTestErrorParser],
+    'stress_crash': [CompilerErrorParser, DbCrashErrorParser],
+    'stress_crash_with_atomic_flush': [CompilerErrorParser, DbCrashErrorParser],
+    'stress_crash_with_txn': [CompilerErrorParser, DbCrashErrorParser],
+    'write_stress': [CompilerErrorParser, WriteStressErrorParser],
+    'asan': [CompilerErrorParser, GTestErrorParser, AsanErrorParser],
+    'asan_crash': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
+    'asan_crash_with_atomic_flush': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
+    'asan_crash_with_txn': [CompilerErrorParser, AsanErrorParser, DbCrashErrorParser],
+    'ubsan': [CompilerErrorParser, GTestErrorParser, UbsanErrorParser],
+    'ubsan_crash': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
+    'ubsan_crash_with_atomic_flush': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
+    'ubsan_crash_with_txn': [CompilerErrorParser, UbsanErrorParser, DbCrashErrorParser],
+    'valgrind': [CompilerErrorParser, GTestErrorParser, ValgrindErrorParser],
+    'tsan': [CompilerErrorParser, GTestErrorParser, TsanErrorParser],
+    'format_compatible': [CompilerErrorParser, CompatErrorParser],
+    'run_format_compatible': [CompilerErrorParser, CompatErrorParser],
+    'no_compression': [CompilerErrorParser, GTestErrorParser],
+    'run_no_compression': [CompilerErrorParser, GTestErrorParser],
+    'regression': [CompilerErrorParser],
+    'run_regression': [CompilerErrorParser],
 }
 
 
 def main():
     if len(sys.argv) != 2:
-        return "Usage: %s <test name>" % sys.argv[0]
+        return 'Usage: %s <test name>' % sys.argv[0]
     test_name = sys.argv[1]
     if test_name not in _TEST_NAME_TO_PARSERS:
-        return "Unknown test name: %s" % test_name
+        return 'Unknown test name: %s' % test_name
 
     error_parsers = []
     for parser_cls in _TEST_NAME_TO_PARSERS[test_name]:
@@ -177,5 +173,5 @@ def main():
                 print(error_msg)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     sys.exit(main())

build_tools/fbcode_config.sh

@@ -21,48 +21,38 @@ LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
 GLIBC_INCLUDE="$GLIBC_BASE/include"
 GLIBC_LIBS=" -L $GLIBC_BASE/lib"
 
-if ! test $ROCKSDB_DISABLE_SNAPPY; then
-  # snappy
-  SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
-  if test -z $PIC_BUILD; then
-    SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
-  else
-    SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
-  fi
-  CFLAGS+=" -DSNAPPY"
+# snappy
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
+if test -z $PIC_BUILD; then
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
+else
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
 fi
+CFLAGS+=" -DSNAPPY"
 
 if test -z $PIC_BUILD; then
-  if ! test $ROCKSDB_DISABLE_ZLIB; then
-    # location of zlib headers and libraries
-    ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
-    ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
-    CFLAGS+=" -DZLIB"
-  fi
+  # location of zlib headers and libraries
+  ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
+  ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
+  CFLAGS+=" -DZLIB"
 
-  if ! test $ROCKSDB_DISABLE_BZIP; then
-    # location of bzip headers and libraries
-    BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
-    BZIP_LIBS=" $BZIP2_BASE/lib/libbz2.a"
-    CFLAGS+=" -DBZIP2"
-  fi
+  # location of bzip headers and libraries
+  BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
+  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2.a"
+  CFLAGS+=" -DBZIP2"
 
-  if ! test $ROCKSDB_DISABLE_LZ4; then
-    LZ4_INCLUDE=" -I $LZ4_BASE/include/"
-    LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
-    CFLAGS+=" -DLZ4"
-  fi
+  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
+  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
+  CFLAGS+=" -DLZ4"
 fi
 
-if ! test $ROCKSDB_DISABLE_ZSTD; then
-  ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
-  if test -z $PIC_BUILD; then
-    ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
-  else
-    ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
-  fi
-  CFLAGS+=" -DZSTD -DZSTD_STATIC_LINKING_ONLY"
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
+if test -z $PIC_BUILD; then
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+else
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
 fi
+CFLAGS+=" -DZSTD -DZSTD_STATIC_LINKING_ONLY"
 
 # location of gflags headers and libraries
 GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
@@ -147,7 +137,7 @@ else
 fi
 
 CFLAGS+=" $DEPS_INCLUDE"
-CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DHAVE_SSE42"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
 CXXFLAGS+=" $CFLAGS"
 
 EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
@@ -172,4 +162,6 @@ else
   LUA_LIB=" $LUA_PATH/lib/liblua_pic.a"
 fi
 
+USE_FOLLY_DISTRIBUTED_MUTEX=1
+
 export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB

build_tools/fbcode_config4.8.1.sh

@@ -0,0 +1,120 @@
+#!/bin/sh
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+#
+# Set environment variables so that we can compile rocksdb using
+# fbcode settings.  It uses the latest g++ compiler and also
+# uses jemalloc
+
+BASEDIR=`dirname $BASH_SOURCE`
+source "$BASEDIR/dependencies_4.8.1.sh"
+
+# location of libgcc
+LIBGCC_INCLUDE="$LIBGCC_BASE/include"
+LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
+
+# location of glibc
+GLIBC_INCLUDE="$GLIBC_BASE/include"
+GLIBC_LIBS=" -L $GLIBC_BASE/lib"
+
+# location of snappy headers and libraries
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include"
+SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
+
+# location of zlib headers and libraries
+ZLIB_INCLUDE=" -I $ZLIB_BASE/include"
+ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
+
+# location of bzip headers and libraries
+BZIP2_INCLUDE=" -I $BZIP2_BASE/include/"
+BZIP2_LIBS=" $BZIP2_BASE/lib/libbz2.a"
+
+LZ4_INCLUDE=" -I $LZ4_BASE/include"
+LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
+
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include"
+ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+
+# location of gflags headers and libraries
+GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
+GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a"
+
+# location of jemalloc
+JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include"
+JEMALLOC_LIB="$JEMALLOC_BASE/lib/libjemalloc.a"
+
+# location of numa
+NUMA_INCLUDE=" -I $NUMA_BASE/include/"
+NUMA_LIB=" $NUMA_BASE/lib/libnuma.a"
+
+# location of libunwind
+LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
+
+# location of tbb
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+
+test "$USE_SSE" || USE_SSE=1
+export USE_SSE
+test "$PORTABLE" || PORTABLE=1
+export PORTABLE
+
+BINUTILS="$BINUTILS_BASE/bin"
+AR="$BINUTILS/ar"
+
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP2_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE"
+
+STDLIBS="-L $GCC_BASE/lib64"
+
+if [ -z "$USE_CLANG" ]; then
+  # gcc
+  CC="$GCC_BASE/bin/gcc"
+  CXX="$GCC_BASE/bin/g++"
+  CXX="$GCC_BASE/bin/gcc-ar"
+
+  CFLAGS="-B$BINUTILS/gold -m64 -mtune=generic"
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  JEMALLOC=1
+else
+  # clang
+  CLANG_BIN="$CLANG_BASE/bin"
+  CLANG_LIB="$CLANG_BASE/lib"
+  CLANG_INCLUDE="$CLANG_LIB/clang/*/include"
+  CC="$CLANG_BIN/clang"
+  CXX="$CLANG_BIN/clang++"
+  AR="$CLANG_BIN/llvm-ar"
+
+  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include/"
+
+  CFLAGS="-B$BINUTILS/gold -nostdinc -nostdlib"
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.8.1 "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/4.8.1/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $CLANG_INCLUDE"
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
+  CXXFLAGS="-nostdinc++"
+fi
+
+CFLAGS+=" $DEPS_INCLUDE"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
+CFLAGS+=" -DSNAPPY -DGFLAGS=google -DZLIB -DBZIP2 -DLZ4 -DZSTD -DNUMA -DTBB"
+CXXFLAGS+=" $CFLAGS"
+
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP2_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/gcc-4.8.1-glibc-2.17/lib/ld.so"
+EXEC_LDFLAGS+=" $LIBUNWIND"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/gcc-4.8.1-glibc-2.17/lib"
+# required by libtbb
+EXEC_LDFLAGS+=" -ldl"
+
+PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
+
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP2_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS"
+
+VALGRIND_VER="$VALGRIND_BASE/bin/"
+
+LUA_PATH="$LUA_BASE"
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE LUA_PATH

build_tools/fbcode_config_platform007.sh

@@ -0,0 +1,170 @@
+#!/bin/sh
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+#
+# Set environment variables so that we can compile rocksdb using
+# fbcode settings.  It uses the latest g++ and clang compilers and also
+# uses jemalloc
+# Environment variables that change the behavior of this script:
+# PIC_BUILD -- if true, it will only take pic versions of libraries from fbcode. libraries that don't have pic variant will not be included
+
+
+BASEDIR=`dirname $BASH_SOURCE`
+source "$BASEDIR/dependencies_platform007.sh"
+
+CFLAGS=""
+
+# libgcc
+LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/7.3.0"
+LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
+
+# glibc
+GLIBC_INCLUDE="$GLIBC_BASE/include"
+GLIBC_LIBS=" -L $GLIBC_BASE/lib"
+
+# snappy
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
+if test -z $PIC_BUILD; then
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
+else
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
+fi
+CFLAGS+=" -DSNAPPY"
+
+if test -z $PIC_BUILD; then
+  # location of zlib headers and libraries
+  ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
+  ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
+  CFLAGS+=" -DZLIB"
+
+  # location of bzip headers and libraries
+  BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
+  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2.a"
+  CFLAGS+=" -DBZIP2"
+
+  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
+  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
+  CFLAGS+=" -DLZ4"
+fi
+
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
+if test -z $PIC_BUILD; then
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+else
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
+fi
+CFLAGS+=" -DZSTD"
+
+# location of gflags headers and libraries
+GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
+if test -z $PIC_BUILD; then
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a"
+else
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
+fi
+CFLAGS+=" -DGFLAGS=gflags"
+
+# location of jemalloc
+JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
+JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc.a"
+
+if test -z $PIC_BUILD; then
+  # location of numa
+  NUMA_INCLUDE=" -I $NUMA_BASE/include/"
+  NUMA_LIB=" $NUMA_BASE/lib/libnuma.a"
+  CFLAGS+=" -DNUMA"
+
+  # location of libunwind
+  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
+fi
+
+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
+CFLAGS+=" -DTBB"
+
+# location of LIBURING
+LIBURING_INCLUDE=" -isystem $LIBURING_BASE/include/"
+if test -z $PIC_BUILD; then
+  LIBURING_LIBS="$LIBURING_BASE/lib/liburing.a"
+else
+  LIBURING_LIBS="$LIBURING_BASE/lib/liburing_pic.a"
+fi
+CFLAGS+=" -DLIBURING"
+
+test "$USE_SSE" || USE_SSE=1
+export USE_SSE
+test "$PORTABLE" || PORTABLE=1
+export PORTABLE
+
+BINUTILS="$BINUTILS_BASE/bin"
+AR="$BINUTILS/ar"
+
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE"
+
+STDLIBS="-L $GCC_BASE/lib64"
+
+CLANG_BIN="$CLANG_BASE/bin"
+CLANG_LIB="$CLANG_BASE/lib"
+CLANG_SRC="$CLANG_BASE/../../src"
+
+CLANG_ANALYZER="$CLANG_BIN/clang++"
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build"
+
+if [ -z "$USE_CLANG" ]; then
+  # gcc
+  CC="$GCC_BASE/bin/gcc"
+  CXX="$GCC_BASE/bin/g++"
+  AR="$GCC_BASE/bin/gcc-ar"
+
+  CFLAGS+=" -B$BINUTILS/gold"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  JEMALLOC=1
+else
+  # clang
+  CLANG_INCLUDE="$CLANG_LIB/clang/stable/include"
+  CC="$CLANG_BIN/clang"
+  CXX="$CLANG_BIN/clang++"
+  AR="$CLANG_BIN/llvm-ar"
+
+  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
+
+  CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib"
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $CLANG_INCLUDE"
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
+  CFLAGS+=" -Wno-expansion-to-defined "
+  CXXFLAGS="-nostdinc++"
+fi
+
+CFLAGS+=" $DEPS_INCLUDE"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42 -DROCKSDB_IOURING_PRESENT"
+CXXFLAGS+=" $CFLAGS"
+
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS"
+EXEC_LDFLAGS+=" -B$BINUTILS/gold"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
+EXEC_LDFLAGS+=" $LIBUNWIND"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform007/lib"
+# required by libtbb
+EXEC_LDFLAGS+=" -ldl"
+
+PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
+
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS $LIBURING_LIBS"
+
+VALGRIND_VER="$VALGRIND_BASE/bin/"
+
+# lua not supported because it's on track for deprecation, I think
+LUA_PATH=
+LUA_LIB=
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB

build_tools/fbcode_config_platform009.sh

@@ -14,83 +14,92 @@ source "$BASEDIR/dependencies_platform009.sh"
 CFLAGS=""
 
 # libgcc
-LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/9.3.0 -I $LIBGCC_BASE/include/c++/9.3.0/backward"
+LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/9.3.0"
 LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
 
 # glibc
 GLIBC_INCLUDE="$GLIBC_BASE/include"
 GLIBC_LIBS=" -L $GLIBC_BASE/lib"
 
+# snappy
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
 if test -z $PIC_BUILD; then
-  MAYBE_PIC=
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
 else
-  MAYBE_PIC=_pic
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
 fi
+CFLAGS+=" -DSNAPPY"
 
-if ! test $ROCKSDB_DISABLE_SNAPPY; then
-  # snappy
-  SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
-  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy${MAYBE_PIC}.a"
-  CFLAGS+=" -DSNAPPY"
-fi
-
-if ! test $ROCKSDB_DISABLE_ZLIB; then
+if test -z $PIC_BUILD; then
   # location of zlib headers and libraries
   ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
-  ZLIB_LIBS=" $ZLIB_BASE/lib/libz${MAYBE_PIC}.a"
+  ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
   CFLAGS+=" -DZLIB"
-fi
 
-if ! test $ROCKSDB_DISABLE_BZIP; then
   # location of bzip headers and libraries
   BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
-  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2${MAYBE_PIC}.a"
+  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2.a"
   CFLAGS+=" -DBZIP2"
-fi
 
-if ! test $ROCKSDB_DISABLE_LZ4; then
   LZ4_INCLUDE=" -I $LZ4_BASE/include/"
-  LZ4_LIBS=" $LZ4_BASE/lib/liblz4${MAYBE_PIC}.a"
+  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
   CFLAGS+=" -DLZ4"
 fi
 
-if ! test $ROCKSDB_DISABLE_ZSTD; then
-  ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
-  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd${MAYBE_PIC}.a"
-  CFLAGS+=" -DZSTD"
+ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
+if test -z $PIC_BUILD; then
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd.a"
+else
+  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd_pic.a"
 fi
+CFLAGS+=" -DZSTD"
 
 # location of gflags headers and libraries
 GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
-GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags${MAYBE_PIC}.a"
+if test -z $PIC_BUILD; then
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a"
+else
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
+fi
 CFLAGS+=" -DGFLAGS=gflags"
 
 BENCHMARK_INCLUDE=" -I $BENCHMARK_BASE/include/"
-BENCHMARK_LIBS=" $BENCHMARK_BASE/lib/libbenchmark${MAYBE_PIC}.a"
-
-GLOG_INCLUDE=" -I $GLOG_BASE/include/"
-GLOG_LIBS=" $GLOG_BASE/lib/libglog${MAYBE_PIC}.a"
+if test -z $PIC_BUILD; then
+  BENCHMARK_LIBS=" $BENCHMARK_BASE/lib/libbenchmark.a"
+else
+  BENCHMARK_LIBS=" $BENCHMARK_BASE/lib/libbenchmark_pic.a"
+fi
 
 # location of jemalloc
 JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
-JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc${MAYBE_PIC}.a"
+JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc.a"
 
-# location of numa
-NUMA_INCLUDE=" -I $NUMA_BASE/include/"
-NUMA_LIB=" $NUMA_BASE/lib/libnuma${MAYBE_PIC}.a"
-CFLAGS+=" -DNUMA"
+if test -z $PIC_BUILD; then
+  # location of numa
+  NUMA_INCLUDE=" -I $NUMA_BASE/include/"
+  NUMA_LIB=" $NUMA_BASE/lib/libnuma.a"
+  CFLAGS+=" -DNUMA"
 
-# location of libunwind
-LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind${MAYBE_PIC}.a"
+  # location of libunwind
+  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
+fi
 
 # location of TBB
 TBB_INCLUDE=" -isystem $TBB_BASE/include/"
-TBB_LIBS="$TBB_BASE/lib/libtbb${MAYBE_PIC}.a"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
 CFLAGS+=" -DTBB"
 
 # location of LIBURING
 LIBURING_INCLUDE=" -isystem $LIBURING_BASE/include/"
-LIBURING_LIBS="$LIBURING_BASE/lib/liburing${MAYBE_PIC}.a"
+if test -z $PIC_BUILD; then
+  LIBURING_LIBS="$LIBURING_BASE/lib/liburing.a"
+else
+  LIBURING_LIBS="$LIBURING_BASE/lib/liburing_pic.a"
+fi
 CFLAGS+=" -DLIBURING"
 
 test "$USE_SSE" || USE_SSE=1
@@ -102,7 +111,7 @@ BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
 AS="$BINUTILS/as"
 
-DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE $GLOG_INCLUDE"
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE"
 
 STDLIBS="-L $GCC_BASE/lib64"
 
@@ -145,7 +154,7 @@ else
 fi
 
 CFLAGS+=" $DEPS_INCLUDE"
-CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DHAVE_SSE42 -DROCKSDB_IOURING_PRESENT"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42 -DROCKSDB_IOURING_PRESENT"
 CXXFLAGS+=" $CFLAGS"
 
 EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"

build_tools/fbcode_config_platform010.sh

@@ -1,175 +0,0 @@
-#!/bin/sh
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-#
-# Set environment variables so that we can compile rocksdb using
-# fbcode settings.  It uses the latest g++ and clang compilers and also
-# uses jemalloc
-# Environment variables that change the behavior of this script:
-# PIC_BUILD -- if true, it will only take pic versions of libraries from fbcode. libraries that don't have pic variant will not be included
-
-
-BASEDIR=`dirname $BASH_SOURCE`
-source "$BASEDIR/dependencies_platform010.sh"
-
-# Disallow using libraries from default locations as they might not be compatible with platform010 libraries.
-CFLAGS=" --sysroot=/DOES/NOT/EXIST"
-
-# libgcc
-LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/trunk"
-LIBGCC_LIBS=" -L $LIBGCC_BASE/lib -B$LIBGCC_BASE/lib/gcc/x86_64-facebook-linux/trunk/"
-
-# glibc
-GLIBC_INCLUDE="$GLIBC_BASE/include"
-GLIBC_LIBS=" -L $GLIBC_BASE/lib"
-GLIBC_LIBS+=" -B$GLIBC_BASE/lib"
-
-if test -z $PIC_BUILD; then
-  MAYBE_PIC=
-else
-  MAYBE_PIC=_pic
-fi
-
-if ! test $ROCKSDB_DISABLE_SNAPPY; then
-  # snappy
-  SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
-  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy${MAYBE_PIC}.a"
-  CFLAGS+=" -DSNAPPY"
-fi
-
-if ! test $ROCKSDB_DISABLE_ZLIB; then
-  # location of zlib headers and libraries
-  ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
-  ZLIB_LIBS=" $ZLIB_BASE/lib/libz${MAYBE_PIC}.a"
-  CFLAGS+=" -DZLIB"
-fi
-
-if ! test $ROCKSDB_DISABLE_BZIP; then
-  # location of bzip headers and libraries
-  BZIP_INCLUDE=" -I $BZIP2_BASE/include/"
-  BZIP_LIBS=" $BZIP2_BASE/lib/libbz2${MAYBE_PIC}.a"
-  CFLAGS+=" -DBZIP2"
-fi
-
-if ! test $ROCKSDB_DISABLE_LZ4; then
-  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
-  LZ4_LIBS=" $LZ4_BASE/lib/liblz4${MAYBE_PIC}.a"
-  CFLAGS+=" -DLZ4"
-fi
-
-if ! test $ROCKSDB_DISABLE_ZSTD; then
-  ZSTD_INCLUDE=" -I $ZSTD_BASE/include/"
-  ZSTD_LIBS=" $ZSTD_BASE/lib/libzstd${MAYBE_PIC}.a"
-  CFLAGS+=" -DZSTD"
-fi
-
-# location of gflags headers and libraries
-GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
-GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags${MAYBE_PIC}.a"
-CFLAGS+=" -DGFLAGS=gflags"
-
-BENCHMARK_INCLUDE=" -I $BENCHMARK_BASE/include/"
-BENCHMARK_LIBS=" $BENCHMARK_BASE/lib/libbenchmark${MAYBE_PIC}.a"
-
-# location of jemalloc
-JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
-JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc${MAYBE_PIC}.a"
-
-# location of numa
-NUMA_INCLUDE=" -I $NUMA_BASE/include/"
-NUMA_LIB=" $NUMA_BASE/lib/libnuma${MAYBE_PIC}.a"
-CFLAGS+=" -DNUMA"
-
-# location of libunwind
-LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind${MAYBE_PIC}.a"
-
-# location of TBB
-TBB_INCLUDE=" -isystem $TBB_BASE/include/"
-TBB_LIBS="$TBB_BASE/lib/libtbb${MAYBE_PIC}.a"
-CFLAGS+=" -DTBB"
-
-# location of LIBURING
-LIBURING_INCLUDE=" -isystem $LIBURING_BASE/include/"
-LIBURING_LIBS="$LIBURING_BASE/lib/liburing${MAYBE_PIC}.a"
-CFLAGS+=" -DLIBURING"
-
-test "$USE_SSE" || USE_SSE=1
-export USE_SSE
-test "$PORTABLE" || PORTABLE=1
-export PORTABLE
-
-BINUTILS="$BINUTILS_BASE/bin"
-AR="$BINUTILS/ar"
-AS="$BINUTILS/as"
-
-DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $BZIP_INCLUDE $LZ4_INCLUDE $ZSTD_INCLUDE $GFLAGS_INCLUDE $NUMA_INCLUDE $TBB_INCLUDE $LIBURING_INCLUDE $BENCHMARK_INCLUDE"
-
-STDLIBS="-L $GCC_BASE/lib64"
-
-CLANG_BIN="$CLANG_BASE/bin"
-CLANG_LIB="$CLANG_BASE/lib"
-CLANG_SRC="$CLANG_BASE/../../src"
-
-CLANG_ANALYZER="$CLANG_BIN/clang++"
-CLANG_SCAN_BUILD="$CLANG_SRC/llvm/clang/tools/scan-build/bin/scan-build"
-
-if [ -z "$USE_CLANG" ]; then
-  # gcc
-  CC="$GCC_BASE/bin/gcc"
-  CXX="$GCC_BASE/bin/g++"
-  AR="$GCC_BASE/bin/gcc-ar"
-
-  CFLAGS+=" -B$BINUTILS -nostdinc -nostdlib"
-  CFLAGS+=" -I$GCC_BASE/include"
-  CFLAGS+=" -isystem $GCC_BASE/lib/gcc/x86_64-redhat-linux-gnu/11.2.1/include"
-  CFLAGS+=" -isystem $GCC_BASE/lib/gcc/x86_64-redhat-linux-gnu/11.2.1/install-tools/include"
-  CFLAGS+=" -isystem $GCC_BASE/lib/gcc/x86_64-redhat-linux-gnu/11.2.1/include-fixed/"
-  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
-  CFLAGS+=" -isystem $GLIBC_INCLUDE"
-  CFLAGS+=" -I$GLIBC_INCLUDE"
-  CFLAGS+=" -I$LIBGCC_BASE/include"
-  CFLAGS+=" -I$LIBGCC_BASE/include/c++/11.x/"
-  CFLAGS+=" -I$LIBGCC_BASE/include/c++/11.x/x86_64-facebook-linux/"
-  CFLAGS+=" -I$LIBGCC_BASE/include/c++/11.x/backward"
-  CFLAGS+=" -isystem $GLIBC_INCLUDE -I$GLIBC_INCLUDE"
-  JEMALLOC=1
-else
-  # clang
-  CLANG_INCLUDE="$CLANG_LIB/clang/stable/include"
-  CC="$CLANG_BIN/clang"
-  CXX="$CLANG_BIN/clang++"
-  AR="$CLANG_BIN/llvm-ar"
-
-  CFLAGS+=" -B$BINUTILS -nostdinc -nostdlib"
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/trunk "
-  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/trunk/x86_64-facebook-linux "
-  CFLAGS+=" -isystem $GLIBC_INCLUDE"
-  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
-  CFLAGS+=" -isystem $CLANG_INCLUDE"
-  CFLAGS+=" -Wno-expansion-to-defined "
-  CXXFLAGS="-nostdinc++"
-fi
-
-KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
-CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
-CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
-
-CFLAGS+=" $DEPS_INCLUDE"
-CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DHAVE_SSE42 -DROCKSDB_IOURING_PRESENT"
-CXXFLAGS+=" $CFLAGS"
-
-EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"
-EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform010/lib/ld.so"
-EXEC_LDFLAGS+=" $LIBUNWIND"
-EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform010/lib"
-EXEC_LDFLAGS+=" -Wl,-rpath=$GCC_BASE/lib64"
-# required by libtbb
-EXEC_LDFLAGS+=" -ldl"
-
-PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
-PLATFORM_LDFLAGS+=" -B$BINUTILS"
-
-EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS $LIBURING_LIBS $BENCHMARK_LIBS"
-
-VALGRIND_VER="$VALGRIND_BASE/bin/"
-
-export CC CXX AR AS CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB

build_tools/format-diff.sh

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

build_tools/gnu_parallel

@@ -1170,7 +1170,7 @@ sub parse_env_var {
     # Check if any variables contain \n
     if(my @v = map { s/BASH_FUNC_(.*)\(\)/$1/; $_ } grep { $ENV{$_}=~/\n/ } @vars) {
 	# \n is bad for csh and will cause it to fail.
-	$Global::envwarn = ::shell_quote_scalar(q{echo $SHELL | grep -E "/t?csh" > /dev/null && echo CSH/TCSH DO NOT SUPPORT newlines IN VARIABLES/FUNCTIONS. Unset }."@v".q{ && exec false;}."\n\n") . $Global::envwarn;
+	$Global::envwarn = ::shell_quote_scalar(q{echo $SHELL | egrep "/t?csh" > /dev/null && echo CSH/TCSH DO NOT SUPPORT newlines IN VARIABLES/FUNCTIONS. Unset }."@v".q{ && exec false;}."\n\n") . $Global::envwarn;
     }
 
     if(not @qcsh) { push @qcsh, "true"; }
@@ -1561,7 +1561,6 @@ sub save_stdin_stdout_stderr {
 	::die_bug("Can't dup STDERR: $!");
     open $Global::original_stdin, "<&", "STDIN" or
 	::die_bug("Can't dup STDIN: $!");
-    $Global::is_terminal = (-t $Global::original_stderr) && !$ENV{'CIRCLECI'} && !$ENV{'TRAVIS'};
 }
 
 sub enough_file_handles {
@@ -1841,17 +1840,12 @@ sub start_another_job {
 }
 }
 
-$opt::min_progress_interval = 0;
-
 sub init_progress {
     # Uses:
     #   $opt::bar
     # Returns:
     #   list of computers for progress output
     $|=1;
-    if (not $Global::is_terminal) {
-      $opt::min_progress_interval = 30;
-    }
     if($opt::bar) {
 	return("","");
     }
@@ -1876,9 +1870,6 @@ sub drain_job_queue {
     }
     my $last_header="";
     my $sleep = 0.2;
-    my $last_left = 1000000000;
-    my $last_progress_time = 0;
-    my $ps_reported = 0;
     do {
         while($Global::total_running > 0) {
             debug($Global::total_running, "==", scalar
@@ -1889,39 +1880,14 @@ sub drain_job_queue {
 		    close $job->fh(0,"w");
 		}
 	    }
-            # When not connected to terminal, assume CI (e.g. CircleCI). In
-            # that case we want occasional progress output to prevent abort
-            # due to timeout with no output, but we also need to stop sending
-            # progress output if there has been no actual progress, so that
-            # the job can time out appropriately (CirecleCI: 10m) in case of
-            # a hung test. But without special output, it is extremely
-            # annoying to diagnose which test is hung, so we add that using
-            # `ps` below.
-            if($opt::progress and
-               ($Global::is_terminal or (time() - $last_progress_time) >= 30)) {
+            if($opt::progress) {
                 my %progress = progress();
                 if($last_header ne $progress{'header'}) {
                     print $Global::original_stderr "\n", $progress{'header'}, "\n";
                     $last_header = $progress{'header'};
                 }
-                if ($Global::is_terminal) {
-                    print $Global::original_stderr "\r",$progress{'status'};
-                }
-                if ($last_left > $Global::left) {
-                    if (not $Global::is_terminal) {
-                        print $Global::original_stderr $progress{'status'},"\n";
-                    }
-                    $last_progress_time = time();
-                    $ps_reported = 0;
-                } elsif (not $ps_reported and (time() - $last_progress_time) >= 60) {
-                    # No progress in at least 60 seconds: run ps
-                    print $Global::original_stderr "\n";
-                    my $script_dir = ::dirname($0);
-                    system("$script_dir/ps_with_stack || ps -wwf");
-                    $ps_reported = 1;
-                }
-                $last_left = $Global::left;
-                flush $Global::original_stderr;
+                print $Global::original_stderr "\r",$progress{'status'};
+		flush $Global::original_stderr;
             }
 	    if($Global::total_running < $Global::max_jobs_running
 	       and not $Global::JobQueue->empty()) {
@@ -1955,7 +1921,7 @@ sub drain_job_queue {
 	     not $Global::start_no_new_jobs and not $Global::JobQueue->empty());
     if($opt::progress) {
 	my %progress = progress();
-	print $Global::original_stderr $opt::progress_sep, $progress{'status'}, "\n";
+	print $Global::original_stderr "\r", $progress{'status'}, "\n";
 	flush $Global::original_stderr;
     }
 }
@@ -1988,11 +1954,10 @@ sub progress {
     my $eta = "";
     my ($status,$header)=("","");
     if($opt::eta) {
-      my($total, $completed, $left, $pctcomplete, $avgtime, $this_eta) =
-        compute_eta();
-      $eta = sprintf("ETA: %ds Left: %d AVG: %.2fs  ",
-        $this_eta, $left, $avgtime);
-      $Global::left = $left;
+	my($total, $completed, $left, $pctcomplete, $avgtime, $this_eta) =
+	    compute_eta();
+	$eta = sprintf("ETA: %ds Left: %d AVG: %.2fs  ",
+		       $this_eta, $left, $avgtime);
     }
     my $termcols = terminal_columns();
     my @workers = sort keys %Global::host;

build_tools/precommit_checker.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python2.7
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+import argparse
+import commands
+import subprocess
+import sys
+import re
+import os
+import time
+
+
+#
+# Simple logger
+#
+
+class Log:
+
+    def __init__(self, filename):
+        self.filename = filename
+        self.f = open(self.filename, 'w+', 0)
+
+    def caption(self, str):
+        line = "\n##### %s #####\n" % str
+        if self.f:
+            self.f.write("%s \n" % line)
+        else:
+            print(line)
+
+    def error(self, str):
+        data = "\n\n##### ERROR ##### %s" % str
+        if self.f:
+            self.f.write("%s \n" % data)
+        else:
+            print(data)
+
+    def log(self, str):
+        if self.f:
+            self.f.write("%s \n" % str)
+        else:
+            print(str)
+
+#
+# Shell Environment
+#
+
+
+class Env(object):
+
+    def __init__(self, logfile, tests):
+        self.tests = tests
+        self.log = Log(logfile)
+
+    def shell(self, cmd, path=os.getcwd()):
+        if path:
+            os.chdir(path)
+
+        self.log.log("==== shell session ===========================")
+        self.log.log("%s> %s" % (path, cmd))
+        status = subprocess.call("cd %s; %s" % (path, cmd), shell=True,
+                                 stdout=self.log.f, stderr=self.log.f)
+        self.log.log("status = %s" % status)
+        self.log.log("============================================== \n\n")
+        return status
+
+    def GetOutput(self, cmd, path=os.getcwd()):
+        if path:
+            os.chdir(path)
+
+        self.log.log("==== shell session ===========================")
+        self.log.log("%s> %s" % (path, cmd))
+        status, out = commands.getstatusoutput(cmd)
+        self.log.log("status = %s" % status)
+        self.log.log("out = %s" % out)
+        self.log.log("============================================== \n\n")
+        return status, out
+
+#
+# Pre-commit checker
+#
+
+
+class PreCommitChecker(Env):
+
+    def __init__(self, args):
+        Env.__init__(self, args.logfile, args.tests)
+        self.ignore_failure = args.ignore_failure
+
+    #
+    #   Get commands for a given job from the determinator file
+    #
+    def get_commands(self, test):
+        status, out = self.GetOutput(
+            "RATIO=1 build_tools/rocksdb-lego-determinator %s" % test, ".")
+        return status, out
+
+    #
+    # Run a specific CI job
+    #
+    def run_test(self, test):
+        self.log.caption("Running test %s locally" % test)
+
+        # get commands for the CI job determinator
+        status, cmds = self.get_commands(test)
+        if status != 0:
+            self.log.error("Error getting commands for test %s" % test)
+            return False
+
+        # Parse the JSON to extract the commands to run
+        cmds = re.findall("'shell':'([^\']*)'", cmds)
+
+        if len(cmds) == 0:
+            self.log.log("No commands found")
+            return False
+
+        # Run commands
+        for cmd in cmds:
+            # Replace J=<..> with the local environment variable
+            if "J" in os.environ:
+                cmd = cmd.replace("J=1", "J=%s" % os.environ["J"])
+                cmd = cmd.replace("make ", "make -j%s " % os.environ["J"])
+            # Run the command
+            status = self.shell(cmd, ".")
+            if status != 0:
+                self.log.error("Error running command %s for test %s"
+                               % (cmd, test))
+                return False
+
+        return True
+
+    #
+    # Run specified CI jobs
+    #
+    def run_tests(self):
+        if not self.tests:
+            self.log.error("Invalid args. Please provide tests")
+            return False
+
+        self.print_separator()
+        self.print_row("TEST", "RESULT")
+        self.print_separator()
+
+        result = True
+        for test in self.tests:
+            start_time = time.time()
+            self.print_test(test)
+            result = self.run_test(test)
+            elapsed_min = (time.time() - start_time) / 60
+            if not result:
+                self.log.error("Error running test %s" % test)
+                self.print_result("FAIL (%dm)" % elapsed_min)
+                if not self.ignore_failure:
+                    return False
+                result = False
+            else:
+                self.print_result("PASS (%dm)" % elapsed_min)
+
+        self.print_separator()
+        return result
+
+    #
+    # Print a line
+    #
+    def print_separator(self):
+        print("".ljust(60, "-"))
+
+    #
+    # Print two colums
+    #
+    def print_row(self, c0, c1):
+        print("%s%s" % (c0.ljust(40), c1.ljust(20)))
+
+    def print_test(self, test):
+        print(test.ljust(40), end="")
+        sys.stdout.flush()
+
+    def print_result(self, result):
+        print(result.ljust(20))
+
+#
+# Main
+#
+parser = argparse.ArgumentParser(description='RocksDB pre-commit checker.')
+
+# --log <logfile>
+parser.add_argument('--logfile', default='/tmp/precommit-check.log',
+                    help='Log file. Default is /tmp/precommit-check.log')
+# --ignore_failure
+parser.add_argument('--ignore_failure', action='store_true', default=False,
+                    help='Stop when an error occurs')
+# <test ....>
+parser.add_argument('tests', nargs='+',
+                    help='CI test(s) to run. e.g: unit punit asan tsan ubsan')
+
+args = parser.parse_args()
+checker = PreCommitChecker(args)
+
+print("Please follow log %s" % checker.log.filename)
+
+if not checker.run_tests():
+    print("Error running tests. Please check log file %s"
+          % checker.log.filename)
+    sys.exit(1)
+
+sys.exit(0)

build_tools/ps_with_stack

@@ -1,38 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-
-open(my $ps, "-|", "ps -wwf");
-my $cols_known = 0;
-my $cmd_col = 0;
-my $pid_col = 0;
-while (<$ps>) {
-  print;
-  my @cols = split(/\s+/);
-
-  if (!$cols_known && /CMD/) {
-    # Parse relevant ps column headers
-    for (my $i = 0; $i <= $#cols; $i++) {
-      if ($cols[$i] eq "CMD") {
-        $cmd_col = $i;
-      }
-      if ($cols[$i] eq "PID") {
-        $pid_col = $i;
-      }
-    }
-    $cols_known = 1;
-  } else {
-    my $pid = $cols[$pid_col];
-    my $cmd = $cols[$cmd_col];
-    # Match numeric PID and relative path command
-    # -> The intention is only to dump stack traces for hangs in code under
-    # test, which means we probably just built it and are executing by
-    # relative path (e.g. ./my_test or foo/bar_test) rather then by absolute
-    # path (e.g. /usr/bin/time) or PATH search (e.g. grep).
-    if ($pid =~ /^[0-9]+$/ && $cmd =~ /^[^\/ ]+[\/]/) {
-      print "Dumping stacks for $pid...\n";
-      system("pstack $pid || gdb -batch -p $pid -ex 'thread apply all bt'");
-    }
-  }
-}
-close $ps;

build_tools/regression_build_test.sh

@@ -258,6 +258,7 @@ common_in_mem_args="--db=/dev/shm/rocksdb \
     --value_size=100 \
     --compression_type=none \
     --compression_ratio=1 \
+    --hard_rate_limit=2 \
     --write_buffer_size=134217728 \
     --max_write_buffer_number=4 \
     --level0_file_num_compaction_trigger=8 \

build_tools/run_ci_db_test.ps1

@@ -42,7 +42,7 @@ $RunOnly.Add("c_test") | Out-Null
 $RunOnly.Add("compact_on_deletion_collector_test") | Out-Null
 $RunOnly.Add("merge_test") | Out-Null
 $RunOnly.Add("stringappend_test") | Out-Null # Apparently incorrectly written
-$RunOnly.Add("backup_engine_test") | Out-Null # Disabled
+$RunOnly.Add("backupable_db_test") | Out-Null # Disabled
 $RunOnly.Add("timer_queue_test") | Out-Null # Not a gtest
 
 if($RunAll -and $SuiteRun -ne "") {
@@ -491,3 +491,5 @@ if(!$script:success) {
  }
 
  exit 0
+
+

build_tools/ubuntu20_image/Dockerfile

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

build_tools/update_dependencies.sh

@@ -9,7 +9,6 @@ OUTPUT=""
 function log_header()
 {
   echo "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved." >> "$OUTPUT"
-  echo "# The file is generated using update_dependencies.sh." >> "$OUTPUT"
 }
 
 
@@ -19,7 +18,7 @@ function log_variable()
 }
 
 
-TP2_LATEST="/data/users/$USER/fbsource/fbcode/third-party2/"
+TP2_LATEST="/mnt/vol/engshare/fbcode/third-party2"
 ## $1 => lib name
 ## $2 => lib version (if not provided, will try to pick latest)
 ## $3 => platform (if not provided, will try to pick latest gcc)
@@ -51,8 +50,6 @@ function get_lib_base()
   fi
   
   result=`ls -1d $result/*/ | head -n1`
-
-  echo Finding link $result
   
   # lib_name => LIB_NAME_BASE
   local __res_var=${lib_name^^}"_BASE"
@@ -64,10 +61,10 @@ function get_lib_base()
 }
 
 ###########################################################
-#                platform010 dependencies                 #
+#                platform007 dependencies                 #
 ###########################################################
 
-OUTPUT="$BASEDIR/dependencies_platform010.sh"
+OUTPUT="$BASEDIR/dependencies_platform007.sh"
 
 rm -f "$OUTPUT"
 touch "$OUTPUT"
@@ -75,42 +72,40 @@ touch "$OUTPUT"
 echo "Writing dependencies to $OUTPUT"
 
 # Compilers locations
-GCC_BASE=`readlink -f $TP2_LATEST/gcc/11.x/centos7-native/*/`
-CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/12/platform010/*/`
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/7.x/centos7-native/*/`
+CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos7-native/*/`
 
 log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE
 
 # Libraries locations
-get_lib_base libgcc     11.x    platform010
-get_lib_base glibc      2.34    platform010
-get_lib_base snappy     LATEST  platform010
-get_lib_base zlib       LATEST  platform010
-get_lib_base bzip2      LATEST  platform010
-get_lib_base lz4        LATEST  platform010
-get_lib_base zstd       LATEST  platform010
-get_lib_base gflags     LATEST  platform010
-get_lib_base jemalloc   LATEST  platform010
-get_lib_base numa       LATEST  platform010
-get_lib_base libunwind  LATEST  platform010
-get_lib_base tbb        2018_U5 platform010
-get_lib_base liburing   LATEST  platform010
-get_lib_base benchmark  LATEST  platform010
+get_lib_base libgcc     7.x     platform007
+get_lib_base glibc      2.26    platform007
+get_lib_base snappy     LATEST  platform007
+get_lib_base zlib       LATEST  platform007
+get_lib_base bzip2      LATEST  platform007
+get_lib_base lz4        LATEST  platform007
+get_lib_base zstd       LATEST  platform007
+get_lib_base gflags     LATEST  platform007
+get_lib_base jemalloc   LATEST  platform007
+get_lib_base numa       LATEST  platform007
+get_lib_base libunwind  LATEST  platform007
+get_lib_base tbb        LATEST  platform007
+get_lib_base liburing   LATEST  platform007
 
-get_lib_base kernel-headers fb platform010
+get_lib_base kernel-headers fb platform007
 get_lib_base binutils   LATEST centos7-native
-get_lib_base valgrind   LATEST platform010
-get_lib_base lua        5.3.4  platform010
+get_lib_base valgrind   LATEST platform007
+get_lib_base lua        5.3.4  platform007
 
 git diff $OUTPUT
 
-
 ###########################################################
-#                platform009 dependencies                 #
+#                   5.x dependencies                      #
 ###########################################################
 
-OUTPUT="$BASEDIR/dependencies_platform009.sh"
+OUTPUT="$BASEDIR/dependencies.sh"
 
 rm -f "$OUTPUT"
 touch "$OUTPUT"
@@ -118,32 +113,70 @@ touch "$OUTPUT"
 echo "Writing dependencies to $OUTPUT"
 
 # Compilers locations
-GCC_BASE=`readlink -f $TP2_LATEST/gcc/9.x/centos7-native/*/`
-CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/9.0.0/platform009/*/`
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/5.x/centos7-native/*/`
+CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos7-native/*/`
 
 log_header
 log_variable GCC_BASE
 log_variable CLANG_BASE
 
 # Libraries locations
-get_lib_base libgcc     9.x     platform009
-get_lib_base glibc      2.30    platform009
-get_lib_base snappy     LATEST  platform009
-get_lib_base zlib       LATEST  platform009
-get_lib_base bzip2      LATEST  platform009
-get_lib_base lz4        LATEST  platform009
-get_lib_base zstd       LATEST  platform009
-get_lib_base gflags     LATEST  platform009
-get_lib_base jemalloc   LATEST  platform009
-get_lib_base numa       LATEST  platform009
-get_lib_base libunwind  LATEST  platform009
-get_lib_base tbb        2018_U5 platform009
-get_lib_base liburing   LATEST  platform009
-get_lib_base benchmark  LATEST  platform009
+get_lib_base libgcc     5.x     gcc-5-glibc-2.23
+get_lib_base glibc      2.23    gcc-5-glibc-2.23
+get_lib_base snappy     LATEST  gcc-5-glibc-2.23
+get_lib_base zlib       LATEST  gcc-5-glibc-2.23
+get_lib_base bzip2      LATEST  gcc-5-glibc-2.23
+get_lib_base lz4        LATEST  gcc-5-glibc-2.23
+get_lib_base zstd       LATEST  gcc-5-glibc-2.23
+get_lib_base gflags     LATEST  gcc-5-glibc-2.23
+get_lib_base jemalloc   LATEST  gcc-5-glibc-2.23
+get_lib_base numa       LATEST  gcc-5-glibc-2.23
+get_lib_base libunwind  LATEST  gcc-5-glibc-2.23
+get_lib_base tbb        LATEST  gcc-5-glibc-2.23
 
-get_lib_base kernel-headers fb platform009
+get_lib_base kernel-headers 4.0.9-36_fbk5_2933_gd092e3f gcc-5-glibc-2.23
 get_lib_base binutils   LATEST centos7-native
-get_lib_base valgrind   LATEST platform009
-get_lib_base lua        5.3.4  platform009
+get_lib_base valgrind   LATEST gcc-5-glibc-2.23
+get_lib_base lua        5.2.3 gcc-5-glibc-2.23
+
+git diff $OUTPUT
+
+###########################################################
+#                   4.8.1 dependencies                    #
+###########################################################
+
+OUTPUT="$BASEDIR/dependencies_4.8.1.sh"
+
+rm -f "$OUTPUT"
+touch "$OUTPUT"
+
+echo "Writing 4.8.1 dependencies to $OUTPUT"
+
+# Compilers locations
+GCC_BASE=`readlink -f $TP2_LATEST/gcc/4.8.1/centos6-native/*/`
+CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/stable/centos6-native/*/`
+
+log_header
+log_variable GCC_BASE
+log_variable CLANG_BASE
+
+# Libraries locations
+get_lib_base libgcc     4.8.1  gcc-4.8.1-glibc-2.17
+get_lib_base glibc      2.17   gcc-4.8.1-glibc-2.17  
+get_lib_base snappy     LATEST gcc-4.8.1-glibc-2.17
+get_lib_base zlib       LATEST gcc-4.8.1-glibc-2.17
+get_lib_base bzip2      LATEST gcc-4.8.1-glibc-2.17
+get_lib_base lz4        LATEST gcc-4.8.1-glibc-2.17
+get_lib_base zstd       LATEST gcc-4.8.1-glibc-2.17
+get_lib_base gflags     LATEST gcc-4.8.1-glibc-2.17
+get_lib_base jemalloc   LATEST gcc-4.8.1-glibc-2.17
+get_lib_base numa       LATEST gcc-4.8.1-glibc-2.17
+get_lib_base libunwind  LATEST gcc-4.8.1-glibc-2.17
+get_lib_base tbb        4.0_update2 gcc-4.8.1-glibc-2.17
+
+get_lib_base kernel-headers LATEST gcc-4.8.1-glibc-2.17 
+get_lib_base binutils   LATEST centos6-native 
+get_lib_base valgrind   3.8.1  gcc-4.8.1-glibc-2.17
+get_lib_base lua        5.2.3 centos6-native
 
 git diff $OUTPUT

cache/cache.cc

@@ -16,6 +16,7 @@
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
+#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, OptionTypeInfo>
     lru_cache_options_type_info = {
         {"capacity",
@@ -32,64 +33,14 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct LRUCacheOptions, high_pri_pool_ratio),
           OptionType::kDouble, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
-        {"low_pri_pool_ratio",
-         {offsetof(struct LRUCacheOptions, low_pri_pool_ratio),
-          OptionType::kDouble, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-};
-
-static std::unordered_map<std::string, OptionTypeInfo>
-    comp_sec_cache_options_type_info = {
-        {"capacity",
-         {offsetof(struct CompressedSecondaryCacheOptions, capacity),
-          OptionType::kSizeT, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-        {"num_shard_bits",
-         {offsetof(struct CompressedSecondaryCacheOptions, num_shard_bits),
-          OptionType::kInt, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-        {"compression_type",
-         {offsetof(struct CompressedSecondaryCacheOptions, compression_type),
-          OptionType::kCompressionType, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-        {"compress_format_version",
-         {offsetof(struct CompressedSecondaryCacheOptions,
-                   compress_format_version),
-          OptionType::kUInt32T, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
-        {"enable_custom_split_merge",
-         {offsetof(struct CompressedSecondaryCacheOptions,
-                   enable_custom_split_merge),
-          OptionType::kBoolean, OptionVerificationType::kNormal,
-          OptionTypeFlags::kMutable}},
 };
+#endif  // ROCKSDB_LITE
 
 Status SecondaryCache::CreateFromString(
     const ConfigOptions& config_options, const std::string& value,
     std::shared_ptr<SecondaryCache>* result) {
-  if (value.find("compressed_secondary_cache://") == 0) {
-    std::string args = value;
-    args.erase(0, std::strlen("compressed_secondary_cache://"));
-    Status status;
-    std::shared_ptr<SecondaryCache> sec_cache;
-
-    CompressedSecondaryCacheOptions sec_cache_opts;
-    status = OptionTypeInfo::ParseStruct(config_options, "",
-                                         &comp_sec_cache_options_type_info, "",
-                                         args, &sec_cache_opts);
-    if (status.ok()) {
-      sec_cache = NewCompressedSecondaryCache(sec_cache_opts);
-    }
-
-
-    if (status.ok()) {
-      result->swap(sec_cache);
-    }
-    return status;
-  } else {
-    return LoadSharedObject<SecondaryCache>(config_options, value, nullptr,
-                                            result);
-  }
+  return LoadSharedObject<SecondaryCache>(config_options, value, nullptr,
+                                          result);
 }
 
 Status Cache::CreateFromString(const ConfigOptions& config_options,
@@ -100,6 +51,7 @@ 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, "",
@@ -107,6 +59,10 @@ 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);

cache/cache_bench_tool.cc

@@ -3,17 +3,13 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include "cache_key.h"
 #ifdef GFLAGS
 #include <cinttypes>
-#include <cstddef>
 #include <cstdio>
 #include <limits>
-#include <memory>
 #include <set>
 #include <sstream>
 
-#include "db/db_impl/db_impl.h"
 #include "monitoring/histogram.h"
 #include "port/port.h"
 #include "rocksdb/cache.h"
@@ -22,11 +18,8 @@
 #include "rocksdb/env.h"
 #include "rocksdb/secondary_cache.h"
 #include "rocksdb/system_clock.h"
-#include "rocksdb/table_properties.h"
-#include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/cachable_entry.h"
 #include "util/coding.h"
-#include "util/distributed_mutex.h"
 #include "util/gflags_compat.h"
 #include "util/hash.h"
 #include "util/mutexlock.h"
@@ -72,69 +65,13 @@ DEFINE_uint32(
 DEFINE_uint32(gather_stats_entries_per_lock, 256,
               "For Cache::ApplyToAllEntries");
 DEFINE_bool(skewed, false, "If true, skew the key access distribution");
-
-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.");
-
-// ## BEGIN stress_cache_key sub-tool options ##
-// See class StressCacheKey below.
-DEFINE_bool(stress_cache_key, false,
-            "If true, run cache key stress test instead");
-DEFINE_uint32(
-    sck_files_per_day, 2500000,
-    "(-stress_cache_key) Simulated files generated per simulated day");
-// NOTE: Giving each run a specified lifetime, rather than e.g. "until
-// first collision" ensures equal skew from start-up, when collisions are
-// less likely.
-DEFINE_uint32(sck_days_per_run, 90,
-              "(-stress_cache_key) Number of days to simulate in each run");
-// NOTE: The number of observed collisions directly affects the relative
-// accuracy of the predicted probabilities. 15 observations should be well
-// within factor-of-2 accuracy.
-DEFINE_uint32(
-    sck_min_collision, 15,
-    "(-stress_cache_key) Keep running until this many collisions seen");
-// sck_file_size_mb can be thought of as average file size. The simulation is
-// not precise enough to care about the distribution of file sizes; other
-// simulations (https://github.com/pdillinger/unique_id/tree/main/monte_carlo)
-// indicate the distribution only makes a small difference (e.g. < 2x factor)
-DEFINE_uint32(
-    sck_file_size_mb, 32,
-    "(-stress_cache_key) Simulated file size in MiB, for accounting purposes");
-DEFINE_uint32(sck_reopen_nfiles, 100,
-              "(-stress_cache_key) Simulate DB re-open average every n files");
-DEFINE_uint32(sck_newdb_nreopen, 1000,
-              "(-stress_cache_key) Simulate new DB average every n re-opens");
-DEFINE_uint32(sck_restarts_per_day, 24,
-              "(-stress_cache_key) Average simulated process restarts per day "
-              "(across DBs)");
-DEFINE_uint32(
-    sck_db_count, 100,
-    "(-stress_cache_key) Parallel DBs in simulation sharing a block cache");
-DEFINE_uint32(
-    sck_table_bits, 20,
-    "(-stress_cache_key) Log2 number of tracked (live) files (across DBs)");
-// sck_keep_bits being well below full 128 bits amplifies the collision
-// probability so that the true probability can be estimated through observed
-// collisions. (More explanation below.)
-DEFINE_uint32(
-    sck_keep_bits, 50,
-    "(-stress_cache_key) Number of bits to keep from each cache key (<= 64)");
-// sck_randomize is used to validate whether cache key is performing "better
-// than random." Even with this setting, file offsets are not randomized.
-DEFINE_bool(sck_randomize, false,
-            "(-stress_cache_key) Randomize (hash) cache key");
-// See https://github.com/facebook/rocksdb/pull/9058
-DEFINE_bool(sck_footer_unique_id, false,
-            "(-stress_cache_key) Simulate using proposed footer unique id");
-// ## END stress_cache_key sub-tool options ##
+DEFINE_bool(use_clock_cache, false, "");
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -219,12 +156,11 @@ struct KeyGen {
     EncodeFixed64(key_data + 10, key);
     key_data[18] = char{4};
     EncodeFixed64(key_data + 19, key);
-    assert(27 >= kCacheKeySize);
-    return Slice(&key_data[off], kCacheKeySize);
+    return Slice(&key_data[off], sizeof(key_data) - off);
   }
 };
 
-Cache::ObjectPtr createValue(Random64& rnd) {
+char* 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) {
@@ -234,33 +170,28 @@ Cache::ObjectPtr createValue(Random64& rnd) {
 }
 
 // Callbacks for secondary cache
-size_t SizeFn(Cache::ObjectPtr /*obj*/) { return FLAGS_value_bytes; }
+size_t SizeFn(void* /*obj*/) { return FLAGS_value_bytes; }
 
-Status SaveToFn(Cache::ObjectPtr from_obj, size_t /*from_offset*/,
-                size_t length, char* out) {
-  memcpy(out, from_obj, length);
+Status SaveToFn(void* obj, size_t /*offset*/, size_t size, void* out) {
+  memcpy(out, obj, size);
   return Status::OK();
 }
 
-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*/) {
+// 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) {
   delete[] static_cast<char*>(value);
 }
 
-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);
+Cache::CacheItemHelper helper1(SizeFn, SaveToFn, deleter1);
+Cache::CacheItemHelper helper2(SizeFn, SaveToFn, deleter2);
+Cache::CacheItemHelper helper3(SizeFn, SaveToFn, deleter3);
 }  // namespace
 
 class CacheBench {
@@ -289,20 +220,18 @@ class CacheBench {
     if (skewed_) {
       uint64_t max_key = max_key_;
       while (max_key >>= 1) max_log_++;
-      if (max_key > (static_cast<uint64_t>(1) << max_log_)) max_log_++;
+      if (max_key > (1u << max_log_)) max_log_++;
     }
 
-    if (FLAGS_cache_type == "clock_cache") {
-      fprintf(stderr, "Old clock cache implementation has been removed.\n");
-      exit(1);
-    } else if (FLAGS_cache_type == "hyper_clock_cache") {
-      cache_ = HyperClockCacheOptions(FLAGS_cache_size, FLAGS_value_bytes,
-                                      FLAGS_num_shard_bits)
-                   .MakeSharedCache();
-    } 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 */);
+    if (FLAGS_use_clock_cache) {
+      cache_ = NewClockCache(FLAGS_cache_size, FLAGS_num_shard_bits);
+      if (!cache_) {
+        fprintf(stderr, "Clock cache not supported.\n");
+        exit(1);
+      }
+    } else {
+      LRUCacheOptions opts(FLAGS_cache_size, FLAGS_num_shard_bits, false, 0.5);
+#ifndef ROCKSDB_LITE
       if (!FLAGS_secondary_cache_uri.empty()) {
         Status s = SecondaryCache::CreateFromString(
             ConfigOptions(), FLAGS_secondary_cache_uri, &secondary_cache);
@@ -315,11 +244,9 @@ class CacheBench {
         }
         opts.secondary_cache = secondary_cache;
       }
+#endif  // ROCKSDB_LITE
 
       cache_ = NewLRUCache(opts);
-    } else {
-      fprintf(stderr, "Cache type not supported.");
-      exit(1);
     }
   }
 
@@ -329,9 +256,8 @@ class CacheBench {
     Random64 rnd(1);
     KeyGen keygen;
     for (uint64_t i = 0; i < 2 * FLAGS_cache_size; i += FLAGS_value_bytes) {
-      Status s = cache_->Insert(keygen.GetRand(rnd, max_key_, max_log_),
-                                createValue(rnd), &helper1, FLAGS_value_bytes);
-      assert(s.ok());
+      cache_->Insert(keygen.GetRand(rnd, max_key_, max_log_), createValue(rnd),
+                     &helper1, FLAGS_value_bytes);
     }
   }
 
@@ -435,9 +361,7 @@ class CacheBench {
     uint64_t total_key_size = 0;
     uint64_t total_charge = 0;
     uint64_t total_entry_count = 0;
-    uint64_t table_occupancy = 0;
-    uint64_t table_size = 0;
-    std::set<const Cache::CacheItemHelper*> helpers;
+    std::set<Cache::DeleterFn> deleters;
     StopWatchNano timer(clock);
 
     for (;;) {
@@ -452,17 +376,13 @@ class CacheBench {
             std::ostringstream ostr;
             ostr << "Most recent cache entry stats:\n"
                  << "Number of entries: " << total_entry_count << "\n"
-                 << "Table occupancy: " << table_occupancy << " / "
-                 << table_size << " = "
-                 << (100.0 * table_occupancy / table_size) << "%\n"
                  << "Total charge: " << BytesToHumanString(total_charge) << "\n"
                  << "Average key size: "
                  << (1.0 * total_key_size / total_entry_count) << "\n"
                  << "Average charge: "
-                 << BytesToHumanString(static_cast<uint64_t>(
-                        1.0 * total_charge / total_entry_count))
+                 << BytesToHumanString(1.0 * total_charge / total_entry_count)
                  << "\n"
-                 << "Unique helpers: " << helpers.size() << "\n";
+                 << "Unique deleters: " << deleters.size() << "\n";
             *stats_report = ostr.str();
             return;
           }
@@ -478,21 +398,19 @@ class CacheBench {
       total_key_size = 0;
       total_charge = 0;
       total_entry_count = 0;
-      helpers.clear();
-      auto fn = [&](const Slice& key, Cache::ObjectPtr /*value*/, size_t charge,
-                    const Cache::CacheItemHelper* helper) {
+      deleters.clear();
+      auto fn = [&](const Slice& key, void* /*value*/, size_t charge,
+                    Cache::DeleterFn deleter) {
         total_key_size += key.size();
         total_charge += charge;
         ++total_entry_count;
-        // Something slightly more expensive as in stats by category
-        helpers.insert(helper);
+        // Something slightly more expensive as in (future) stats by category
+        deleters.insert(deleter);
       };
       timer.Start();
       Cache::ApplyToAllEntriesOptions opts;
       opts.average_entries_per_lock = FLAGS_gather_stats_entries_per_lock;
       shared->GetCacheBench()->cache_->ApplyToAllEntries(fn, opts);
-      table_occupancy = shared->GetCacheBench()->cache_->GetOccupancyCount();
-      table_size = shared->GetCacheBench()->cache_->GetTableAddressCount();
       stats_hist->Add(timer.ElapsedNanos() / 1000);
     }
   }
@@ -532,10 +450,16 @@ class CacheBench {
     StopWatchNano timer(clock);
 
     for (uint64_t i = 0; i < FLAGS_ops_per_thread; i++) {
+      timer.Start();
       Slice key = gen.GetRand(thread->rnd, max_key_, max_log_);
       uint64_t random_op = thread->rnd.Next();
-
-      timer.Start();
+      Cache::CreateCallback create_cb =
+          [](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();
+      };
 
       if (random_op < lookup_insert_threshold_) {
         if (handle) {
@@ -543,19 +467,16 @@ class CacheBench {
           handle = nullptr;
         }
         // do lookup
-        handle = cache_->Lookup(key, &helper2, /*context*/ nullptr,
-                                Cache::Priority::LOW, true);
+        handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
+                                true);
         if (handle) {
-          if (!FLAGS_lean) {
-            // do something with the data
-            result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                               FLAGS_value_bytes);
-          }
+          // do something with the data
+          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                             FLAGS_value_bytes);
         } else {
           // do insert
-          Status s = cache_->Insert(key, createValue(thread->rnd), &helper2,
-                                    FLAGS_value_bytes, &handle);
-          assert(s.ok());
+          cache_->Insert(key, createValue(thread->rnd), &helper2,
+                         FLAGS_value_bytes, &handle);
         }
       } else if (random_op < insert_threshold_) {
         if (handle) {
@@ -563,23 +484,20 @@ class CacheBench {
           handle = nullptr;
         }
         // do insert
-        Status s = cache_->Insert(key, createValue(thread->rnd), &helper3,
-                                  FLAGS_value_bytes, &handle);
-        assert(s.ok());
+        cache_->Insert(key, createValue(thread->rnd), &helper3,
+                       FLAGS_value_bytes, &handle);
       } else if (random_op < lookup_threshold_) {
         if (handle) {
           cache_->Release(handle);
           handle = nullptr;
         }
         // do lookup
-        handle = cache_->Lookup(key, &helper2, /*context*/ nullptr,
-                                Cache::Priority::LOW, true);
+        handle = cache_->Lookup(key, &helper2, create_cb, Cache::Priority::LOW,
+                                true);
         if (handle) {
-          if (!FLAGS_lean) {
-            // do something with the data
-            result += NPHash64(static_cast<char*>(cache_->Value(handle)),
-                               FLAGS_value_bytes);
-          }
+          // do something with the data
+          result += NPHash64(static_cast<char*>(cache_->Value(handle)),
+                             FLAGS_value_bytes);
         }
       } else if (random_op < erase_threshold_) {
         // do erase
@@ -603,15 +521,7 @@ class CacheBench {
   }
 
   void PrintEnv() const {
-#if defined(__GNUC__) && !defined(__OPTIMIZE__)
-    printf(
-        "WARNING: Optimization is disabled: benchmarks unnecessarily slow\n");
-#endif
-#ifndef NDEBUG
-    printf("WARNING: Assertions are enabled; benchmarks unnecessarily slow\n");
-#endif
     printf("RocksDB version     : %d.%d\n", kMajorVersion, kMinorVersion);
-    printf("DMutex impl name    : %s\n", DMutex::kName());
     printf("Number of threads   : %u\n", FLAGS_threads);
     printf("Ops per thread      : %" PRIu64 "\n", FLAGS_ops_per_thread);
     printf("Cache size          : %s\n",
@@ -637,313 +547,9 @@ class CacheBench {
   }
 };
 
-// cache_bench -stress_cache_key is an independent embedded tool for
-// estimating the probability of CacheKey collisions through simulation.
-// At a high level, it simulates generating SST files over many months,
-// keeping them in the DB and/or cache for some lifetime while staying
-// under resource caps, and checking for any cache key collisions that
-// arise among the set of live files. For efficient simulation, we make
-// some simplifying "pessimistic" assumptions (that only increase the
-// chance of the simulation reporting a collision relative to the chance
-// of collision in practice):
-// * Every generated file has a cache entry for every byte offset in the
-// file (contiguous range of cache keys)
-// * All of every file is cached for its entire lifetime. (Here "lifetime"
-// is technically the union of DB and Cache lifetime, though we only
-// model a generous DB lifetime, where space usage is always maximized.
-// In a effective Cache, lifetime in cache can only substantially exceed
-// lifetime in DB if there is little cache activity; cache activity is
-// required to hit cache key collisions.)
-//
-// It would be possible to track an exact set of cache key ranges for the
-// set of live files, but we would have no hope of observing collisions
-// (overlap in live files) in our simulation. We need to employ some way
-// of amplifying collision probability that allows us to predict the real
-// collision probability by extrapolation from observed collisions. Our
-// basic approach is to reduce each cache key range down to some smaller
-// number of bits, and limiting to bits that are shared over the whole
-// range.  Now we can observe collisions using a set of smaller stripped-down
-// (reduced) cache keys. Let's do some case analysis to understand why this
-// works:
-// * No collision in reduced key - because the reduction is a pure function
-// this implies no collision in the full keys
-// * Collision detected between two reduced keys - either
-//   * The reduction has dropped some structured uniqueness info (from one of
-// session counter or file number; file offsets are never materialized here).
-// This can only artificially inflate the observed and extrapolated collision
-// probabilities. We only have to worry about this in designing the reduction.
-//   * The reduction has preserved all the structured uniqueness in the cache
-// key, which means either
-//     * REJECTED: We have a uniqueness bug in generating cache keys, where
-// structured uniqueness info should have been different but isn't. In such a
-// case, increasing by 1 the number of bits kept after reduction would not
-// reduce observed probabilities by half. (In our observations, the
-// probabilities are reduced approximately by half.)
-//     * ACCEPTED: The lost unstructured uniqueness in the key determines the
-// probability that an observed collision would imply an overlap in ranges.
-// In short, dropping n bits from key would increase collision probability by
-// 2**n, assuming those n bits have full entropy in unstructured uniqueness.
-//
-// But we also have to account for the key ranges based on file size. If file
-// sizes are roughly 2**b offsets, using XOR in 128-bit cache keys for
-// "ranges", we know from other simulations (see
-// https://github.com/pdillinger/unique_id/) that that's roughly equivalent to
-// (less than 2x higher collision probability) using a cache key of size
-// 128 - b bits for the whole file. (This is the only place we make an
-// "optimistic" assumption, which is more than offset by the real
-// implementation stripping off 2 lower bits from block byte offsets for cache
-// keys. The simulation assumes byte offsets, which is net pessimistic.)
-//
-// So to accept the extrapolation as valid, we need to be confident that all
-// "lost" bits, excluding those covered by file offset, are full entropy.
-// Recall that we have assumed (verifiably, safely) that other structured data
-// (file number and session counter) are kept, not lost. Based on the
-// implementation comments for OffsetableCacheKey, the only potential hole here
-// is that we only have ~103 bits of entropy in "all new" session IDs, and in
-// extreme cases, there might be only 1 DB ID. However, because the upper ~39
-// bits of session ID are hashed, the combination of file number and file
-// offset only has to add to 25 bits (or more) to ensure full entropy in
-// unstructured uniqueness lost in the reduction. Typical file size of 32MB
-// suffices (at least for simulation purposes where we assume each file offset
-// occupies a cache key).
-//
-// Example results in comments on OffsetableCacheKey.
-class StressCacheKey {
- public:
-  void Run() {
-    if (FLAGS_sck_footer_unique_id) {
-      // Proposed footer unique IDs are DB-independent and session-independent
-      // (but process-dependent) which is most easily simulated here by
-      // assuming 1 DB and (later below) no session resets without process
-      // reset.
-      FLAGS_sck_db_count = 1;
-    }
-
-    // Describe the simulated workload
-    uint64_t mb_per_day =
-        uint64_t{FLAGS_sck_files_per_day} * FLAGS_sck_file_size_mb;
-    printf("Total cache or DBs size: %gTiB  Writing %g MiB/s or %gTiB/day\n",
-           FLAGS_sck_file_size_mb / 1024.0 / 1024.0 *
-               std::pow(2.0, FLAGS_sck_table_bits),
-           mb_per_day / 86400.0, mb_per_day / 1024.0 / 1024.0);
-    // For extrapolating probability of any collisions from a number of
-    // observed collisions
-    multiplier_ = std::pow(2.0, 128 - FLAGS_sck_keep_bits) /
-                  (FLAGS_sck_file_size_mb * 1024.0 * 1024.0);
-    printf(
-        "Multiply by %g to correct for simulation losses (but still assume "
-        "whole file cached)\n",
-        multiplier_);
-    restart_nfiles_ = FLAGS_sck_files_per_day / FLAGS_sck_restarts_per_day;
-    double without_ejection =
-        std::pow(1.414214, FLAGS_sck_keep_bits) / FLAGS_sck_files_per_day;
-    // This should be a lower bound for -sck_randomize, usually a terribly
-    // rough lower bound.
-    // If observation is worse than this, then something has gone wrong.
-    printf(
-        "Without ejection, expect random collision after %g days (%g "
-        "corrected)\n",
-        without_ejection, without_ejection * multiplier_);
-    double with_full_table =
-        std::pow(2.0, FLAGS_sck_keep_bits - FLAGS_sck_table_bits) /
-        FLAGS_sck_files_per_day;
-    // This is an alternate lower bound for -sck_randomize, usually pretty
-    // accurate. Our cache keys should usually perform "better than random"
-    // but always no worse. (If observation is substantially worse than this,
-    // then something has gone wrong.)
-    printf(
-        "With ejection and full table, expect random collision after %g "
-        "days (%g corrected)\n",
-        with_full_table, with_full_table * multiplier_);
-    collisions_ = 0;
-
-    // Run until sufficient number of observed collisions.
-    for (int i = 1; collisions_ < FLAGS_sck_min_collision; i++) {
-      RunOnce();
-      if (collisions_ == 0) {
-        printf(
-            "No collisions after %d x %u days                              "
-            "                   \n",
-            i, FLAGS_sck_days_per_run);
-      } else {
-        double est = 1.0 * i * FLAGS_sck_days_per_run / collisions_;
-        printf("%" PRIu64
-               " collisions after %d x %u days, est %g days between (%g "
-               "corrected)        \n",
-               collisions_, i, FLAGS_sck_days_per_run, est, est * multiplier_);
-      }
-    }
-  }
-
-  void RunOnce() {
-    // Re-initialized simulated state
-    const size_t db_count = std::max(size_t{FLAGS_sck_db_count}, size_t{1});
-    dbs_.reset(new TableProperties[db_count]{});
-    const size_t table_mask = (size_t{1} << FLAGS_sck_table_bits) - 1;
-    table_.reset(new uint64_t[table_mask + 1]{});
-    if (FLAGS_sck_keep_bits > 64) {
-      FLAGS_sck_keep_bits = 64;
-    }
-
-    // Details of which bits are dropped in reduction
-    uint32_t shift_away = 64 - FLAGS_sck_keep_bits;
-    // Shift away fewer potential file number bits (b) than potential
-    // session counter bits (a).
-    uint32_t shift_away_b = shift_away / 3;
-    uint32_t shift_away_a = shift_away - shift_away_b;
-
-    process_count_ = 0;
-    session_count_ = 0;
-    newdb_count_ = 0;
-    ResetProcess(/*newdbs*/ true);
-
-    Random64 r{std::random_device{}()};
-
-    uint64_t max_file_count =
-        uint64_t{FLAGS_sck_files_per_day} * FLAGS_sck_days_per_run;
-    uint32_t report_count = 0;
-    uint32_t collisions_this_run = 0;
-    size_t db_i = 0;
-
-    for (uint64_t file_count = 1; file_count <= max_file_count;
-         ++file_count, ++db_i) {
-      // Round-robin through DBs (this faster than %)
-      if (db_i >= db_count) {
-        db_i = 0;
-      }
-      // Any other periodic actions before simulating next file
-      if (!FLAGS_sck_footer_unique_id && r.OneIn(FLAGS_sck_reopen_nfiles)) {
-        ResetSession(db_i, /*newdb*/ r.OneIn(FLAGS_sck_newdb_nreopen));
-      } else if (r.OneIn(restart_nfiles_)) {
-        ResetProcess(/*newdbs*/ false);
-      }
-      // Simulate next file
-      OffsetableCacheKey ock;
-      dbs_[db_i].orig_file_number += 1;
-      // skip some file numbers for other file kinds, except in footer unique
-      // ID, orig_file_number here tracks process-wide generated SST file
-      // count.
-      if (!FLAGS_sck_footer_unique_id) {
-        dbs_[db_i].orig_file_number += (r.Next() & 3);
-      }
-      bool is_stable;
-      BlockBasedTable::SetupBaseCacheKey(&dbs_[db_i], /* ignored */ "",
-                                         /* ignored */ 42, &ock, &is_stable);
-      assert(is_stable);
-      // Get a representative cache key, which later we analytically generalize
-      // to a range.
-      CacheKey ck = ock.WithOffset(0);
-      uint64_t reduced_key;
-      if (FLAGS_sck_randomize) {
-        reduced_key = GetSliceHash64(ck.AsSlice()) >> shift_away;
-      } else if (FLAGS_sck_footer_unique_id) {
-        // Special case: keep only file number, not session counter
-        reduced_key = DecodeFixed64(ck.AsSlice().data()) >> shift_away;
-      } else {
-        // Try to keep file number and session counter (shift away other bits)
-        uint32_t a = DecodeFixed32(ck.AsSlice().data()) << shift_away_a;
-        uint32_t b = DecodeFixed32(ck.AsSlice().data() + 4) >> shift_away_b;
-        reduced_key = (uint64_t{a} << 32) + b;
-      }
-      if (reduced_key == 0) {
-        // Unlikely, but we need to exclude tracking this value because we
-        // use it to mean "empty" in table. This case is OK as long as we
-        // don't hit it often.
-        printf("Hit Zero!                                                  \n");
-        file_count--;
-        continue;
-      }
-      uint64_t h =
-          NPHash64(reinterpret_cast<char*>(&reduced_key), sizeof(reduced_key));
-      // Skew expected lifetimes, for high variance (super-Poisson) variance
-      // in actual lifetimes.
-      size_t pos =
-          std::min(Lower32of64(h) & table_mask, Upper32of64(h) & table_mask);
-      if (table_[pos] == reduced_key) {
-        collisions_this_run++;
-        // Our goal is to predict probability of no collisions, not expected
-        // number of collisions. To make the distinction, we have to get rid
-        // of observing correlated collisions, which this takes care of:
-        ResetProcess(/*newdbs*/ false);
-      } else {
-        // Replace (end of lifetime for file that was in this slot)
-        table_[pos] = reduced_key;
-      }
-
-      if (++report_count == FLAGS_sck_files_per_day) {
-        report_count = 0;
-        // Estimate fill %
-        size_t incr = table_mask / 1000;
-        size_t sampled_count = 0;
-        for (size_t i = 0; i <= table_mask; i += incr) {
-          if (table_[i] != 0) {
-            sampled_count++;
-          }
-        }
-        // Report
-        printf(
-            "%" PRIu64 " days, %" PRIu64 " proc, %" PRIu64 " sess, %" PRIu64
-            " newdb, %u coll, occ %g%%, ejected %g%%      \r",
-            file_count / FLAGS_sck_files_per_day, process_count_,
-            session_count_, newdb_count_ - FLAGS_sck_db_count,
-            collisions_this_run, 100.0 * sampled_count / 1000.0,
-            100.0 * (1.0 - sampled_count / 1000.0 * table_mask / file_count));
-        fflush(stdout);
-      }
-    }
-    collisions_ += collisions_this_run;
-  }
-
-  void ResetSession(size_t i, bool newdb) {
-    dbs_[i].db_session_id = DBImpl::GenerateDbSessionId(nullptr);
-    if (newdb) {
-      ++newdb_count_;
-      if (FLAGS_sck_footer_unique_id) {
-        // Simulate how footer id would behave
-        dbs_[i].db_id = "none";
-      } else {
-        // db_id might be ignored, depending on the implementation details
-        dbs_[i].db_id = std::to_string(newdb_count_);
-        dbs_[i].orig_file_number = 0;
-      }
-    }
-    session_count_++;
-  }
-
-  void ResetProcess(bool newdbs) {
-    process_count_++;
-    DBImpl::TEST_ResetDbSessionIdGen();
-    for (size_t i = 0; i < FLAGS_sck_db_count; ++i) {
-      ResetSession(i, newdbs);
-    }
-    if (FLAGS_sck_footer_unique_id) {
-      // For footer unique ID, this tracks process-wide generated SST file
-      // count.
-      dbs_[0].orig_file_number = 0;
-    }
-  }
-
- private:
-  // Use db_session_id and orig_file_number from TableProperties
-  std::unique_ptr<TableProperties[]> dbs_;
-  std::unique_ptr<uint64_t[]> table_;
-  uint64_t process_count_ = 0;
-  uint64_t session_count_ = 0;
-  uint64_t newdb_count_ = 0;
-  uint64_t collisions_ = 0;
-  uint32_t restart_nfiles_ = 0;
-  double multiplier_ = 0.0;
-};
-
 int cache_bench_tool(int argc, char** argv) {
   ParseCommandLineFlags(&argc, &argv, true);
 
-  if (FLAGS_stress_cache_key) {
-    // Alternate tool
-    StressCacheKey().Run();
-    return 0;
-  }
-
   if (FLAGS_threads <= 0) {
     fprintf(stderr, "threads number <= 0\n");
     exit(1);

cache/cache_entry_roles.cc

@@ -11,7 +11,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
+std::array<const char*, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
     "DataBlock",
     "FilterBlock",
     "FilterMetaBlock",
@@ -20,15 +20,10 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToCamelString{{
     "OtherBlock",
     "WriteBuffer",
     "CompressionDictionaryBuildingBuffer",
-    "FilterConstruction",
-    "BlockBasedTableReader",
-    "FileMetadata",
-    "BlobValue",
-    "BlobCache",
     "Misc",
 }};
 
-std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
+std::array<const char*, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
     "data-block",
     "filter-block",
     "filter-meta-block",
@@ -37,68 +32,37 @@ std::array<std::string, kNumCacheEntryRoles> kCacheEntryRoleToHyphenString{{
     "other-block",
     "write-buffer",
     "compression-dictionary-building-buffer",
-    "filter-construction",
-    "block-based-table-reader",
-    "file-metadata",
-    "blob-value",
-    "blob-cache",
     "misc",
 }};
 
-const std::string& GetCacheEntryRoleName(CacheEntryRole role) {
-  return kCacheEntryRoleToHyphenString[static_cast<size_t>(role)];
-}
-
-const std::string& BlockCacheEntryStatsMapKeys::CacheId() {
-  static const std::string kCacheId = "id";
-  return kCacheId;
-}
-
-const std::string& BlockCacheEntryStatsMapKeys::CacheCapacityBytes() {
-  static const std::string kCacheCapacityBytes = "capacity";
-  return kCacheCapacityBytes;
-}
-
-const std::string&
-BlockCacheEntryStatsMapKeys::LastCollectionDurationSeconds() {
-  static const std::string kLastCollectionDurationSeconds =
-      "secs_for_last_collection";
-  return kLastCollectionDurationSeconds;
-}
-
-const std::string& BlockCacheEntryStatsMapKeys::LastCollectionAgeSeconds() {
-  static const std::string kLastCollectionAgeSeconds =
-      "secs_since_last_collection";
-  return kLastCollectionAgeSeconds;
-}
-
 namespace {
 
-std::string GetPrefixedCacheEntryRoleName(const std::string& prefix,
-                                          CacheEntryRole role) {
-  const std::string& role_name = GetCacheEntryRoleName(role);
-  std::string prefixed_role_name;
-  prefixed_role_name.reserve(prefix.size() + role_name.size());
-  prefixed_role_name.append(prefix);
-  prefixed_role_name.append(role_name);
-  return prefixed_role_name;
+struct Registry {
+  std::mutex mutex;
+  std::unordered_map<Cache::DeleterFn, CacheEntryRole> role_map;
+  void Register(Cache::DeleterFn fn, CacheEntryRole role) {
+    std::lock_guard<std::mutex> lock(mutex);
+    role_map[fn] = role;
+  }
+  std::unordered_map<Cache::DeleterFn, CacheEntryRole> Copy() {
+    std::lock_guard<std::mutex> lock(mutex);
+    return role_map;
+  }
+};
+
+Registry& GetRegistry() {
+  STATIC_AVOID_DESTRUCTION(Registry, registry);
+  return registry;
 }
 
 }  // namespace
 
-std::string BlockCacheEntryStatsMapKeys::EntryCount(CacheEntryRole role) {
-  const static std::string kPrefix = "count.";
-  return GetPrefixedCacheEntryRoleName(kPrefix, role);
+void RegisterCacheDeleterRole(Cache::DeleterFn fn, CacheEntryRole role) {
+  GetRegistry().Register(fn, role);
 }
 
-std::string BlockCacheEntryStatsMapKeys::UsedBytes(CacheEntryRole role) {
-  const static std::string kPrefix = "bytes.";
-  return GetPrefixedCacheEntryRoleName(kPrefix, role);
-}
-
-std::string BlockCacheEntryStatsMapKeys::UsedPercent(CacheEntryRole role) {
-  const static std::string kPrefix = "percent.";
-  return GetPrefixedCacheEntryRoleName(kPrefix, role);
+std::unordered_map<Cache::DeleterFn, CacheEntryRole> CopyCacheDeleterRoleMap() {
+  return GetRegistry().Copy();
 }
 
 }  // namespace ROCKSDB_NAMESPACE

cache/cache_entry_roles.h

@@ -7,14 +7,121 @@
 
 #include <array>
 #include <cstdint>
+#include <unordered_map>
 
 #include "rocksdb/cache.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-extern std::array<std::string, kNumCacheEntryRoles>
+// Classifications of block cache entries, for reporting statistics
+// Adding new enum to this class requires corresponding updates to
+// kCacheEntryRoleToCamelString and kCacheEntryRoleToHyphenString
+enum class CacheEntryRole {
+  // Block-based table data block
+  kDataBlock,
+  // Block-based table filter block (full or partitioned)
+  kFilterBlock,
+  // Block-based table metadata block for partitioned filter
+  kFilterMetaBlock,
+  // Block-based table deprecated filter block (old "block-based" filter)
+  kDeprecatedFilterBlock,
+  // Block-based table index block
+  kIndexBlock,
+  // Other kinds of block-based table block
+  kOtherBlock,
+  // WriteBufferManager reservations to account for memtable usage
+  kWriteBuffer,
+  // BlockBasedTableBuilder reservations to account for
+  // compression dictionary building buffer's memory usage
+  kCompressionDictionaryBuildingBuffer,
+  // Default bucket, for miscellaneous cache entries. Do not use for
+  // entries that could potentially add up to large usage.
+  kMisc,
+};
+constexpr uint32_t kNumCacheEntryRoles =
+    static_cast<uint32_t>(CacheEntryRole::kMisc) + 1;
+
+extern std::array<const char*, kNumCacheEntryRoles>
     kCacheEntryRoleToCamelString;
-extern std::array<std::string, kNumCacheEntryRoles>
+extern std::array<const char*, 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).
+std::unordered_map<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) {
+    delete static_cast<T*>(value);
+  }
+};
+
+template <CacheEntryRole R>
+struct RegisteredNoopDeleter {
+  RegisteredNoopDeleter() { RegisterCacheDeleterRole(Delete, R); }
+
+  static void Delete(const Slice& /* key */, void* value) {
+    (void)value;
+    assert(value == nullptr);
+  }
+};
+
+}  // 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

cache/cache_entry_stats.h

@@ -10,8 +10,7 @@
 #include <memory>
 #include <mutex>
 
-#include "cache/cache_key.h"
-#include "cache/typed_cache.h"
+#include "cache/cache_helpers.h"
 #include "port/lang.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/status.h"
@@ -111,14 +110,17 @@ 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 *raw_cache, SystemClock *clock,
+  static Status GetShared(Cache *cache, SystemClock *clock,
                           std::shared_ptr<CacheEntryStatsCollector> *ptr) {
-    assert(raw_cache);
-    BasicTypedCacheInterface<CacheEntryStatsCollector, CacheEntryRole::kMisc>
-        cache{raw_cache};
+    std::array<uint64_t, 3> cache_key_data{
+        {// First 16 bytes == md5 of class name
+         0x7eba5a8fb5437c90U, 0x8ca68c9b11655855U,
+         // Last 8 bytes based on a function pointer to make unique for each
+         // template instantiation
+         reinterpret_cast<uint64_t>(&CacheEntryStatsCollector::GetShared)}};
+    Slice cache_key = GetSlice(&cache_key_data);
 
-    const Slice &cache_key = GetCacheKey();
-    auto h = cache.Lookup(cache_key);
+    Cache::Handle *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,
@@ -126,15 +128,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.get(), clock);
+        auto new_ptr = new CacheEntryStatsCollector(cache, 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, &h, Cache::Priority::HIGH);
+        Status s = cache->Insert(cache_key, new_ptr, charge, Deleter, &h,
+                                 Cache::Priority::HIGH);
         if (!s.ok()) {
           assert(h == nullptr);
           delete new_ptr;
@@ -143,11 +145,11 @@ class CacheEntryStatsCollector {
       }
     }
     // If we reach here, shared entry is in cache with handle `h`.
-    assert(cache.get()->GetCacheItemHelper(h) == &cache.kBasicHelper);
+    assert(cache->GetDeleter(h) == Deleter);
 
     // Build an aliasing shared_ptr that keeps `ptr` in cache while there
     // are references.
-    *ptr = cache.SharedGuard(h);
+    *ptr = MakeSharedCacheHandleGuard<CacheEntryStatsCollector>(cache, h);
     return Status::OK();
   }
 
@@ -160,11 +162,8 @@ class CacheEntryStatsCollector {
         cache_(cache),
         clock_(clock) {}
 
-  static const Slice &GetCacheKey() {
-    // For each template instantiation
-    static CacheKey ckey = CacheKey::CreateUniqueForProcessLifetime();
-    static Slice ckey_slice = ckey.AsSlice();
-    return ckey_slice;
+  static void Deleter(const Slice &, void *value) {
+    delete static_cast<CacheEntryStatsCollector *>(value);
   }
 
   std::mutex saved_mutex_;

cache/cache_helpers.cc

@@ -1,40 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "cache/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

cache/cache_helpers.h

@@ -17,17 +17,22 @@ 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 GetSliceForKey(const T* t) {
+Slice GetSlice(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.
@@ -79,16 +84,6 @@ class CacheHandleGuard {
   Cache::Handle* GetCacheHandle() const { return handle_; }
   T* GetValue() const { return value_; }
 
-  void TransferTo(Cleanable* cleanable) {
-    if (cleanable) {
-      if (handle_ != nullptr) {
-        assert(cache_);
-        cleanable->RegisterCleanup(&ReleaseCacheHandleCleanup, cache_, handle_);
-      }
-    }
-    ResetFields();
-  }
-
   void Reset() {
     ReleaseHandle();
     ResetFields();
@@ -124,16 +119,7 @@ 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, GetFromCacheHandle<T>(cache, handle));
+  return std::shared_ptr<T>(wrapper, static_cast<T*>(cache->Value(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

cache/cache_key.cc

@@ -1,364 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. 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 "cache/cache_key.h"
-
-#include <algorithm>
-#include <atomic>
-
-#include "rocksdb/cache.h"
-#include "table/unique_id_impl.h"
-#include "util/hash.h"
-#include "util/math.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Value space plan for CacheKey:
-//
-// file_num_etc64_ | offset_etc64_ | Only generated by
-// ---------------+---------------+------------------------------------------
-//              0 |             0 | Reserved for "empty" CacheKey()
-//              0 |  > 0, < 1<<63 | CreateUniqueForCacheLifetime
-//              0 |      >= 1<<63 | CreateUniqueForProcessLifetime
-//            > 0 |           any | OffsetableCacheKey.WithOffset
-
-CacheKey CacheKey::CreateUniqueForCacheLifetime(Cache *cache) {
-  // +1 so that we can reserve all zeros for "unset" cache key
-  uint64_t id = cache->NewId() + 1;
-  // Ensure we don't collide with CreateUniqueForProcessLifetime
-  assert((id >> 63) == 0U);
-  return CacheKey(0, id);
-}
-
-CacheKey CacheKey::CreateUniqueForProcessLifetime() {
-  // To avoid colliding with CreateUniqueForCacheLifetime, assuming
-  // Cache::NewId counts up from zero, here we count down from UINT64_MAX.
-  // If this ever becomes a point of contention, we could sub-divide the
-  // space and use CoreLocalArray.
-  static std::atomic<uint64_t> counter{UINT64_MAX};
-  uint64_t id = counter.fetch_sub(1, std::memory_order_relaxed);
-  // Ensure we don't collide with CreateUniqueForCacheLifetime
-  assert((id >> 63) == 1U);
-  return CacheKey(0, id);
-}
-
-// How we generate CacheKeys and base OffsetableCacheKey, assuming that
-// db_session_ids are generated from a base_session_id and
-// session_id_counter (by SemiStructuredUniqueIdGen+EncodeSessionId
-// in DBImpl::GenerateDbSessionId):
-//
-// Conceptual inputs:
-//   db_id                   (unstructured, from GenerateRawUniqueId or equiv)
-//                           * could be shared between cloned DBs but rare
-//                           * could be constant, if session id suffices
-//   base_session_id         (unstructured, from GenerateRawUniqueId)
-//   session_id_counter      (structured)
-//                           * usually much smaller than 2**24
-//   orig_file_number        (structured)
-//                           * usually smaller than 2**24
-//   offset_in_file          (structured, might skip lots of values)
-//                           * usually smaller than 2**32
-//
-// Overall approach (see https://github.com/pdillinger/unique_id for
-// background):
-//
-// First, we have three "structured" values, up to 64 bits each, that we
-// need to fit, without losses, into 128 bits. In practice, the values will
-// be small enough that they should fit. For example, applications generating
-// large SST files (large offsets) will naturally produce fewer files (small
-// file numbers). But we don't know ahead of time what bounds the values will
-// have.
-//
-// Second, we have unstructured inputs that enable distinct RocksDB processes
-// to pick a random point in space, likely very different from others. Xoring
-// the structured with the unstructured give us a cache key that is
-// structurally distinct between related keys (e.g. same file or same RocksDB
-// process) and distinct with high probability between unrelated keys.
-//
-// The problem of packing three structured values into the space for two is
-// complicated by the fact that we want to derive cache keys from SST unique
-// IDs, which have already combined structured and unstructured inputs in a
-// practically inseparable way. And we want a base cache key that works
-// with an offset of any size. So basically, we need to encode these three
-// structured values, each up to 64 bits, into 128 bits without knowing any
-// of their sizes. The DownwardInvolution() function gives us a mechanism to
-// accomplish this. (See its properties in math.h.) Specifically, for inputs
-// a, b, and c:
-//   lower64 = DownwardInvolution(a) ^ ReverseBits(b);
-//   upper64 = c ^ ReverseBits(a);
-// The 128-bit output is unique assuming there exist some i, j, and k
-// where a < 2**i, b < 2**j, c < 2**k, i <= 64, j <= 64, k <= 64, and
-// i + j + k <= 128. In other words, as long as there exist some bounds
-// that would allow us to pack the bits of a, b, and c into the output
-// if we know the bound, we can generate unique outputs without knowing
-// those bounds. To validate this claim, the inversion function (given
-// the bounds) has been implemented in CacheKeyDecoder in
-// db_block_cache_test.cc.
-//
-// With that in mind, the outputs in terms of the conceptual inputs look
-// like this, using bitwise-xor of the constituent pieces, low bits on left:
-//
-// |------------------------- file_num_etc64 -------------------------|
-// | +++++++++ base_session_id (lower 64 bits, involution) +++++++++ |
-// |-----------------------------------------------------------------|
-// | session_id_counter (involution) ..... |                         |
-// |-----------------------------------------------------------------|
-// | hash of: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
-// |  * base_session_id (upper ~39 bits)                             |
-// |  * db_id (~122 bits entropy)                                    |
-// |-----------------------------------------------------------------|
-// |                             | ..... orig_file_number (reversed) |
-// |-----------------------------------------------------------------|
-//
-//
-// |------------------------- offset_etc64 --------------------------|
-// | ++++++++++ base_session_id (lower 64 bits, reversed) ++++++++++ |
-// |-----------------------------------------------------------------|
-// |                           | ..... session_id_counter (reversed) |
-// |-----------------------------------------------------------------|
-// | offset_in_file ............... |                                |
-// |-----------------------------------------------------------------|
-//
-// Some oddities or inconveniences of this layout are due to deriving
-// the "base" cache key (without offset) from the SST unique ID (see
-// GetSstInternalUniqueId). Specifically,
-// * Lower 64 of base_session_id occurs in both output words (ok but
-//   weird)
-// * The inclusion of db_id is bad for the conditions under which we
-//   can guarantee uniqueness, but could be useful in some cases with
-//   few small files per process, to make up for db session id only having
-//   ~103 bits of entropy.
-//
-// In fact, if DB ids were not involved, we would be guaranteed unique
-// cache keys for files generated in a single process until total bits for
-// biggest session_id_counter, orig_file_number, and offset_in_file
-// reach 128 bits.
-//
-// With the DB id limitation, we only have nice guaranteed unique cache
-// keys for files generated in a single process until biggest
-// session_id_counter and offset_in_file reach combined 64 bits. This
-// is quite good in practice because we can have millions of DB Opens
-// with terabyte size SST files, or billions of DB Opens with gigabyte
-// size SST files.
-//
-// One of the considerations in the translation between existing SST unique
-// IDs and base cache keys is supporting better SST unique IDs in a future
-// format_version. If we use a process-wide file counter instead of
-// session counter and file numbers, we only need to combine two 64-bit values
-// instead of three. But we don't want to track unique ID versions in the
-// manifest, so we want to keep the same translation layer between SST unique
-// IDs and base cache keys, even with updated SST unique IDs. If the new
-// unique IDs put the file counter where the orig_file_number was, and
-// use no structured field where session_id_counter was, then our translation
-// layer works fine for two structured fields as well as three (for
-// compatibility). The small computation for the translation (one
-// DownwardInvolution(), two ReverseBits(), both ~log(64) instructions deep)
-// is negligible for computing as part of SST file reader open.
-//
-// More on how https://github.com/pdillinger/unique_id applies here:
-// Every bit of output always includes "unstructured" uniqueness bits and
-// often combines with "structured" uniqueness bits. The "unstructured" bits
-// change infrequently: only when we cannot guarantee our state tracking for
-// "structured" uniqueness hasn't been cloned. Using a static
-// SemiStructuredUniqueIdGen for db_session_ids, this means we only get an
-// "all new" session id when a new process uses RocksDB. (Between processes,
-// we don't know if a DB or other persistent storage has been cloned. We
-// assume that if VM hot cloning is used, subsequently generated SST files
-// do not interact.) Within a process, only the session_lower of the
-// db_session_id changes incrementally ("structured" uniqueness).
-//
-// This basically means that our offsets, counters and file numbers allow us
-// to do somewhat "better than random" (birthday paradox) while in the
-// degenerate case of completely new session for each tiny file, we still
-// have strong uniqueness properties from the birthday paradox, with ~103
-// bit session IDs or up to 128 bits entropy with different DB IDs sharing a
-// cache.
-//
-// More collision probability analysis:
-// Suppose a RocksDB host generates (generously) 2 GB/s (10TB data, 17 DWPD)
-// with average process/session lifetime of (pessimistically) 4 minutes.
-// In 180 days (generous allowable data lifespan), we generate 31 million GB
-// of data, or 2^55 bytes, and 2^16 "all new" session IDs.
-//
-// First, suppose this is in a single DB (lifetime 180 days):
-// 128 bits cache key size
-// - 55 <- ideal size for byte offsets + file numbers
-// -  2 <- bits for offsets and file numbers not exactly powers of two
-// +  2 <- bits saved not using byte offsets in BlockBasedTable::GetCacheKey
-// ----
-//   73 <- bits remaining for distinguishing session IDs
-// The probability of a collision in 73 bits of session ID data is less than
-// 1 in 2**(73 - (2 * 16)), or roughly 1 in a trillion. And this assumes all
-// data from the last 180 days is in cache for potential collision, and that
-// cache keys under each session id exhaustively cover the remaining 57 bits
-// while in reality they'll only cover a small fraction of it.
-//
-// Although data could be transferred between hosts, each host has its own
-// cache and we are already assuming a high rate of "all new" session ids.
-// So this doesn't really change the collision calculation. Across a fleet
-// of 1 million, each with <1 in a trillion collision possibility,
-// fleetwide collision probability is <1 in a million.
-//
-// Now suppose we have many DBs per host, say 2**10, with same host-wide write
-// rate and process/session lifetime. File numbers will be ~10 bits smaller
-// and we will have 2**10 times as many session IDs because of simultaneous
-// lifetimes. So now collision chance is less than 1 in 2**(83 - (2 * 26)),
-// or roughly 1 in a billion.
-//
-// Suppose instead we generated random or hashed cache keys for each
-// (compressed) block. For 1KB compressed block size, that is 2^45 cache keys
-// in 180 days. Collision probability is more easily estimated at roughly
-// 1 in 2**(128 - (2 * 45)) or roughly 1 in a trillion (assuming all
-// data from the last 180 days is in cache, but NOT the other assumption
-// for the 1 in a trillion estimate above).
-//
-//
-// Collision probability estimation through simulation:
-// A tool ./cache_bench -stress_cache_key broadly simulates host-wide cache
-// activity over many months, by making some pessimistic simplifying
-// assumptions. See class StressCacheKey in cache_bench_tool.cc for details.
-// Here is some sample output with
-// `./cache_bench -stress_cache_key -sck_keep_bits=43`:
-//
-//   Total cache or DBs size: 32TiB  Writing 925.926 MiB/s or 76.2939TiB/day
-//   Multiply by 1.15292e+18 to correct for simulation losses (but still
-//   assume whole file cached)
-//
-// These come from default settings of 2.5M files per day of 32 MB each, and
-// `-sck_keep_bits=43` means that to represent a single file, we are only
-// keeping 43 bits of the 128-bit (base) cache key.  With file size of 2**25
-// contiguous keys (pessimistic), our simulation is about 2\*\*(128-43-25) or
-// about 1 billion billion times more prone to collision than reality.
-//
-// More default assumptions, relatively pessimistic:
-// * 100 DBs in same process (doesn't matter much)
-// * Re-open DB in same process (new session ID related to old session ID) on
-// average every 100 files generated
-// * Restart process (all new session IDs unrelated to old) 24 times per day
-//
-// After enough data, we get a result at the end (-sck_keep_bits=43):
-//
-//   (keep 43 bits)  18 collisions after 2 x 90 days, est 10 days between
-//                   (1.15292e+19 corrected)
-//
-// If we believe the (pessimistic) simulation and the mathematical
-// extrapolation, we would need to run a billion machines all for 11 billion
-// days to expect a cache key collision. To help verify that our extrapolation
-// ("corrected") is robust, we can make our simulation more precise by
-// increasing the "keep" bits, which takes more running time to get enough
-// collision data:
-//
-//   (keep 44 bits)  16 collisions after 5 x 90 days, est 28.125 days between
-//                   (1.6213e+19 corrected)
-//   (keep 45 bits)  15 collisions after 7 x 90 days, est 42 days between
-//                   (1.21057e+19 corrected)
-//   (keep 46 bits)  15 collisions after 17 x 90 days, est 102 days between
-//                   (1.46997e+19 corrected)
-//   (keep 47 bits)  15 collisions after 49 x 90 days, est 294 days between
-//                   (2.11849e+19 corrected)
-//
-// The extrapolated prediction seems to be within noise (sampling error).
-//
-// With the `-sck_randomize` option, we can see that typical workloads like
-// above have lower collision probability than "random" cache keys (note:
-// offsets still non-randomized) by a modest amount (roughly 2-3x less
-// collision prone than random), which should make us reasonably comfortable
-// even in "degenerate" cases (e.g. repeatedly launch a process to generate
-// one file with SstFileWriter):
-//
-//   (rand 43 bits) 22 collisions after 1 x 90 days, est 4.09091 days between
-//                  (4.7165e+18 corrected)
-//
-// We can see that with more frequent process restarts,
-// -sck_restarts_per_day=5000, which means more all-new session IDs, we get
-// closer to the "random" cache key performance:
-//
-// 15 collisions after 1 x 90 days, est 6 days between (6.91753e+18 corrected)
-//
-// And with less frequent process restarts and re-opens,
-// -sck_restarts_per_day=1 -sck_reopen_nfiles=1000, we get lower collision
-// probability:
-//
-// 18 collisions after 8 x 90 days, est 40 days between (4.61169e+19 corrected)
-//
-// Other tests have been run to validate other conditions behave as expected,
-// never behaving "worse than random" unless we start chopping off structured
-// data.
-//
-// Conclusion: Even in extreme cases, rapidly burning through "all new" IDs
-// that only arise when a new process is started, the chance of any cache key
-// collisions in a giant fleet of machines is negligible. Especially when
-// processes live for hours or days, the chance of a cache key collision is
-// likely more plausibly due to bad hardware than to bad luck in random
-// session ID data. Software defects are surely more likely to cause corruption
-// than both of those.
-//
-// TODO: Nevertheless / regardless, an efficient way to detect (and thus
-// quantify) block cache corruptions, including collisions, should be added.
-OffsetableCacheKey::OffsetableCacheKey(const std::string &db_id,
-                                       const std::string &db_session_id,
-                                       uint64_t file_number) {
-  UniqueId64x2 internal_id;
-  Status s = GetSstInternalUniqueId(db_id, db_session_id, file_number,
-                                    &internal_id, /*force=*/true);
-  assert(s.ok());
-  *this = FromInternalUniqueId(&internal_id);
-}
-
-OffsetableCacheKey OffsetableCacheKey::FromInternalUniqueId(UniqueIdPtr id) {
-  uint64_t session_lower = id.ptr[0];
-  uint64_t file_num_etc = id.ptr[1];
-
-#ifndef NDEBUG
-  bool is_empty = session_lower == 0 && file_num_etc == 0;
-#endif
-
-  // Although DBImpl guarantees (in recent versions) that session_lower is not
-  // zero, that's not entirely sufficient to guarantee that file_num_etc64_ is
-  // not zero (so that the 0 case can be used by CacheKey::CreateUnique*)
-  // However, if we are given an "empty" id as input, then we should produce
-  // "empty" as output.
-  // As a consequence, this function is only bijective assuming
-  // id[0] == 0 only if id[1] == 0.
-  if (session_lower == 0U) {
-    session_lower = file_num_etc;
-  }
-
-  // See comments above for how DownwardInvolution and ReverseBits
-  // make this function invertible under various assumptions.
-  OffsetableCacheKey rv;
-  rv.file_num_etc64_ =
-      DownwardInvolution(session_lower) ^ ReverseBits(file_num_etc);
-  rv.offset_etc64_ = ReverseBits(session_lower);
-
-  // Because of these transformations and needing to allow arbitrary
-  // offset (thus, second 64 bits of cache key might be 0), we need to
-  // make some correction to ensure the first 64 bits is not 0.
-  // Fortunately, the transformation ensures the second 64 bits is not 0
-  // for non-empty base key, so we can swap in the case one is 0 without
-  // breaking bijectivity (assuming condition above).
-  assert(is_empty || rv.offset_etc64_ > 0);
-  if (rv.file_num_etc64_ == 0) {
-    std::swap(rv.file_num_etc64_, rv.offset_etc64_);
-  }
-  assert(is_empty || rv.file_num_etc64_ > 0);
-  return rv;
-}
-
-// Inverse of FromInternalUniqueId (assuming file_num_etc64 == 0 only if
-// offset_etc64 == 0)
-UniqueId64x2 OffsetableCacheKey::ToInternalUniqueId() {
-  uint64_t a = file_num_etc64_;
-  uint64_t b = offset_etc64_;
-  if (b == 0) {
-    std::swap(a, b);
-  }
-  UniqueId64x2 rv;
-  rv[0] = ReverseBits(b);
-  rv[1] = ReverseBits(a ^ DownwardInvolution(rv[0]));
-  return rv;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/cache_key.h

@@ -1,143 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <cstdint>
-
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/slice.h"
-#include "table/unique_id_impl.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Cache;
-
-// A standard holder for fixed-size block cache keys (and for related caches).
-// They are created through one of these, each using its own range of values:
-// * CacheKey::CreateUniqueForCacheLifetime
-// * CacheKey::CreateUniqueForProcessLifetime
-// * Default ctor ("empty" cache key)
-// * OffsetableCacheKey->WithOffset
-//
-// The first two use atomic counters to guarantee uniqueness over the given
-// lifetime and the last uses a form of universally unique identifier for
-// uniqueness with very high probabilty (and guaranteed for files generated
-// during a single process lifetime).
-//
-// CacheKeys are currently used by calling AsSlice() to pass as a key to
-// Cache. For performance, the keys are endianness-dependent (though otherwise
-// portable). (Persistable cache entries are not intended to cross platforms.)
-class CacheKey {
- public:
-  // For convenience, constructs an "empty" cache key that is never returned
-  // by other means.
-  inline CacheKey() : file_num_etc64_(), offset_etc64_() {}
-
-  inline bool IsEmpty() const {
-    return (file_num_etc64_ == 0) & (offset_etc64_ == 0);
-  }
-
-  // Use this cache key as a Slice (byte order is endianness-dependent)
-  inline Slice AsSlice() const {
-    static_assert(sizeof(*this) == 16, "Standardized on 16-byte cache key");
-    assert(!IsEmpty());
-    return Slice(reinterpret_cast<const char *>(this), sizeof(*this));
-  }
-
-  // Create a CacheKey that is unique among others associated with this Cache
-  // instance. Depends on Cache::NewId. This is useful for block cache
-  // "reservations".
-  static CacheKey CreateUniqueForCacheLifetime(Cache *cache);
-
-  // Create a CacheKey that is unique among others for the lifetime of this
-  // process. This is useful for saving in a static data member so that
-  // different DB instances can agree on a cache key for shared entities,
-  // such as for CacheEntryStatsCollector.
-  static CacheKey CreateUniqueForProcessLifetime();
-
- protected:
-  friend class OffsetableCacheKey;
-  CacheKey(uint64_t file_num_etc64, uint64_t offset_etc64)
-      : file_num_etc64_(file_num_etc64), offset_etc64_(offset_etc64) {}
-  uint64_t file_num_etc64_;
-  uint64_t offset_etc64_;
-};
-
-constexpr uint8_t kCacheKeySize = static_cast<uint8_t>(sizeof(CacheKey));
-
-// A file-specific generator of cache keys, sometimes referred to as the
-// "base" cache key for a file because all the cache keys for various offsets
-// within the file are computed using simple arithmetic. The basis for the
-// general approach is dicussed here: https://github.com/pdillinger/unique_id
-// Heavily related to GetUniqueIdFromTableProperties.
-//
-// If the db_id, db_session_id, and file_number come from the file's table
-// properties, then the keys will be stable across DB::Open/Close, backup/
-// restore, import/export, etc.
-//
-// This class "is a" CacheKey only privately so that it is not misused as
-// a ready-to-use CacheKey.
-class OffsetableCacheKey : private CacheKey {
- public:
-  // For convenience, constructs an "empty" cache key that should not be used.
-  inline OffsetableCacheKey() : CacheKey() {}
-
-  // Constructs an OffsetableCacheKey with the given information about a file.
-  // This constructor never generates an "empty" base key.
-  OffsetableCacheKey(const std::string &db_id, const std::string &db_session_id,
-                     uint64_t file_number);
-
-  // Creates an OffsetableCacheKey from an SST unique ID, so that cache keys
-  // can be derived from DB manifest data before reading the file from
-  // storage--so that every part of the file can potentially go in a persistent
-  // cache.
-  //
-  // Calling GetSstInternalUniqueId() on a db_id, db_session_id, and
-  // file_number and passing the result to this function produces the same
-  // base cache key as feeding those inputs directly to the constructor.
-  //
-  // This is a bijective transformation assuming either id is empty or
-  // lower 64 bits is non-zero:
-  // * Empty (all zeros) input -> empty (all zeros) output
-  // * Lower 64 input is non-zero -> lower 64 output (file_num_etc64_) is
-  //   non-zero
-  static OffsetableCacheKey FromInternalUniqueId(UniqueIdPtr id);
-
-  // This is the inverse transformation to the above, assuming either empty
-  // or lower 64 bits (file_num_etc64_) is non-zero. Perhaps only useful for
-  // testing.
-  UniqueId64x2 ToInternalUniqueId();
-
-  inline bool IsEmpty() const {
-    bool result = file_num_etc64_ == 0;
-    assert(!(offset_etc64_ > 0 && result));
-    return result;
-  }
-
-  // Construct a CacheKey for an offset within a file. An offset is not
-  // necessarily a byte offset if a smaller unique identifier of keyable
-  // offsets is used.
-  //
-  // This class was designed to make this hot code extremely fast.
-  inline CacheKey WithOffset(uint64_t offset) const {
-    assert(!IsEmpty());
-    return CacheKey(file_num_etc64_, offset_etc64_ ^ offset);
-  }
-
-  // The "common prefix" is a shared prefix for all the returned CacheKeys.
-  // It is specific to the file but the same for all offsets within the file.
-  static constexpr size_t kCommonPrefixSize = 8;
-  inline Slice CommonPrefixSlice() const {
-    static_assert(sizeof(file_num_etc64_) == kCommonPrefixSize,
-                  "8 byte common prefix expected");
-    assert(!IsEmpty());
-    assert(&this->file_num_etc64_ == static_cast<const void *>(this));
-
-    return Slice(reinterpret_cast<const char *>(this), kCommonPrefixSize);
-  }
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager.cc

@@ -13,57 +13,38 @@
 #include <cstring>
 #include <memory>
 
+#include "cache/cache_entry_roles.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
-#include "table/block_based/reader_common.h"
+#include "table/block_based/block_based_table_reader.h"
 #include "util/coding.h"
 
 namespace ROCKSDB_NAMESPACE {
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::CacheReservationHandle::CacheReservationHandle(
-    std::size_t incremental_memory_used,
-    std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr)
-    : incremental_memory_used_(incremental_memory_used) {
-  assert(cache_res_mgr);
-  cache_res_mgr_ = cache_res_mgr;
-}
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<
-    R>::CacheReservationHandle::~CacheReservationHandle() {
-  Status s = cache_res_mgr_->ReleaseCacheReservation(incremental_memory_used_);
-  s.PermitUncheckedError();
-}
-
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::CacheReservationManagerImpl(
-    std::shared_ptr<Cache> cache, bool delayed_decrease)
-    : cache_(cache),
-      delayed_decrease_(delayed_decrease),
-      cache_allocated_size_(0),
-      memory_used_(0) {
+CacheReservationManager::CacheReservationManager(std::shared_ptr<Cache> cache,
+                                                 bool delayed_decrease)
+    : delayed_decrease_(delayed_decrease), cache_allocated_size_(0) {
   assert(cache != nullptr);
+  cache_ = cache;
+  std::memset(cache_key_, 0, kCacheKeyPrefixSize + kMaxVarint64Length);
+  EncodeVarint64(cache_key_, cache_->NewId());
 }
 
-template <CacheEntryRole R>
-CacheReservationManagerImpl<R>::~CacheReservationManagerImpl() {
+CacheReservationManager::~CacheReservationManager() {
   for (auto* handle : dummy_handles_) {
-    cache_.ReleaseAndEraseIfLastRef(handle);
+    cache_->Release(handle, true);
   }
 }
 
 template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::UpdateCacheReservation(
+Status CacheReservationManager::UpdateCacheReservation(
     std::size_t new_mem_used) {
-  memory_used_ = new_mem_used;
   std::size_t cur_cache_allocated_size =
       cache_allocated_size_.load(std::memory_order_relaxed);
   if (new_mem_used == cur_cache_allocated_size) {
     return Status::OK();
   } else if (new_mem_used > cur_cache_allocated_size) {
-    Status s = IncreaseCacheReservation(new_mem_used);
+    Status s = IncreaseCacheReservation<R>(new_mem_used);
     return s;
   } else {
     // In delayed decrease mode, we don't decrease cache reservation
@@ -84,37 +65,25 @@ Status CacheReservationManagerImpl<R>::UpdateCacheReservation(
   }
 }
 
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::MakeCacheReservation(
-    std::size_t incremental_memory_used,
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>* handle) {
-  assert(handle);
-  Status s =
-      UpdateCacheReservation(GetTotalMemoryUsed() + incremental_memory_used);
-  (*handle).reset(new CacheReservationManagerImpl::CacheReservationHandle(
-      incremental_memory_used,
-      std::enable_shared_from_this<
-          CacheReservationManagerImpl<R>>::shared_from_this()));
-  return s;
-}
+// Explicitly instantiate templates for "CacheEntryRole" values we use.
+// This makes it possible to keep the template definitions in the .cc file.
+template Status CacheReservationManager::UpdateCacheReservation<
+    CacheEntryRole::kWriteBuffer>(std::size_t new_mem_used);
+template Status CacheReservationManager::UpdateCacheReservation<
+    CacheEntryRole::kCompressionDictionaryBuildingBuffer>(
+    std::size_t new_mem_used);
+// For cache reservation manager unit tests
+template Status CacheReservationManager::UpdateCacheReservation<
+    CacheEntryRole::kMisc>(std::size_t new_mem_used);
 
 template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::ReleaseCacheReservation(
-    std::size_t incremental_memory_used) {
-  assert(GetTotalMemoryUsed() >= incremental_memory_used);
-  std::size_t updated_total_mem_used =
-      GetTotalMemoryUsed() - incremental_memory_used;
-  Status s = UpdateCacheReservation(updated_total_mem_used);
-  return s;
-}
-
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::IncreaseCacheReservation(
+Status CacheReservationManager::IncreaseCacheReservation(
     std::size_t new_mem_used) {
   Status return_status = Status::OK();
   while (new_mem_used > cache_allocated_size_.load(std::memory_order_relaxed)) {
     Cache::Handle* handle = nullptr;
-    return_status = cache_.Insert(GetNextCacheKey(), kSizeDummyEntry, &handle);
+    return_status = cache_->Insert(GetNextCacheKey(), nullptr, kSizeDummyEntry,
+                                   GetNoopDeleterForRole<R>(), &handle);
 
     if (return_status != Status::OK()) {
       return return_status;
@@ -126,8 +95,7 @@ Status CacheReservationManagerImpl<R>::IncreaseCacheReservation(
   return return_status;
 }
 
-template <CacheEntryRole R>
-Status CacheReservationManagerImpl<R>::DecreaseCacheReservation(
+Status CacheReservationManager::DecreaseCacheReservation(
     std::size_t new_mem_used) {
   Status return_status = Status::OK();
 
@@ -139,46 +107,25 @@ Status CacheReservationManagerImpl<R>::DecreaseCacheReservation(
          cache_allocated_size_.load(std::memory_order_relaxed)) {
     assert(!dummy_handles_.empty());
     auto* handle = dummy_handles_.back();
-    cache_.ReleaseAndEraseIfLastRef(handle);
+    cache_->Release(handle, true);
     dummy_handles_.pop_back();
     cache_allocated_size_ -= kSizeDummyEntry;
   }
   return return_status;
 }
 
-template <CacheEntryRole R>
-std::size_t CacheReservationManagerImpl<R>::GetTotalReservedCacheSize() {
+std::size_t CacheReservationManager::GetTotalReservedCacheSize() {
   return cache_allocated_size_.load(std::memory_order_relaxed);
 }
 
-template <CacheEntryRole R>
-std::size_t CacheReservationManagerImpl<R>::GetTotalMemoryUsed() {
-  return memory_used_;
-}
-
-template <CacheEntryRole R>
-Slice CacheReservationManagerImpl<R>::GetNextCacheKey() {
+Slice CacheReservationManager::GetNextCacheKey() {
   // Calling this function will have the side-effect of changing the
   // underlying cache_key_ that is shared among other keys generated from this
   // fucntion. Therefore please make sure the previous keys are saved/copied
   // before calling this function.
-  cache_key_ = CacheKey::CreateUniqueForCacheLifetime(cache_.get());
-  return cache_key_.AsSlice();
+  std::memset(cache_key_ + kCacheKeyPrefixSize, 0, kMaxVarint64Length);
+  char* end =
+      EncodeVarint64(cache_key_ + kCacheKeyPrefixSize, next_cache_key_id_++);
+  return Slice(cache_key_, static_cast<std::size_t>(end - cache_key_));
 }
-
-template <CacheEntryRole R>
-const Cache::CacheItemHelper*
-CacheReservationManagerImpl<R>::TEST_GetCacheItemHelperForRole() {
-  return &CacheInterface::kHelper;
-}
-
-template class CacheReservationManagerImpl<
-    CacheEntryRole::kBlockBasedTableReader>;
-template class CacheReservationManagerImpl<
-    CacheEntryRole::kCompressionDictionaryBuildingBuffer>;
-template class CacheReservationManagerImpl<CacheEntryRole::kFilterConstruction>;
-template class CacheReservationManagerImpl<CacheEntryRole::kMisc>;
-template class CacheReservationManagerImpl<CacheEntryRole::kWriteBuffer>;
-template class CacheReservationManagerImpl<CacheEntryRole::kFileMetadata>;
-template class CacheReservationManagerImpl<CacheEntryRole::kBlobCache>;
-}  // namespace ROCKSDB_NAMESPACE
+}  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager.h

@@ -13,100 +13,48 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
-#include <mutex>
 #include <vector>
 
 #include "cache/cache_entry_roles.h"
-#include "cache/cache_key.h"
-#include "cache/typed_cache.h"
+#include "rocksdb/cache.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
+#include "table/block_based/block_based_table_reader.h"
 #include "util/coding.h"
 
 namespace ROCKSDB_NAMESPACE {
-// CacheReservationManager is an interface for reserving cache space for the
-// memory used
+
+// CacheReservationManager is for reserving cache space for the memory used
+// through inserting/releasing dummy entries in the cache.
+// This class is not thread-safe.
 class CacheReservationManager {
  public:
-  // CacheReservationHandle is for managing the lifetime of a cache reservation
-  // for an incremental amount of memory used (i.e, incremental_memory_used)
-  class CacheReservationHandle {
-   public:
-    virtual ~CacheReservationHandle() {}
-  };
-  virtual ~CacheReservationManager() {}
-  virtual Status UpdateCacheReservation(std::size_t new_memory_used) = 0;
-  // TODO(hx235): replace the usage of
-  // `UpdateCacheReservation(memory_used_delta, increase)` with
-  // `UpdateCacheReservation(new_memory_used)` so that we only have one
-  // `UpdateCacheReservation` function
-  virtual Status UpdateCacheReservation(std::size_t memory_used_delta,
-                                        bool increase) = 0;
-  virtual Status MakeCacheReservation(
-      std::size_t incremental_memory_used,
-      std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-          *handle) = 0;
-  virtual std::size_t GetTotalReservedCacheSize() = 0;
-  virtual std::size_t GetTotalMemoryUsed() = 0;
-};
-
-// CacheReservationManagerImpl implements interface CacheReservationManager
-// for reserving cache space for the memory used by inserting/releasing dummy
-// entries in the cache.
-//
-// This class is NOT thread-safe, except that GetTotalReservedCacheSize()
-// can be called without external synchronization.
-template <CacheEntryRole R>
-class CacheReservationManagerImpl
-    : public CacheReservationManager,
-      public std::enable_shared_from_this<CacheReservationManagerImpl<R>> {
- public:
-  class CacheReservationHandle
-      : public CacheReservationManager::CacheReservationHandle {
-   public:
-    CacheReservationHandle(
-        std::size_t incremental_memory_used,
-        std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr);
-    ~CacheReservationHandle() override;
-
-   private:
-    std::size_t incremental_memory_used_;
-    std::shared_ptr<CacheReservationManagerImpl> cache_res_mgr_;
-  };
-
-  // Construct a CacheReservationManagerImpl
+  // Construct a CacheReservationManager
   // @param cache The cache where dummy entries are inserted and released for
   // reserving cache space
   // @param delayed_decrease If set true, then dummy entries won't be released
-  //                         immediately when memory usage decreases.
+  // immediately when memory usage decreases.
   //                         Instead, it will be released when the memory usage
   //                         decreases to 3/4 of what we have reserved so far.
   //                         This is for saving some future dummy entry
   //                         insertion when memory usage increases are likely to
   //                         happen in the near future.
-  //
-  // REQUIRED: cache is not nullptr
-  explicit CacheReservationManagerImpl(std::shared_ptr<Cache> cache,
-                                       bool delayed_decrease = false);
+  explicit CacheReservationManager(std::shared_ptr<Cache> cache,
+                                   bool delayed_decrease = false);
 
   // no copy constructor, copy assignment, move constructor, move assignment
-  CacheReservationManagerImpl(const CacheReservationManagerImpl &) = delete;
-  CacheReservationManagerImpl &operator=(const CacheReservationManagerImpl &) =
-      delete;
-  CacheReservationManagerImpl(CacheReservationManagerImpl &&) = delete;
-  CacheReservationManagerImpl &operator=(CacheReservationManagerImpl &&) =
-      delete;
+  CacheReservationManager(const CacheReservationManager &) = delete;
+  CacheReservationManager &operator=(const CacheReservationManager &) = delete;
+  CacheReservationManager(CacheReservationManager &&) = delete;
+  CacheReservationManager &operator=(CacheReservationManager &&) = delete;
 
-  ~CacheReservationManagerImpl() override;
+  ~CacheReservationManager();
+
+  template <CacheEntryRole R>
 
-  // One of the two ways of reserving/releasing cache space,
-  // see MakeCacheReservation() for the other.
-  //
-  // Use ONLY one of these two ways to prevent unexpected behavior.
-  //
   // Insert and release dummy entries in the cache to
-  // match the size of total dummy entries with the least multiple of
-  // kSizeDummyEntry greater than or equal to new_mem_used
+  // match the size of total dummy entries with the smallest multiple of
+  // kSizeDummyEntry that is greater than or equal to new_mem_used
   //
   // Insert dummy entries if new_memory_used > cache_allocated_size_;
   //
@@ -120,198 +68,33 @@ class CacheReservationManagerImpl
   // is set true.
   //
   // @param new_memory_used The number of bytes used by new memory
-  //        The most recent new_memoy_used passed in will be returned
-  //        in GetTotalMemoryUsed() even when the call return non-ok status.
-  //
-  //        Since the class is NOT thread-safe, external synchronization on the
-  //        order of calling UpdateCacheReservation() is needed if you want
-  //        GetTotalMemoryUsed() indeed returns the latest memory used.
-  //
   // @return On inserting dummy entries, it returns Status::OK() if all dummy
-  //         entry insertions succeed.
-  //         Otherwise, it returns the first non-ok status;
-  //         On releasing dummy entries, it always returns Status::OK().
-  //         On keeping dummy entries the same, it always returns Status::OK().
-  Status UpdateCacheReservation(std::size_t new_memory_used) override;
-
-  Status UpdateCacheReservation(std::size_t /* memory_used_delta */,
-                                bool /* increase */) override {
-    return Status::NotSupported();
-  }
-
-  // One of the two ways of reserving cache space and releasing is done through
-  // destruction of CacheReservationHandle.
-  // See UpdateCacheReservation() for the other way.
-  //
-  // Use ONLY one of these two ways to prevent unexpected behavior.
-  //
-  // Insert dummy entries in the cache for the incremental memory usage
-  // to match the size of total dummy entries with the least multiple of
-  // kSizeDummyEntry greater than or equal to the total memory used.
-  //
-  // A CacheReservationHandle is returned as an output parameter.
-  // The reserved dummy entries are automatically released on the destruction of
-  // this handle, which achieves better RAII per cache reservation.
-  //
-  // WARNING: Deallocate all the handles of the CacheReservationManager object
-  //          before deallocating the object to prevent unexpected behavior.
-  //
-  // @param incremental_memory_used The number of bytes increased in memory
-  //        usage.
-  //
-  //        Calling GetTotalMemoryUsed() afterward will return the total memory
-  //        increased by this number, even when calling MakeCacheReservation()
-  //        returns non-ok status.
-  //
-  //        Since the class is NOT thread-safe, external synchronization in
-  //        calling MakeCacheReservation() is needed if you want
-  //        GetTotalMemoryUsed() indeed returns the latest memory used.
-  //
-  // @param handle An pointer to std::unique_ptr<CacheReservationHandle> that
-  //        manages the lifetime of the cache reservation represented by the
-  //        handle.
-  //
-  // @return It returns Status::OK() if all dummy
-  //         entry insertions succeed.
-  //         Otherwise, it returns the first non-ok status;
-  //
-  // REQUIRES: handle != nullptr
-  Status MakeCacheReservation(
-      std::size_t incremental_memory_used,
-      std::unique_ptr<CacheReservationManager::CacheReservationHandle> *handle)
-      override;
-
-  // Return the size of the cache (which is a multiple of kSizeDummyEntry)
-  // successfully reserved by calling UpdateCacheReservation().
-  //
-  // When UpdateCacheReservation() returns non-ok status,
-  // calling GetTotalReservedCacheSize() after that might return a slightly
-  // smaller number than the actual reserved cache size due to
-  // the returned number will always be a multiple of kSizeDummyEntry
-  // and cache full might happen in the middle of inserting a dummy entry.
-  std::size_t GetTotalReservedCacheSize() override;
-
-  // Return the latest total memory used indicated by the most recent call of
-  // UpdateCacheReservation(std::size_t new_memory_used);
-  std::size_t GetTotalMemoryUsed() override;
+  // entry insertions succeed. Otherwise, it returns the first non-ok status;
+  // On releasing dummy entries, it always returns Status::OK().
+  // On keeping dummy entries the same, it always returns Status::OK().
+  Status UpdateCacheReservation(std::size_t new_memory_used);
+  std::size_t GetTotalReservedCacheSize();
 
   static constexpr std::size_t GetDummyEntrySize() { return kSizeDummyEntry; }
 
-  // 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 const Cache::CacheItemHelper *TEST_GetCacheItemHelperForRole();
-
  private:
   static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
+  // The key will be longer than keys for blocks in SST files so they won't
+  // conflict.
+  static const std::size_t kCacheKeyPrefixSize =
+      BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
 
   Slice GetNextCacheKey();
-
-  Status ReleaseCacheReservation(std::size_t incremental_memory_used);
+  template <CacheEntryRole R>
   Status IncreaseCacheReservation(std::size_t new_mem_used);
   Status DecreaseCacheReservation(std::size_t new_mem_used);
 
-  using CacheInterface = PlaceholderSharedCacheInterface<R>;
-  CacheInterface cache_;
+  std::shared_ptr<Cache> cache_;
   bool delayed_decrease_;
   std::atomic<std::size_t> cache_allocated_size_;
-  std::size_t memory_used_;
   std::vector<Cache::Handle *> dummy_handles_;
-  CacheKey cache_key_;
-};
-
-class ConcurrentCacheReservationManager
-    : public CacheReservationManager,
-      public std::enable_shared_from_this<ConcurrentCacheReservationManager> {
- public:
-  class CacheReservationHandle
-      : public CacheReservationManager::CacheReservationHandle {
-   public:
-    CacheReservationHandle(
-        std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr,
-        std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-            cache_res_handle) {
-      assert(cache_res_mgr && cache_res_handle);
-      cache_res_mgr_ = cache_res_mgr;
-      cache_res_handle_ = std::move(cache_res_handle);
-    }
-
-    ~CacheReservationHandle() override {
-      std::lock_guard<std::mutex> lock(cache_res_mgr_->cache_res_mgr_mu_);
-      cache_res_handle_.reset();
-    }
-
-   private:
-    std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-        cache_res_handle_;
-  };
-
-  explicit ConcurrentCacheReservationManager(
-      std::shared_ptr<CacheReservationManager> cache_res_mgr) {
-    cache_res_mgr_ = std::move(cache_res_mgr);
-  }
-  ConcurrentCacheReservationManager(const ConcurrentCacheReservationManager &) =
-      delete;
-  ConcurrentCacheReservationManager &operator=(
-      const ConcurrentCacheReservationManager &) = delete;
-  ConcurrentCacheReservationManager(ConcurrentCacheReservationManager &&) =
-      delete;
-  ConcurrentCacheReservationManager &operator=(
-      ConcurrentCacheReservationManager &&) = delete;
-
-  ~ConcurrentCacheReservationManager() override {}
-
-  inline Status UpdateCacheReservation(std::size_t new_memory_used) override {
-    std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-    return cache_res_mgr_->UpdateCacheReservation(new_memory_used);
-  }
-
-  inline Status UpdateCacheReservation(std::size_t memory_used_delta,
-                                       bool increase) override {
-    std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-    std::size_t total_mem_used = cache_res_mgr_->GetTotalMemoryUsed();
-    Status s;
-    if (!increase) {
-      assert(total_mem_used >= memory_used_delta);
-      s = cache_res_mgr_->UpdateCacheReservation(total_mem_used -
-                                                 memory_used_delta);
-    } else {
-      s = cache_res_mgr_->UpdateCacheReservation(total_mem_used +
-                                                 memory_used_delta);
-    }
-    return s;
-  }
-
-  inline Status MakeCacheReservation(
-      std::size_t incremental_memory_used,
-      std::unique_ptr<CacheReservationManager::CacheReservationHandle> *handle)
-      override {
-    std::unique_ptr<CacheReservationManager::CacheReservationHandle>
-        wrapped_handle;
-    Status s;
-    {
-      std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-      s = cache_res_mgr_->MakeCacheReservation(incremental_memory_used,
-                                               &wrapped_handle);
-    }
-    (*handle).reset(
-        new ConcurrentCacheReservationManager::CacheReservationHandle(
-            std::enable_shared_from_this<
-                ConcurrentCacheReservationManager>::shared_from_this(),
-            std::move(wrapped_handle)));
-    return s;
-  }
-  inline std::size_t GetTotalReservedCacheSize() override {
-    return cache_res_mgr_->GetTotalReservedCacheSize();
-  }
-  inline std::size_t GetTotalMemoryUsed() override {
-    std::lock_guard<std::mutex> lock(cache_res_mgr_mu_);
-    return cache_res_mgr_->GetTotalMemoryUsed();
-  }
-
- private:
-  std::mutex cache_res_mgr_mu_;
-  std::shared_ptr<CacheReservationManager> cache_res_mgr_;
+  std::uint64_t next_cache_key_id_ = 0;
+  // The non-prefix part will be updated according to the ID to use.
+  char cache_key_[kCacheKeyPrefixSize + kMaxVarint64Length];
 };
 }  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager_test.cc

@@ -15,48 +15,58 @@
 #include "cache/cache_entry_roles.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/slice.h"
+#include "table/block_based/block_based_table_reader.h"
 #include "test_util/testharness.h"
 #include "util/coding.h"
 
 namespace ROCKSDB_NAMESPACE {
 class CacheReservationManagerTest : public ::testing::Test {
  protected:
-  static constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  static constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
+  static constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
   static constexpr int kNumShardBits = 0;  // 2^0 shard
+
+  static constexpr std::size_t kSizeDummyEntry =
+      CacheReservationManager::GetDummyEntrySize();
+  static const std::size_t kCacheKeyPrefixSize =
+      BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
   static constexpr std::size_t kMetaDataChargeOverhead = 10000;
 
-  std::shared_ptr<Cache> cache = NewLRUCache(kCacheCapacity, kNumShardBits);
-  std::shared_ptr<CacheReservationManager> test_cache_rev_mng;
+  std::shared_ptr<Cache> cache = NewLRUCache(kOneGigabyte, kNumShardBits);
+  std::unique_ptr<CacheReservationManager> test_cache_rev_mng;
 
   CacheReservationManagerTest() {
-    test_cache_rev_mng =
-        std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-            cache);
+    test_cache_rev_mng.reset(new CacheReservationManager(cache));
   }
 };
 
 TEST_F(CacheReservationManagerTest, GenerateCacheKey) {
+  // The first cache reservation manager owning the cache will have
+  // cache->NewId() = 1
+  constexpr std::size_t kCacheNewId = 1;
+  // The first key generated inside of cache reservation manager will have
+  // next_cache_key_id = 0
+  constexpr std::size_t kCacheKeyId = 0;
+
+  char expected_cache_key[kCacheKeyPrefixSize + kMaxVarint64Length];
+  std::memset(expected_cache_key, 0, kCacheKeyPrefixSize + kMaxVarint64Length);
+
+  EncodeVarint64(expected_cache_key, kCacheNewId);
+  char* end =
+      EncodeVarint64(expected_cache_key + kCacheKeyPrefixSize, kCacheKeyId);
+  Slice expected_cache_key_slice(
+      expected_cache_key, static_cast<std::size_t>(end - expected_cache_key));
+
   std::size_t new_mem_used = 1 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   ASSERT_EQ(s, Status::OK());
   ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
   ASSERT_LT(cache->GetPinnedUsage(),
             1 * kSizeDummyEntry + kMetaDataChargeOverhead);
 
-  // Next unique Cache key
-  CacheKey ckey = CacheKey::CreateUniqueForCacheLifetime(cache.get());
-  // Get to the underlying values
-  uint64_t* ckey_data = reinterpret_cast<uint64_t*>(&ckey);
-  // Back it up to the one used by CRM (using CacheKey implementation details)
-  ckey_data[1]--;
-
-  // Specific key (subject to implementation details)
-  EXPECT_EQ(ckey_data[0], 0);
-  EXPECT_EQ(ckey_data[1], 2);
-
-  Cache::Handle* handle = cache->Lookup(ckey.AsSlice());
+  Cache::Handle* handle = cache->Lookup(expected_cache_key_slice);
   EXPECT_NE(handle, nullptr)
       << "Failed to generate the cache key for the dummy entry correctly";
   // Clean up the returned handle from Lookup() to prevent memory leak
@@ -65,17 +75,21 @@ TEST_F(CacheReservationManagerTest, GenerateCacheKey) {
 
 TEST_F(CacheReservationManagerTest, KeepCacheReservationTheSame) {
   std::size_t new_mem_used = 1 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             1 * kSizeDummyEntry);
-  ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
   std::size_t initial_pinned_usage = cache->GetPinnedUsage();
   ASSERT_GE(initial_pinned_usage, 1 * kSizeDummyEntry);
   ASSERT_LT(initial_pinned_usage,
             1 * kSizeDummyEntry + kMetaDataChargeOverhead);
 
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to keep cache reservation the same when new_mem_used equals "
          "to current cache reservation";
@@ -83,9 +97,6 @@ TEST_F(CacheReservationManagerTest, KeepCacheReservationTheSame) {
             1 * kSizeDummyEntry)
       << "Failed to bookkeep correctly when new_mem_used equals to current "
          "cache reservation";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly when new_mem_used "
-         "equals to current cache reservation";
   EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
       << "Failed to keep underlying dummy entries the same when new_mem_used "
          "equals to current cache reservation";
@@ -94,14 +105,15 @@ TEST_F(CacheReservationManagerTest, KeepCacheReservationTheSame) {
 TEST_F(CacheReservationManagerTest,
        IncreaseCacheReservationByMultiplesOfDummyEntrySize) {
   std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to increase cache reservation correctly";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             2 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation increase correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
       << "Failed to increase underlying dummy entries in cache correctly";
   EXPECT_LT(cache->GetPinnedUsage(),
@@ -112,14 +124,15 @@ TEST_F(CacheReservationManagerTest,
 TEST_F(CacheReservationManagerTest,
        IncreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
   std::size_t new_mem_used = 2 * kSizeDummyEntry + kSizeDummyEntry / 2;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to increase cache reservation correctly";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             3 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation increase correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 3 * kSizeDummyEntry)
       << "Failed to increase underlying dummy entries in cache correctly";
   EXPECT_LT(cache->GetPinnedUsage(),
@@ -129,47 +142,47 @@ TEST_F(CacheReservationManagerTest,
 
 TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
      IncreaseCacheReservationOnFullCache) {
-  ;
+  constexpr std::size_t kOneMegabyte = 1024 * 1024;
+  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
   constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kSmallCacheCapacity = 4 * kSizeDummyEntry;
-  constexpr std::size_t kBigCacheCapacity = 4096 * kSizeDummyEntry;
+      CacheReservationManager::GetDummyEntrySize();
   constexpr std::size_t kMetaDataChargeOverhead = 10000;
 
   LRUCacheOptions lo;
-  lo.capacity = kSmallCacheCapacity;
+  lo.capacity = kOneMegabyte;
   lo.num_shard_bits = 0;  // 2^0 shard
   lo.strict_capacity_limit = true;
   std::shared_ptr<Cache> cache = NewLRUCache(lo);
-  std::shared_ptr<CacheReservationManager> test_cache_rev_mng =
-      std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-          cache);
+  std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
+      new CacheReservationManager(cache));
 
-  std::size_t new_mem_used = kSmallCacheCapacity + 1;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
-  EXPECT_EQ(s, Status::MemoryLimit())
+  std::size_t new_mem_used = kOneMegabyte + 1;
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
+  EXPECT_EQ(s, Status::Incomplete())
       << "Failed to return status to indicate failure of dummy entry insertion "
          "during cache reservation on full cache";
   EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
             1 * kSizeDummyEntry)
       << "Failed to bookkeep correctly before cache resevation failure happens "
          "due to full cache";
-  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            kSmallCacheCapacity)
+  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(), kOneMegabyte)
       << "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
          "entry insertions) when encountering cache resevation failure due to "
          "full cache";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
       << "Failed to insert underlying dummy entries correctly when "
          "encountering cache resevation failure due to full cache";
-  EXPECT_LE(cache->GetPinnedUsage(), kSmallCacheCapacity)
+  EXPECT_LE(cache->GetPinnedUsage(), kOneMegabyte)
       << "Failed to insert underlying dummy entries correctly when "
          "encountering cache resevation failure due to full cache";
 
-  new_mem_used = kSmallCacheCapacity / 2;  // 2 dummy entries
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  new_mem_used = kOneMegabyte / 2;  // 2 dummy entries
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to decrease cache reservation after encountering cache "
          "reservation failure due to full cache";
@@ -177,8 +190,6 @@ TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
             2 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation decrease correctly after "
          "encountering cache reservation due to full cache";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
       << "Failed to release underlying dummy entries correctly on cache "
          "reservation decrease after encountering cache resevation failure due "
@@ -190,34 +201,35 @@ TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
          "to full cache";
 
   // Create cache full again for subsequent tests
-  new_mem_used = kSmallCacheCapacity + 1;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
-  EXPECT_EQ(s, Status::MemoryLimit())
+  new_mem_used = kOneMegabyte + 1;
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
+  EXPECT_EQ(s, Status::Incomplete())
       << "Failed to return status to indicate failure of dummy entry insertion "
          "during cache reservation on full cache";
   EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
             1 * kSizeDummyEntry)
       << "Failed to bookkeep correctly before cache resevation failure happens "
          "due to full cache";
-  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(),
-            kSmallCacheCapacity)
+  EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(), kOneMegabyte)
       << "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
          "entry insertions) when encountering cache resevation failure due to "
          "full cache";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
       << "Failed to insert underlying dummy entries correctly when "
          "encountering cache resevation failure due to full cache";
-  EXPECT_LE(cache->GetPinnedUsage(), kSmallCacheCapacity)
+  EXPECT_LE(cache->GetPinnedUsage(), kOneMegabyte)
       << "Failed to insert underlying dummy entries correctly when "
          "encountering cache resevation failure due to full cache";
 
   // Increase cache capacity so the previously failed insertion can fully
   // succeed
-  cache->SetCapacity(kBigCacheCapacity);
-  new_mem_used = kSmallCacheCapacity + 1;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  cache->SetCapacity(kOneGigabyte);
+  new_mem_used = kOneMegabyte + 1;
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to increase cache reservation after increasing cache capacity "
          "and mitigating cache full error";
@@ -225,8 +237,6 @@ TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
             5 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation increase correctly after "
          "increasing cache capacity and mitigating cache full error";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 5 * kSizeDummyEntry)
       << "Failed to insert underlying dummy entries correctly after increasing "
          "cache capacity and mitigating cache full error";
@@ -239,24 +249,26 @@ TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
 TEST_F(CacheReservationManagerTest,
        DecreaseCacheReservationByMultiplesOfDummyEntrySize) {
   std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             2 * kSizeDummyEntry);
-  ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
   ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
   ASSERT_LT(cache->GetPinnedUsage(),
             2 * kSizeDummyEntry + kMetaDataChargeOverhead);
 
   new_mem_used = 1 * kSizeDummyEntry;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to decrease cache reservation correctly";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             1 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation decrease correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
       << "Failed to decrease underlying dummy entries in cache correctly";
   EXPECT_LT(cache->GetPinnedUsage(),
@@ -267,24 +279,26 @@ TEST_F(CacheReservationManagerTest,
 TEST_F(CacheReservationManagerTest,
        DecreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
   std::size_t new_mem_used = 2 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             2 * kSizeDummyEntry);
-  ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
   ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
   ASSERT_LT(cache->GetPinnedUsage(),
             2 * kSizeDummyEntry + kMetaDataChargeOverhead);
 
   new_mem_used = kSizeDummyEntry / 2;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to decrease cache reservation correctly";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             1 * kSizeDummyEntry)
       << "Failed to bookkeep cache reservation decrease correctly";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
       << "Failed to decrease underlying dummy entries in cache correctly";
   EXPECT_LT(cache->GetPinnedUsage(),
@@ -294,56 +308,59 @@ TEST_F(CacheReservationManagerTest,
 
 TEST(CacheReservationManagerWithDelayedDecreaseTest,
      DecreaseCacheReservationWithDelayedDecrease) {
+  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
   constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
+      CacheReservationManager::GetDummyEntrySize();
   constexpr std::size_t kMetaDataChargeOverhead = 10000;
 
   LRUCacheOptions lo;
-  lo.capacity = kCacheCapacity;
+  lo.capacity = kOneGigabyte;
   lo.num_shard_bits = 0;
   std::shared_ptr<Cache> cache = NewLRUCache(lo);
-  std::shared_ptr<CacheReservationManager> test_cache_rev_mng =
-      std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-          cache, true /* delayed_decrease */);
+  std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
+      new CacheReservationManager(cache, true /* delayed_decrease */));
 
   std::size_t new_mem_used = 8 * kSizeDummyEntry;
-  Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  Status s =
+      test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             8 * kSizeDummyEntry);
-  ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
   std::size_t initial_pinned_usage = cache->GetPinnedUsage();
   ASSERT_GE(initial_pinned_usage, 8 * kSizeDummyEntry);
   ASSERT_LT(initial_pinned_usage,
             8 * kSizeDummyEntry + kMetaDataChargeOverhead);
 
   new_mem_used = 6 * kSizeDummyEntry;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             8 * kSizeDummyEntry)
       << "Failed to bookkeep correctly when delaying cache reservation "
          "decrease";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
       << "Failed to delay decreasing underlying dummy entries in cache";
 
   new_mem_used = 7 * kSizeDummyEntry;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
   EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
             8 * kSizeDummyEntry)
       << "Failed to bookkeep correctly when delaying cache reservation "
          "decrease";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
       << "Failed to delay decreasing underlying dummy entries in cache";
 
   new_mem_used = 6 * kSizeDummyEntry - 1;
-  s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+  s = test_cache_rev_mng
+          ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+              new_mem_used);
   EXPECT_EQ(s, Status::OK())
       << "Failed to decrease cache reservation correctly when new_mem_used < "
          "GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
@@ -351,8 +368,6 @@ TEST(CacheReservationManagerWithDelayedDecreaseTest,
             6 * kSizeDummyEntry)
       << "Failed to bookkeep correctly when new_mem_used < "
          "GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
-      << "Failed to bookkeep the used memory correctly";
   EXPECT_GE(cache->GetPinnedUsage(), 6 * kSizeDummyEntry)
       << "Failed to decrease underlying dummy entries in cache when "
          "new_mem_used < GetTotalReservedCacheSize() * 3 / 4 on delayed "
@@ -366,21 +381,23 @@ TEST(CacheReservationManagerWithDelayedDecreaseTest,
 
 TEST(CacheReservationManagerDestructorTest,
      ReleaseRemainingDummyEntriesOnDestruction) {
+  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
   constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
+      CacheReservationManager::GetDummyEntrySize();
   constexpr std::size_t kMetaDataChargeOverhead = 10000;
 
   LRUCacheOptions lo;
-  lo.capacity = kCacheCapacity;
+  lo.capacity = kOneGigabyte;
   lo.num_shard_bits = 0;
   std::shared_ptr<Cache> cache = NewLRUCache(lo);
   {
-    std::shared_ptr<CacheReservationManager> test_cache_rev_mng =
-        std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-            cache);
+    std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
+        new CacheReservationManager(cache));
     std::size_t new_mem_used = 1 * kSizeDummyEntry;
-    Status s = test_cache_rev_mng->UpdateCacheReservation(new_mem_used);
+    Status s =
+        test_cache_rev_mng
+            ->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
+                new_mem_used);
     ASSERT_EQ(s, Status::OK());
     ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
     ASSERT_LT(cache->GetPinnedUsage(),
@@ -390,80 +407,9 @@ TEST(CacheReservationManagerDestructorTest,
       << "Failed to release remaining underlying dummy entries in cache in "
          "CacheReservationManager's destructor";
 }
-
-TEST(CacheReservationHandleTest, HandleTest) {
-  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
-  constexpr std::size_t kSizeDummyEntry = 256 * 1024;
-  constexpr std::size_t kMetaDataChargeOverhead = 10000;
-
-  LRUCacheOptions lo;
-  lo.capacity = kOneGigabyte;
-  lo.num_shard_bits = 0;
-  std::shared_ptr<Cache> cache = NewLRUCache(lo);
-
-  std::shared_ptr<CacheReservationManager> test_cache_rev_mng(
-      std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-          cache));
-
-  std::size_t mem_used = 0;
-  const std::size_t incremental_mem_used_handle_1 = 1 * kSizeDummyEntry;
-  const std::size_t incremental_mem_used_handle_2 = 2 * kSizeDummyEntry;
-  std::unique_ptr<CacheReservationManager::CacheReservationHandle> handle_1,
-      handle_2;
-
-  // To test consecutive CacheReservationManager::MakeCacheReservation works
-  // correctly in terms of returning the handle as well as updating cache
-  // reservation and the latest total memory used
-  Status s = test_cache_rev_mng->MakeCacheReservation(
-      incremental_mem_used_handle_1, &handle_1);
-  mem_used = mem_used + incremental_mem_used_handle_1;
-  ASSERT_EQ(s, Status::OK());
-  EXPECT_TRUE(handle_1 != nullptr);
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
-  EXPECT_GE(cache->GetPinnedUsage(), mem_used);
-  EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
-
-  s = test_cache_rev_mng->MakeCacheReservation(incremental_mem_used_handle_2,
-                                               &handle_2);
-  mem_used = mem_used + incremental_mem_used_handle_2;
-  ASSERT_EQ(s, Status::OK());
-  EXPECT_TRUE(handle_2 != nullptr);
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
-  EXPECT_GE(cache->GetPinnedUsage(), mem_used);
-  EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
-
-  // To test
-  // CacheReservationManager::CacheReservationHandle::~CacheReservationHandle()
-  // works correctly in releasing the cache reserved for the handle
-  handle_1.reset();
-  EXPECT_TRUE(handle_1 == nullptr);
-  mem_used = mem_used - incremental_mem_used_handle_1;
-  EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
-  EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
-  EXPECT_GE(cache->GetPinnedUsage(), mem_used);
-  EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
-
-  // To test the actual CacheReservationManager object won't be deallocated
-  // as long as there remain handles pointing to it.
-  // We strongly recommend deallocating CacheReservationManager object only
-  // after all its handles are deallocated to keep things easy to reasonate
-  test_cache_rev_mng.reset();
-  EXPECT_GE(cache->GetPinnedUsage(), mem_used);
-  EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
-
-  handle_2.reset();
-  // The CacheReservationManager object is now deallocated since all the handles
-  // and its original pointer is gone
-  mem_used = mem_used - incremental_mem_used_handle_2;
-  EXPECT_EQ(mem_used, 0);
-  EXPECT_EQ(cache->GetPinnedUsage(), mem_used);
-}
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

cache/charged_cache.cc

@@ -1,101 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "cache/charged_cache.h"
-
-#include "cache/cache_reservation_manager.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-ChargedCache::ChargedCache(std::shared_ptr<Cache> cache,
-                           std::shared_ptr<Cache> block_cache)
-    : cache_(cache),
-      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
-          std::make_shared<
-              CacheReservationManagerImpl<CacheEntryRole::kBlobCache>>(
-              block_cache))) {}
-
-Status ChargedCache::Insert(const Slice& key, ObjectPtr obj,
-                            const CacheItemHelper* helper, size_t charge,
-                            Handle** handle, Priority 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
-    // in the cache.
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Cache::Handle* ChargedCache::Lookup(const Slice& key,
-                                    const CacheItemHelper* helper,
-                                    CreateContext* create_context,
-                                    Priority priority, bool wait,
-                                    Statistics* 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.
-  if (helper && helper->create_cb) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return handle;
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool useful,
-                           bool erase_if_last_ref) {
-  size_t memory_used_delta = cache_->GetUsage(handle);
-  bool erased = cache_->Release(handle, useful, erase_if_last_ref);
-  if (erased) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_
-        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
-        .PermitUncheckedError();
-  }
-  return erased;
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool erase_if_last_ref) {
-  size_t memory_used_delta = cache_->GetUsage(handle);
-  bool erased = cache_->Release(handle, erase_if_last_ref);
-  if (erased) {
-    assert(cache_res_mgr_);
-    cache_res_mgr_
-        ->UpdateCacheReservation(memory_used_delta, /* increase */ false)
-        .PermitUncheckedError();
-  }
-  return erased;
-}
-
-void ChargedCache::Erase(const Slice& key) {
-  cache_->Erase(key);
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::EraseUnRefEntries() {
-  cache_->EraseUnRefEntries();
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::SetCapacity(size_t capacity) {
-  cache_->SetCapacity(capacity);
-  // SetCapacity can result in evictions when the cache capacity is decreased,
-  // so we would want to update the cache reservation here as well.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/charged_cache.h

@@ -1,116 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <string>
-
-#include "port/port.h"
-#include "rocksdb/cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class ConcurrentCacheReservationManager;
-
-// A cache interface which wraps around another cache and takes care of
-// reserving space in block cache towards a single global memory limit, and
-// forwards all the calls to the underlying cache.
-class ChargedCache : public Cache {
- public:
-  ChargedCache(std::shared_ptr<Cache> cache,
-               std::shared_ptr<Cache> block_cache);
-  ~ChargedCache() override = default;
-
-  Status Insert(const Slice& key, ObjectPtr obj, const CacheItemHelper* helper,
-                size_t charge, Handle** handle = nullptr,
-                Priority priority = Priority::LOW) override;
-
-  Cache::Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                        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;
-  bool Release(Cache::Handle* handle, bool erase_if_last_ref = false) override;
-
-  void Erase(const Slice& key) override;
-  void EraseUnRefEntries() override;
-
-  static const char* kClassName() { return "ChargedCache"; }
-  const char* Name() const override { return kClassName(); }
-
-  uint64_t NewId() override { return cache_->NewId(); }
-
-  void SetCapacity(size_t capacity) override;
-
-  void SetStrictCapacityLimit(bool strict_capacity_limit) override {
-    cache_->SetStrictCapacityLimit(strict_capacity_limit);
-  }
-
-  bool HasStrictCapacityLimit() const override {
-    return cache_->HasStrictCapacityLimit();
-  }
-
-  ObjectPtr Value(Cache::Handle* handle) override {
-    return cache_->Value(handle);
-  }
-
-  bool IsReady(Cache::Handle* handle) override {
-    return cache_->IsReady(handle);
-  }
-
-  void Wait(Cache::Handle* handle) override { cache_->Wait(handle); }
-
-  void WaitAll(std::vector<Handle*>& handles) override {
-    cache_->WaitAll(handles);
-  }
-
-  bool Ref(Cache::Handle* handle) override { return cache_->Ref(handle); }
-
-  size_t GetCapacity() const override { return cache_->GetCapacity(); }
-
-  size_t GetUsage() const override { return cache_->GetUsage(); }
-
-  size_t GetUsage(Cache::Handle* handle) const override {
-    return cache_->GetUsage(handle);
-  }
-
-  size_t GetPinnedUsage() const override { return cache_->GetPinnedUsage(); }
-
-  size_t GetCharge(Cache::Handle* handle) const override {
-    return cache_->GetCharge(handle);
-  }
-
-  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override {
-    return cache_->GetCacheItemHelper(handle);
-  }
-
-  void ApplyToAllEntries(
-      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);
-  }
-
-  std::string GetPrintableOptions() const override {
-    return cache_->GetPrintableOptions();
-  }
-
-  void DisownData() override { return cache_->DisownData(); }
-
-  inline Cache* GetCache() const { return cache_.get(); }
-
-  inline ConcurrentCacheReservationManager* TEST_GetCacheReservationManager()
-      const {
-    return cache_res_mgr_.get();
-  }
-
- private:
-  std::shared_ptr<Cache> cache_;
-  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/clock_cache.h

@@ -9,691 +9,8 @@
 
 #pragma once
 
-#include <array>
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#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/cache.h"
-#include "rocksdb/secondary_cache.h"
-#include "util/autovector.h"
 
-namespace ROCKSDB_NAMESPACE {
-
-namespace clock_cache {
-
-// Forward declaration of friend class.
-class ClockCacheTest;
-
-// HyperClockCache is an alternative to LRUCache specifically tailored for
-// use as BlockBasedTableOptions::block_cache
-//
-// Benefits
-// --------
-// * Fully lock free (no waits or spins) for efficiency under high concurrency
-// * Optimized for hot path reads. For concurrency control, most Lookup() and
-// essentially all Release() are a single atomic add operation.
-// * Eviction on insertion is fully parallel and lock-free.
-// * Uses a generalized + aging variant of CLOCK eviction that might outperform
-// LRU in some cases. (For background, see
-// https://en.wikipedia.org/wiki/Page_replacement_algorithm)
-//
-// Costs
-// -----
-// * Hash table is not resizable (for lock-free efficiency) so capacity is not
-// dynamically changeable. Rely on an estimated average value (block) size for
-// space+time efficiency. (See estimated_entry_charge option details.)
-// * Insert usually does not (but might) overwrite a previous entry associated
-// with a cache key. This is OK for RocksDB uses of Cache.
-// * Only supports keys of exactly 16 bytes, which is what RocksDB uses for
-// block cache (not row cache or table cache).
-// * SecondaryCache is not supported.
-// * Cache priorities are less aggressively enforced. Unlike LRUCache, enough
-// transient LOW or BOTTOM priority items can evict HIGH priority entries that
-// are not referenced recently (or often) enough.
-// * If pinned entries leave little or nothing eligible for eviction,
-// performance can degrade substantially, because of clock eviction eating
-// CPU looking for evictable entries and because Release does not
-// pro-actively delete unreferenced entries when the cache is over-full.
-// Specifically, this makes this implementation more susceptible to the
-// following combination:
-//   * num_shard_bits is high (e.g. 6)
-//   * capacity small (e.g. some MBs)
-//   * some large individual entries (e.g. non-partitioned filters)
-// where individual entries occupy a large portion of their shard capacity.
-// This should be mostly mitigated by the implementation picking a lower
-// number of cache shards than LRUCache for a given capacity (when
-// num_shard_bits is not overridden; see calls to GetDefaultCacheShardBits()).
-// * With strict_capacity_limit=false, respecting the capacity limit is not as
-// aggressive as LRUCache. The limit might be transiently exceeded by a very
-// small number of entries even when not strictly necessary, and slower to
-// recover after pinning forces limit to be substantially exceeded. (Even with
-// strict_capacity_limit=true, RocksDB will nevertheless transiently allocate
-// memory before discovering it is over the block cache capacity, so this
-// should not be a detectable regression in respecting memory limits, except
-// on exceptionally small caches.)
-// * In some cases, erased or duplicated entries might not be freed
-// immediately. They will eventually be freed by eviction from further Inserts.
-// * Internal metadata can overflow if the number of simultaneous references
-// to a cache handle reaches many millions.
-//
-// High-level eviction algorithm
-// -----------------------------
-// A score (or "countdown") is maintained for each entry, initially determined
-// by priority. The score is incremented on each Lookup, up to a max of 3,
-// though is easily returned to previous state if useful=false with Release.
-// During CLOCK-style eviction iteration, entries with score > 0 are
-// decremented if currently unreferenced and entries with score == 0 are
-// evicted if currently unreferenced. Note that scoring might not be perfect
-// because entries can be referenced transiently within the cache even when
-// there are no outside references to the entry.
-//
-// Cache sharding like LRUCache is used to reduce contention on usage+eviction
-// state, though here the performance improvement from more shards is small,
-// and (as noted above) potentially detrimental if shard capacity is too close
-// to largest entry size. Here cache sharding mostly only affects cache update
-// (Insert / Erase) performance, not read performance.
-//
-// Read efficiency (hot path)
-// --------------------------
-// Mostly to minimize the cost of accessing metadata blocks with
-// cache_index_and_filter_blocks=true, we focus on optimizing Lookup and
-// Release. In terms of concurrency, at a minimum, these operations have
-// to do reference counting (and Lookup has to compare full keys in a safe
-// way). Can we fold in all the other metadata tracking *for free* with
-// Lookup and Release doing a simple atomic fetch_add/fetch_sub? (Assume
-// for the moment that Lookup succeeds on the first probe.)
-//
-// We have a clever way of encoding an entry's reference count and countdown
-// clock so that Lookup and Release are each usually a single atomic addition.
-// In a single metadata word we have both an "acquire" count, incremented by
-// Lookup, and a "release" count, incremented by Release. If useful=false,
-// Release can instead decrement the acquire count. Thus the current ref
-// count is (acquires - releases), and the countdown clock is min(3, acquires).
-// Note that only unreferenced entries (acquires == releases) are eligible
-// for CLOCK manipulation and eviction. We tolerate use of more expensive
-// compare_exchange operations for cache writes (insertions and erasures).
-//
-// In a cache receiving many reads and little or no writes, it is possible
-// for the acquire and release counters to overflow. Assuming the *current*
-// refcount never reaches to many millions, we only have to correct for
-// overflow in both counters in Release, not in Lookup. The overflow check
-// should be only 1-2 CPU cycles per Release because it is a predictable
-// branch on a simple condition on data already in registers.
-//
-// Slot states
-// -----------
-// We encode a state indicator into the same metadata word with the
-// acquire and release counters. This allows bigger state transitions to
-// be atomic. States:
-//
-// * Empty - slot is not in use and unowned. All other metadata and data is
-// in an undefined state.
-// * Construction - slot is exclusively owned by one thread, the thread
-// successfully entering this state, for populating or freeing data.
-// * Shareable (group) - slot holds an entry with counted references for
-// pinning and reading, including
-//   * Visible - slot holds an entry that can be returned by Lookup
-//   * Invisible - slot holds an entry that is not visible to Lookup
-//     (erased by user) but can be read by existing references, and ref count
-//     changed by Ref and Release.
-//
-// A special case is "detached" entries, which are heap-allocated handles
-// not in the table. They are always Invisible and freed on zero refs.
-//
-// State transitions:
-// Empty -> Construction (in Insert): The encoding of state enables Insert to
-// perform an optimistic atomic bitwise-or to take ownership if a slot is
-// empty, or otherwise make no state change.
-//
-// Construction -> Visible (in Insert): This can be a simple assignment to the
-// metadata word because the current thread has exclusive ownership and other
-// metadata is meaningless.
-//
-// Visible -> Invisible (in Erase): This can be a bitwise-and while holding
-// a shared reference, which is safe because the change is idempotent (in case
-// of parallel Erase). By the way, we never go Invisible->Visible.
-//
-// Shareable -> Construction (in Evict part of Insert, in Erase, and in
-// Release if Invisible): This is for starting to freeing/deleting an
-// unreferenced entry. We have to use compare_exchange to ensure we only make
-// this transition when there are zero refs.
-//
-// Construction -> Empty (in same places): This is for completing free/delete
-// of an entry. A "release" atomic store suffices, as we have exclusive
-// ownership of the slot but have to ensure none of the data member reads are
-// re-ordered after committing the state transition.
-//
-// Insert
-// ------
-// If Insert were to guarantee replacing an existing entry for a key, there
-// would be complications for concurrency and efficiency. First, consider how
-// many probes to get to an entry. To ensure Lookup never waits and
-// availability of a key is uninterrupted, we would need to use a different
-// slot for a new entry for the same key. This means it is most likely in a
-// later probing position than the old version, which should soon be removed.
-// (Also, an entry is too big to replace atomically, even if no current refs.)
-//
-// However, overwrite capability is not really needed by RocksDB. Also, we
-// know from our "redundant" stats that overwrites are very rare for the block
-// cache, so we should not spend much to make them effective.
-//
-// So instead we Insert as soon as we find an empty slot in the probing
-// sequence without seeing an existing (visible) entry for the same key. This
-// way we only insert if we can improve the probing performance, and we don't
-// need to probe beyond our insert position, assuming we are willing to let
-// the previous entry for the same key die of old age (eventual eviction from
-// not being used). We can reach a similar state with concurrent insertions,
-// where one will pass over the other while it is "under construction."
-// This temporary duplication is acceptable for RocksDB block cache because
-// we know redundant insertion is rare.
-//
-// Another problem to solve is what to return to the caller when we find an
-// existing entry whose probing position we cannot improve on, or when the
-// table occupancy limit has been reached. If strict_capacity_limit=false,
-// we must never fail Insert, and if a Handle* is provided, we have to return
-// a usable Cache handle on success. The solution to this (typically rare)
-// problem is "detached" handles, which are usable by the caller but not
-// actually available for Lookup in the Cache. Detached handles are allocated
-// independently on the heap and specially marked so that they are freed on
-// the heap when their last reference is released.
-//
-// Usage on capacity
-// -----------------
-// Insert takes different approaches to usage tracking depending on
-// strict_capacity_limit setting. If true, we enforce a kind of strong
-// consistency where compare-exchange is used to ensure the usage number never
-// exceeds its limit, and provide threads with an authoritative signal on how
-// much "usage" they have taken ownership of. With strict_capacity_limit=false,
-// we use a kind of "eventual consistency" where all threads Inserting to the
-// same cache shard might race on reserving the same space, but the
-// over-commitment will be worked out in later insertions. It is kind of a
-// dance because we don't want threads racing each other too much on paying
-// down the over-commitment (with eviction) either.
-//
-// Eviction
-// --------
-// A key part of Insert is evicting some entries currently unreferenced to
-// make room for new entries. The high-level eviction algorithm is described
-// above, but the details are also interesting. A key part is parallelizing
-// eviction with a single CLOCK pointer. This works by each thread working on
-// eviction pre-emptively incrementing the CLOCK pointer, and then CLOCK-
-// updating or evicting the incremented-over slot(s). To reduce contention at
-// the cost of possibly evicting too much, each thread increments the clock
-// pointer by 4, so commits to updating at least 4 slots per batch. As
-// described above, a CLOCK update will decrement the "countdown" of
-// unreferenced entries, or evict unreferenced entries with zero countdown.
-// Referenced entries are not updated, because we (presumably) don't want
-// long-referenced entries to age while referenced. Note however that we
-// cannot distinguish transiently referenced entries from cache user
-// references, so some CLOCK updates might be somewhat arbitrarily skipped.
-// This is OK as long as it is rare enough that eviction order is still
-// pretty good.
-//
-// There is no synchronization on the completion of the CLOCK updates, so it
-// is theoretically possible for another thread to cycle back around and have
-// two threads racing on CLOCK updates to the same slot. Thus, we cannot rely
-// on any implied exclusivity to make the updates or eviction more efficient.
-// These updates use an opportunistic compare-exchange (no loop), where a
-// racing thread might cause the update to be skipped without retry, but in
-// such case the update is likely not needed because the most likely update
-// to an entry is that it has become referenced. (TODO: test efficiency of
-// avoiding compare-exchange loop)
-//
-// Release
-// -------
-// In the common case, Release is a simple atomic increment of the release
-// counter. There is a simple overflow check that only does another atomic
-// update in extremely rare cases, so costs almost nothing.
-//
-// If the Release specifies "not useful", we can instead decrement the
-// acquire counter, which returns to the same CLOCK state as before Lookup
-// or Ref.
-//
-// Adding a check for over-full cache on every release to zero-refs would
-// likely be somewhat expensive, increasing read contention on cache shard
-// metadata. Instead we are less aggressive about deleting entries right
-// away in those cases.
-//
-// However Release tries to immediately delete entries reaching zero refs
-// if (a) erase_if_last_ref is set by the caller, or (b) the entry is already
-// marked invisible. Both of these are checks on values already in CPU
-// registers so do not increase cross-CPU contention when not applicable.
-// When applicable, they use a compare-exchange loop to take exclusive
-// ownership of the slot for freeing the entry. These are rare cases
-// that should not usually affect performance.
-//
-// Erase
-// -----
-// Searches for an entry like Lookup but moves it to Invisible state if found.
-// This state transition is with bit operations so is idempotent and safely
-// done while only holding a shared "read" reference. Like Release, it makes
-// a best effort to immediately release an Invisible entry that reaches zero
-// refs, but there are some corner cases where it will only be freed by the
-// clock eviction process.
-
-// ----------------------------------------------------------------------- //
-
-// 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 occupied 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, which should be negligible
-// with double hashing).
-// 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.7;
-
-// The user can exceed kLoadFactor if the sizes of the inserted values don't
-// match estimated_value_size, or in some rare cases with
-// strict_capacity_limit == false. To avoid degenerate performance, we set a
-// strict upper bound on the load factor.
-constexpr double kStrictLoadFactor = 0.84;
-
-struct ClockHandleBasicData {
-  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(MemoryAllocator* allocator) const;
-
-  // Required by concept HandleImpl
-  const UniqueId64x2& GetHash() const { return hashed_key; }
-};
-
-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
-  // -----------------------------------------------------------------------
-  // | acquire counter          | release counter           | state marker |
-  // -----------------------------------------------------------------------
-
-  // For reading or updating counters in meta word.
-  static constexpr uint8_t kCounterNumBits = 30;
-  static constexpr uint64_t kCounterMask = (uint64_t{1} << kCounterNumBits) - 1;
-
-  static constexpr uint8_t kAcquireCounterShift = 0;
-  static constexpr uint64_t kAcquireIncrement = uint64_t{1}
-                                                << kAcquireCounterShift;
-  static constexpr uint8_t kReleaseCounterShift = kCounterNumBits;
-  static constexpr uint64_t kReleaseIncrement = uint64_t{1}
-                                                << kReleaseCounterShift;
-
-  // For reading or updating the state marker in meta word
-  static constexpr uint8_t kStateShift = 2U * kCounterNumBits;
-
-  // Bits contribution to state marker.
-  // Occupied means any state other than empty
-  static constexpr uint8_t kStateOccupiedBit = 0b100;
-  // Shareable means the entry is reference counted (visible or invisible)
-  // (only set if also occupied)
-  static constexpr uint8_t kStateShareableBit = 0b010;
-  // Visible is only set if also shareable
-  static constexpr uint8_t kStateVisibleBit = 0b001;
-
-  // Complete state markers (not shifted into full word)
-  static constexpr uint8_t kStateEmpty = 0b000;
-  static constexpr uint8_t kStateConstruction = kStateOccupiedBit;
-  static constexpr uint8_t kStateInvisible =
-      kStateOccupiedBit | kStateShareableBit;
-  static constexpr uint8_t kStateVisible =
-      kStateOccupiedBit | kStateShareableBit | kStateVisibleBit;
-
-  // Constants for initializing the countdown clock. (Countdown clock is only
-  // in effect with zero refs, acquire counter == release counter, and in that
-  // case the countdown clock == both of those counters.)
-  static constexpr uint8_t kHighCountdown = 3;
-  static constexpr uint8_t kLowCountdown = 2;
-  static constexpr uint8_t kBottomCountdown = 1;
-  // During clock update, treat any countdown clock value greater than this
-  // value the same as this value.
-  static constexpr uint8_t kMaxCountdown = kHighCountdown;
-  // TODO: make these coundown values tuning parameters for eviction?
-
-  // See above
-  std::atomic<uint64_t> meta{};
-
-  // Anticipating use for SecondaryCache support
-  void* reserved_for_future_use = nullptr;
-};  // struct ClockHandle
-
-class HyperClockTable {
- public:
-  // 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{};
-
-    // 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);
-
-  HandleImpl* Lookup(const UniqueId64x2& hashed_key);
-
-  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref);
-
-  void Ref(HandleImpl& handle);
-
-  void Erase(const UniqueId64x2& hashed_key);
-
-  void ConstApplyToEntriesRange(std::function<void(const HandleImpl&)> func,
-                                size_t index_begin, size_t index_end,
-                                bool apply_if_will_be_deleted) const;
-
-  void EraseUnRefEntries();
-
-  size_t GetTableSize() const { return size_t{1} << length_bits_; }
-
-  int GetLengthBits() const { return length_bits_; }
-
-  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 {
-    return detached_usage_.load(std::memory_order_relaxed);
-  }
-
-  // Acquire/release N references
-  void TEST_RefN(HandleImpl& handle, size_t n);
-  void TEST_ReleaseN(HandleImpl* handle, size_t n);
-
- private:  // functions
-  // Returns x mod 2^{length_bits_}.
-  inline size_t ModTableSize(uint64_t x) {
-    return static_cast<size_t>(x) & length_bits_mask_;
-  }
-
-  // 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.
-  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
-  // step, the function first tests whether match(e) holds. If this is false,
-  // it evaluates abort(e) to decide whether the search should be aborted,
-  // and in the affirmative returns -1. For every handle e probed except
-  // the last one, the function runs update(e).
-  // The probe parameter is modified as follows. We say a probe to a handle
-  // e is aborting if match(e) is false and abort(e) is true. Then the final
-  // 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 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
-  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.
-  // The size of the table is 1 << length_bits_.
-  const int length_bits_;
-
-  // For faster computation of ModTableSize.
-  const size_t length_bits_mask_;
-
-  // Maximum number of elements the user can store in the table.
-  const size_t occupancy_limit_;
-
-  // Array of slots comprising the hash table.
-  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
-  // operations in ClockCacheShard.
-
-  ALIGN_AS(CACHE_LINE_SIZE)
-  // Clock algorithm sweep pointer.
-  std::atomic<uint64_t> clock_pointer_{};
-
-  ALIGN_AS(CACHE_LINE_SIZE)
-  // Number of elements in the table.
-  std::atomic<size_t> occupancy_{};
-
-  // Memory usage by entries tracked by the cache (including detached)
-  std::atomic<size_t> usage_{};
-
-  // Part of usage by detached entries (not in table)
-  std::atomic<size_t> detached_usage_{};
-};  // 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, bool strict_capacity_limit,
-                  CacheMetadataChargePolicy metadata_charge_policy,
-                  MemoryAllocator* allocator, const typename Table::Opts& opts);
-
-  // For CacheShard concept
-  using HandleImpl = typename Table::HandleImpl;
-  // Hash is lossless hash of 128-bit key
-  using HashVal = UniqueId64x2;
-  using HashCref = const HashVal&;
-  static inline uint32_t HashPieceForSharding(HashCref hash) {
-    return Upper32of64(hash[0]);
-  }
-  static inline HashVal ComputeHash(const Slice& key) {
-    assert(key.size() == kCacheKeySize);
-    HashVal in;
-    HashVal out;
-    // NOTE: endian dependence
-    // TODO: use GetUnaligned?
-    std::memcpy(&in, key.data(), kCacheKeySize);
-    BijectiveHash2x64(in[1], in[0], &out[1], &out[0]);
-    return out;
-  }
-
-  // For reconstructing key from hashed_key. Requires the caller to provide
-  // backing storage for the Slice in `unhashed`
-  static inline Slice ReverseHash(const UniqueId64x2& hashed,
-                                  UniqueId64x2* unhashed) {
-    BijectiveUnhash2x64(hashed[1], hashed[0], &(*unhashed)[1], &(*unhashed)[0]);
-    // NOTE: endian dependence
-    return Slice(reinterpret_cast<const char*>(unhashed), kCacheKeySize);
-  }
-
-  // Although capacity is dynamically changeable, the number of table slots is
-  // not, so growing capacity substantially could lead to hitting occupancy
-  // limit.
-  void SetCapacity(size_t capacity);
-
-  void SetStrictCapacityLimit(bool strict_capacity_limit);
-
-  Status Insert(const Slice& key, const UniqueId64x2& hashed_key,
-                Cache::ObjectPtr value, const Cache::CacheItemHelper* helper,
-                size_t charge, HandleImpl** handle, Cache::Priority priority);
-
-  HandleImpl* Lookup(const Slice& key, const UniqueId64x2& hashed_key);
-
-  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref);
-
-  bool Release(HandleImpl* handle, bool erase_if_last_ref = false);
-
-  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, 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{}; }
-
-  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(HandleImpl* /*handle*/) { return true; }
-
-  void Wait(HandleImpl* /*handle*/) {}
-
-  // Acquire/release N references
-  void TEST_RefN(HandleImpl* handle, size_t n);
-  void TEST_ReleaseN(HandleImpl* handle, size_t n);
-
- private:  // data
-  Table table_;
-
-  // Maximum total charge of all elements stored in the table.
-  std::atomic<size_t> capacity_;
-
-  // Whether to reject insertion if cache reaches its full capacity.
-  std::atomic<bool> strict_capacity_limit_;
-};  // class ClockCacheShard
-
-class HyperClockCache
-#ifdef NDEBUG
-    final
+#if defined(TBB) && !defined(ROCKSDB_LITE)
+#define SUPPORT_CLOCK_CACHE
 #endif
-    : 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,
-                  std::shared_ptr<MemoryAllocator> memory_allocator);
-
-  const char* Name() const override { return "HyperClockCache"; }
-
-  Cache::ObjectPtr Value(Handle* handle) override;
-
-  size_t GetCharge(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 clock_cache
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.cc

@@ -1,337 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "cache/compressed_secondary_cache.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <memory>
-
-#include "memory/memory_allocator.h"
-#include "monitoring/perf_context_imp.h"
-#include "util/compression.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-CompressedSecondaryCache::CompressedSecondaryCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge)
-    : cache_options_(capacity, num_shard_bits, strict_capacity_limit,
-                     high_pri_pool_ratio, low_pri_pool_ratio, memory_allocator,
-                     use_adaptive_mutex, metadata_charge_policy,
-                     compression_type, compress_format_version,
-                     enable_custom_split_merge) {
-  cache_ =
-      NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
-                  high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                  metadata_charge_policy, low_pri_pool_ratio);
-}
-
-CompressedSecondaryCache::~CompressedSecondaryCache() { cache_.reset(); }
-
-std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
-    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);
-  if (lru_handle == nullptr) {
-    return nullptr;
-  }
-
-  void* handle_value = cache_->Value(lru_handle);
-  if (handle_value == nullptr) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-    return nullptr;
-  }
-
-  CacheAllocationPtr* ptr{nullptr};
-  CacheAllocationPtr merged_value;
-  size_t handle_value_charge{0};
-  if (cache_options_.enable_custom_split_merge) {
-    CacheValueChunk* value_chunk_ptr =
-        reinterpret_cast<CacheValueChunk*>(handle_value);
-    merged_value = MergeChunksIntoValue(value_chunk_ptr, handle_value_charge);
-    ptr = &merged_value;
-  } else {
-    ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
-    handle_value_charge = cache_->GetCharge(lru_handle);
-  }
-  MemoryAllocator* allocator = cache_options_.memory_allocator.get();
-
-  Status s;
-  Cache::ObjectPtr value{nullptr};
-  size_t charge{0};
-  if (cache_options_.compression_type == kNoCompression) {
-    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,
-                                         UncompressionDict::GetEmptyDict(),
-                                         cache_options_.compression_type);
-
-    size_t uncompressed_size{0};
-    CacheAllocationPtr uncompressed = UncompressData(
-        uncompression_info, (char*)ptr->get(), handle_value_charge,
-        &uncompressed_size, cache_options_.compress_format_version, allocator);
-
-    if (!uncompressed) {
-      cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-      return nullptr;
-    }
-    s = helper->create_cb(Slice(uncompressed.get(), uncompressed_size),
-                          create_context, allocator, &value, &charge);
-  }
-
-  if (!s.ok()) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-    return nullptr;
-  }
-
-  if (advise_erase) {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-    // Insert a dummy handle.
-    cache_
-        ->Insert(key, /*obj=*/nullptr,
-                 GetHelper(cache_options_.enable_custom_split_merge),
-                 /*charge=*/0)
-        .PermitUncheckedError();
-  } else {
-    is_in_sec_cache = true;
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
-  handle.reset(new CompressedSecondaryCacheResultHandle(value, charge));
-  return handle;
-}
-
-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);
-  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, /*obj=*/nullptr, internal_helper,
-                          /*charge=*/0);
-  } else {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
-
-  size_t size = (*helper->size_cb)(value);
-  CacheAllocationPtr ptr =
-      AllocateBlock(size, cache_options_.memory_allocator.get());
-
-  Status s = (*helper->saveto_cb)(value, 0, size, ptr.get());
-  if (!s.ok()) {
-    return s;
-  }
-  Slice val(ptr.get(), size);
-
-  std::string compressed_val;
-  if (cache_options_.compression_type != kNoCompression) {
-    PERF_COUNTER_ADD(compressed_sec_cache_uncompressed_bytes, size);
-    CompressionOptions compression_opts;
-    CompressionContext compression_context(cache_options_.compression_type);
-    uint64_t sample_for_compression{0};
-    CompressionInfo compression_info(
-        compression_opts, compression_context, CompressionDict::GetEmptyDict(),
-        cache_options_.compression_type, sample_for_compression);
-
-    bool success =
-        CompressData(val, compression_info,
-                     cache_options_.compress_format_version, &compressed_val);
-
-    if (!success) {
-      return Status::Corruption("Error compressing value.");
-    }
-
-    val = Slice(compressed_val);
-    size = compressed_val.size();
-    PERF_COUNTER_ADD(compressed_sec_cache_compressed_bytes, size);
-
-    if (!cache_options_.enable_custom_split_merge) {
-      ptr = AllocateBlock(size, cache_options_.memory_allocator.get());
-      memcpy(ptr.get(), compressed_val.data(), size);
-    }
-  }
-
-  PERF_COUNTER_ADD(compressed_sec_cache_insert_real_count, 1);
-  if (cache_options_.enable_custom_split_merge) {
-    size_t charge{0};
-    CacheValueChunk* value_chunks_head =
-        SplitValueIntoChunks(val, cache_options_.compression_type, charge);
-    return cache_->Insert(key, value_chunks_head, internal_helper, charge);
-  } else {
-    CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    return cache_->Insert(key, buf, internal_helper, size);
-  }
-}
-
-void CompressedSecondaryCache::Erase(const Slice& key) { cache_->Erase(key); }
-
-Status CompressedSecondaryCache::SetCapacity(size_t capacity) {
-  MutexLock l(&capacity_mutex_);
-  cache_options_.capacity = capacity;
-  cache_->SetCapacity(capacity);
-  return Status::OK();
-}
-
-Status CompressedSecondaryCache::GetCapacity(size_t& capacity) {
-  MutexLock l(&capacity_mutex_);
-  capacity = cache_options_.capacity;
-  return Status::OK();
-}
-
-std::string CompressedSecondaryCache::GetPrintableOptions() const {
-  std::string ret;
-  ret.reserve(20000);
-  const int kBufferSize{200};
-  char buffer[kBufferSize];
-  ret.append(cache_->GetPrintableOptions());
-  snprintf(buffer, kBufferSize, "    compression_type : %s\n",
-           CompressionTypeToString(cache_options_.compression_type).c_str());
-  ret.append(buffer);
-  snprintf(buffer, kBufferSize, "    compress_format_version : %d\n",
-           cache_options_.compress_format_version);
-  ret.append(buffer);
-  return ret;
-}
-
-CompressedSecondaryCache::CacheValueChunk*
-CompressedSecondaryCache::SplitValueIntoChunks(const Slice& value,
-                                               CompressionType compression_type,
-                                               size_t& charge) {
-  assert(!value.empty());
-  const char* src_ptr = value.data();
-  size_t src_size{value.size()};
-
-  CacheValueChunk dummy_head = CacheValueChunk();
-  CacheValueChunk* current_chunk = &dummy_head;
-  // Do not split when value size is large or there is no compression.
-  size_t predicted_chunk_size{0};
-  size_t actual_chunk_size{0};
-  size_t tmp_size{0};
-  while (src_size > 0) {
-    predicted_chunk_size = sizeof(CacheValueChunk) - 1 + src_size;
-    auto upper =
-        std::upper_bound(malloc_bin_sizes_.begin(), malloc_bin_sizes_.end(),
-                         predicted_chunk_size);
-    // Do not split when value size is too small, too large, close to a bin
-    // size, or there is no compression.
-    if (upper == malloc_bin_sizes_.begin() ||
-        upper == malloc_bin_sizes_.end() ||
-        *upper - predicted_chunk_size < malloc_bin_sizes_.front() ||
-        compression_type == kNoCompression) {
-      tmp_size = predicted_chunk_size;
-    } else {
-      tmp_size = *(--upper);
-    }
-
-    CacheValueChunk* new_chunk =
-        reinterpret_cast<CacheValueChunk*>(new char[tmp_size]);
-    current_chunk->next = new_chunk;
-    current_chunk = current_chunk->next;
-    actual_chunk_size = tmp_size - sizeof(CacheValueChunk) + 1;
-    memcpy(current_chunk->data, src_ptr, actual_chunk_size);
-    current_chunk->size = actual_chunk_size;
-    src_ptr += actual_chunk_size;
-    src_size -= actual_chunk_size;
-    charge += tmp_size;
-  }
-  current_chunk->next = nullptr;
-
-  return dummy_head.next;
-}
-
-CacheAllocationPtr CompressedSecondaryCache::MergeChunksIntoValue(
-    const void* chunks_head, size_t& charge) {
-  const CacheValueChunk* head =
-      reinterpret_cast<const CacheValueChunk*>(chunks_head);
-  const CacheValueChunk* current_chunk = head;
-  charge = 0;
-  while (current_chunk != nullptr) {
-    charge += current_chunk->size;
-    current_chunk = current_chunk->next;
-  }
-
-  CacheAllocationPtr ptr =
-      AllocateBlock(charge, cache_options_.memory_allocator.get());
-  current_chunk = head;
-  size_t pos{0};
-  while (current_chunk != nullptr) {
-    memcpy(ptr.get() + pos, current_chunk->data, current_chunk->size);
-    pos += current_chunk->size;
-    current_chunk = current_chunk->next;
-  }
-
-  return ptr;
-}
-
-const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
-    bool enable_custom_split_merge) const {
-  if (enable_custom_split_merge) {
-    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 {
-    static const Cache::CacheItemHelper kHelper{
-        CacheEntryRole::kMisc,
-        [](Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
-          delete static_cast<CacheAllocationPtr*>(obj);
-          obj = nullptr;
-        }};
-    return &kHelper;
-  }
-}
-
-std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge) {
-  return std::make_shared<CompressedSecondaryCache>(
-      capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      low_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-      metadata_charge_policy, compression_type, compress_format_version,
-      enable_custom_split_merge);
-}
-
-std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
-    const CompressedSecondaryCacheOptions& opts) {
-  // The secondary_cache is disabled for this LRUCache instance.
-  assert(opts.secondary_cache == nullptr);
-  return NewCompressedSecondaryCache(
-      opts.capacity, opts.num_shard_bits, opts.strict_capacity_limit,
-      opts.high_pri_pool_ratio, opts.low_pri_pool_ratio, opts.memory_allocator,
-      opts.use_adaptive_mutex, opts.metadata_charge_policy,
-      opts.compression_type, opts.compress_format_version,
-      opts.enable_custom_split_merge);
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.h

@@ -1,140 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <array>
-#include <cstddef>
-#include <memory>
-
-#include "cache/lru_cache.h"
-#include "memory/memory_allocator.h"
-#include "rocksdb/secondary_cache.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-#include "util/compression.h"
-#include "util/mutexlock.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
- public:
-  CompressedSecondaryCacheResultHandle(Cache::ObjectPtr value, size_t size)
-      : value_(value), size_(size) {}
-  ~CompressedSecondaryCacheResultHandle() override = default;
-
-  CompressedSecondaryCacheResultHandle(
-      const CompressedSecondaryCacheResultHandle&) = delete;
-  CompressedSecondaryCacheResultHandle& operator=(
-      const CompressedSecondaryCacheResultHandle&) = delete;
-
-  bool IsReady() override { return true; }
-
-  void Wait() override {}
-
-  Cache::ObjectPtr Value() override { return value_; }
-
-  size_t Size() override { return size_; }
-
- private:
-  Cache::ObjectPtr value_;
-  size_t size_;
-};
-
-// The CompressedSecondaryCache is a concrete implementation of
-// rocksdb::SecondaryCache.
-//
-// When a block is found from CompressedSecondaryCache::Lookup, we check whether
-// there is a dummy block with the same key in the primary cache.
-// 1. If the dummy block exits, we erase the block from
-//    CompressedSecondaryCache and insert it into the primary cache.
-// 2. If not, we just insert a dummy block into the primary cache
-//    (charging the actual size of the block) and don not erase the block from
-//    CompressedSecondaryCache. A standalone handle is returned to the caller.
-//
-// When a block is evicted from the primary cache, we check whether
-// there is a dummy block with the same key in CompressedSecondaryCache.
-// 1. If the dummy block exits, the block is inserted into
-//    CompressedSecondaryCache.
-// 2. If not, we just insert a dummy block (size 0) in CompressedSecondaryCache.
-//
-// Users can also cast a pointer to CompressedSecondaryCache and call methods on
-// it directly, especially custom methods that may be added
-// in the future.  For example -
-// std::unique_ptr<rocksdb::SecondaryCache> cache =
-//      NewCompressedSecondaryCache(opts);
-// static_cast<CompressedSecondaryCache*>(cache.get())->Erase(key);
-
-class CompressedSecondaryCache : public SecondaryCache {
- public:
-  CompressedSecondaryCache(
-      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      double high_pri_pool_ratio, double low_pri_pool_ratio,
-      std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-      bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
-      CacheMetadataChargePolicy metadata_charge_policy =
-          kDefaultCacheMetadataChargePolicy,
-      CompressionType compression_type = CompressionType::kLZ4Compression,
-      uint32_t compress_format_version = 2,
-      bool enable_custom_split_merge = false);
-  ~CompressedSecondaryCache() override;
-
-  const char* Name() const override { return "CompressedSecondaryCache"; }
-
-  Status Insert(const Slice& key, Cache::ObjectPtr value,
-                const Cache::CacheItemHelper* helper) override;
-
-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      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; }
-
-  void Erase(const Slice& key) override;
-
-  void WaitAll(std::vector<SecondaryCacheResultHandle*> /*handles*/) override {}
-
-  Status SetCapacity(size_t capacity) override;
-
-  Status GetCapacity(size_t& capacity) override;
-
-  std::string GetPrintableOptions() const override;
-
- private:
-  friend class CompressedSecondaryCacheTest;
-  static constexpr std::array<uint16_t, 8> malloc_bin_sizes_{
-      128, 256, 512, 1024, 2048, 4096, 8192, 16384};
-
-  struct CacheValueChunk {
-    // TODO try "CacheAllocationPtr next;".
-    CacheValueChunk* next;
-    size_t size;
-    // Beginning of the chunk data (MUST BE THE LAST FIELD IN THIS STRUCT!)
-    char data[1];
-
-    void Free() { delete[] reinterpret_cast<char*>(this); }
-  };
-
-  // Split value into chunks to better fit into jemalloc bins. The chunks
-  // are stored in CacheValueChunk and extra charge is needed for each chunk,
-  // so the cache charge is recalculated here.
-  CacheValueChunk* SplitValueIntoChunks(const Slice& value,
-                                        CompressionType compression_type,
-                                        size_t& charge);
-
-  // After merging chunks, the extra charge for each chunk is removed, so
-  // the charge is recalculated.
-  CacheAllocationPtr MergeChunksIntoValue(const void* chunks_head,
-                                          size_t& charge);
-
-  // 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_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache_test.cc

@@ -1,951 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "cache/compressed_secondary_cache.h"
-
-#include <iterator>
-#include <memory>
-#include <tuple>
-
-#include "memory/jemalloc_nodump_allocator.h"
-#include "rocksdb/convenience.h"
-#include "test_util/testharness.h"
-#include "test_util/testutil.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class CompressedSecondaryCacheTest : public testing::Test,
-                                     public Cache::CreateContext {
- public:
-  CompressedSecondaryCacheTest() : fail_create_(false) {}
-  ~CompressedSecondaryCacheTest() override = default;
-
- protected:
-  class TestItem {
-   public:
-    TestItem(const char* buf, size_t size) : buf_(new char[size]), size_(size) {
-      memcpy(buf_.get(), buf, size);
-    }
-    ~TestItem() = default;
-
-    char* Buf() { return buf_.get(); }
-    [[nodiscard]] size_t Size() const { return size_; }
-
-   private:
-    std::unique_ptr<char[]> buf_;
-    size_t size_;
-  };
-
-  static size_t SizeCallback(Cache::ObjectPtr obj) {
-    return static_cast<TestItem*>(obj)->Size();
-  }
-
-  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);
-    memcpy(out, buf, length);
-    return Status::OK();
-  }
-
-  static void DeletionCallback(Cache::ObjectPtr obj,
-                               MemoryAllocator* /*alloc*/) {
-    delete static_cast<TestItem*>(obj);
-    obj = nullptr;
-  }
-
-  static Status SaveToCallbackFail(Cache::ObjectPtr /*obj*/, size_t /*offset*/,
-                                   size_t /*size*/, char* /*out*/) {
-    return Status::NotSupported();
-  }
-
-  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 = 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; }
-
-  void BasicTestHelper(std::shared_ptr<SecondaryCache> sec_cache,
-                       bool sec_cache_is_compressed) {
-    get_perf_context()->Reset();
-    bool is_in_sec_cache{true};
-    // Lookup an non-existent key.
-    std::unique_ptr<SecondaryCacheResultHandle> handle0 = sec_cache->Lookup(
-        "k0", &kHelper, this, true, /*advise_erase=*/true, is_in_sec_cache);
-    ASSERT_EQ(handle0, nullptr);
-
-    Random rnd(301);
-    // Insert and Lookup the item k1 for the first time.
-    std::string str1(rnd.RandomString(1000));
-    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, &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", &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, &kHelper));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 1);
-
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_2 = sec_cache->Lookup(
-        "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) {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes,
-                1000);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                1007);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-
-    std::unique_ptr<TestItem> val1 =
-        std::unique_ptr<TestItem>(static_cast<TestItem*>(handle1_2->Value()));
-    ASSERT_NE(val1, nullptr);
-    ASSERT_EQ(memcmp(val1->Buf(), item1.Buf(), item1.Size()), 0);
-
-    // Lookup the item k1 again.
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_3 = sec_cache->Lookup(
-        "k1", &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, &kHelper));
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_dummy_count, 2);
-    std::unique_ptr<SecondaryCacheResultHandle> handle2_1 = sec_cache->Lookup(
-        "k2", &kHelper, this, true, /*advise_erase=*/false, is_in_sec_cache);
-    ASSERT_EQ(handle2_1, nullptr);
-
-    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,
-                2000);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                2014);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-    std::unique_ptr<SecondaryCacheResultHandle> handle2_2 = sec_cache->Lookup(
-        "k2", &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()));
-    ASSERT_NE(val2, nullptr);
-    ASSERT_EQ(memcmp(val2->Buf(), item2.Buf(), item2.Size()), 0);
-
-    std::vector<SecondaryCacheResultHandle*> handles = {handle1_2.get(),
-                                                        handle2_2.get()};
-    sec_cache->WaitAll(handles);
-
-    sec_cache.reset();
-  }
-
-  void BasicTest(bool sec_cache_is_compressed, bool use_jemalloc) {
-    CompressedSecondaryCacheOptions opts;
-    opts.capacity = 2048;
-    opts.num_shard_bits = 0;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        opts.compression_type = CompressionType::kNoCompression;
-        sec_cache_is_compressed = false;
-      }
-    } else {
-      opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    if (use_jemalloc) {
-      JemallocAllocatorOptions jopts;
-      std::shared_ptr<MemoryAllocator> allocator;
-      std::string msg;
-      if (JemallocNodumpAllocator::IsSupported(&msg)) {
-        Status s = NewJemallocNodumpAllocator(jopts, &allocator);
-        if (s.ok()) {
-          opts.memory_allocator = allocator;
-        }
-      } else {
-        ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-      }
-    }
-    std::shared_ptr<SecondaryCache> sec_cache =
-        NewCompressedSecondaryCache(opts);
-
-    BasicTestHelper(sec_cache, sec_cache_is_compressed);
-  }
-
-  void FailsTest(bool sec_cache_is_compressed) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 1100;
-    secondary_cache_opts.num_shard_bits = 0;
-    std::shared_ptr<SecondaryCache> sec_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-
-    // Insert and Lookup the first item.
-    Random rnd(301);
-    std::string str1(rnd.RandomString(1000));
-    TestItem item1(str1.data(), str1.length());
-    // Insert a dummy handle.
-    ASSERT_OK(sec_cache->Insert("k1", &item1, &kHelper));
-    // Insert k1.
-    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, &kHelper));
-    bool is_in_sec_cache{false};
-    std::unique_ptr<SecondaryCacheResultHandle> handle1 = sec_cache->Lookup(
-        "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, &kHelper));
-    std::unique_ptr<SecondaryCacheResultHandle> handle2 = sec_cache->Lookup(
-        "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()));
-    ASSERT_NE(val2, nullptr);
-    ASSERT_EQ(memcmp(val2->Buf(), item2.Buf(), item2.Size()), 0);
-
-    // Insert k1 again and a dummy handle is inserted.
-    ASSERT_OK(sec_cache->Insert("k1", &item1, &kHelper));
-
-    std::unique_ptr<SecondaryCacheResultHandle> handle1_1 = sec_cache->Lookup(
-        "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", &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, &kHelperFail));
-    ASSERT_NOK(sec_cache->Insert("k3", &item3, &kHelperFail));
-
-    sec_cache.reset();
-  }
-
-  void BasicIntegrationTest(bool sec_cache_is_compressed,
-                            bool enable_custom_split_merge) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-        sec_cache_is_compressed = false;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 6000;
-    secondary_cache_opts.num_shard_bits = 0;
-    secondary_cache_opts.enable_custom_split_merge = enable_custom_split_merge;
-    std::shared_ptr<SecondaryCache> secondary_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-    LRUCacheOptions lru_cache_opts(
-        /*_capacity =*/1300, /*_num_shard_bits =*/0,
-        /*_strict_capacity_limit =*/false, /*_high_pri_pool_ratio =*/0.5,
-        /*_memory_allocator =*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio =*/0.0);
-    lru_cache_opts.secondary_cache = secondary_cache;
-    std::shared_ptr<Cache> cache = NewLRUCache(lru_cache_opts);
-    std::shared_ptr<Statistics> stats = CreateDBStatistics();
-
-    get_perf_context()->Reset();
-    Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    auto item1_1 = new TestItem(str1.data(), 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, &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);
-
-    std::string str3 = rnd.RandomString(1024);
-    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, &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, &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, &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,
-                str1.length());
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                1008);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-
-    // After this Insert, primary cache contains k3 and secondary cache contains
-    // k1's item and k2's item.
-    auto item3_2 = new TestItem(str3.data(), 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,
-                str1.length() + str2.length());
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes,
-                2027);
-    } else {
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_uncompressed_bytes, 0);
-      ASSERT_EQ(get_perf_context()->compressed_sec_cache_compressed_bytes, 0);
-    }
-
-    Cache::Handle* handle;
-    handle = cache->Lookup("k3", &kHelper, this, Cache::Priority::LOW, true,
-                           stats.get());
-    ASSERT_NE(handle, nullptr);
-    auto val3 = static_cast<TestItem*>(cache->Value(handle));
-    ASSERT_NE(val3, nullptr);
-    ASSERT_EQ(memcmp(val3->Buf(), item3_2->Buf(), item3_2->Size()), 0);
-    cache->Release(handle);
-
-    // Lookup an non-existent key.
-    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", &kHelper, this, Cache::Priority::LOW, true,
-                           stats.get());
-    ASSERT_NE(handle, nullptr);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
-    auto val1_1 = static_cast<TestItem*>(cache->Value(handle));
-    ASSERT_NE(val1_1, nullptr);
-    ASSERT_EQ(memcmp(val1_1->Buf(), str1.data(), str1.size()), 0);
-    cache->Release(handle);
-
-    // 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", &kHelper, this, Cache::Priority::LOW, true,
-                           stats.get());
-    ASSERT_NE(handle, nullptr);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 1);
-    ASSERT_EQ(get_perf_context()->compressed_sec_cache_insert_real_count, 3);
-    cache->Release(handle);
-
-    // k2 is still in secondary cache.
-    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);
-    cache->Release(handle);
-
-    // Testing SetCapacity().
-    ASSERT_OK(secondary_cache->SetCapacity(0));
-    handle = cache->Lookup("k3", &kHelper, this, Cache::Priority::LOW, true,
-                           stats.get());
-    ASSERT_EQ(handle, nullptr);
-
-    ASSERT_OK(secondary_cache->SetCapacity(7000));
-    size_t capacity;
-    ASSERT_OK(secondary_cache->GetCapacity(capacity));
-    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, &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, &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, &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, &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", &kHelper, this, Cache::Priority::LOW, true,
-                           stats.get());
-
-    ASSERT_NE(handle, nullptr);
-    cache->Release(handle);
-    ASSERT_EQ(get_perf_context()->block_cache_standalone_handle_count, 3);
-
-    cache.reset();
-    secondary_cache.reset();
-  }
-
-  void BasicIntegrationFailTest(bool sec_cache_is_compressed) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 6000;
-    secondary_cache_opts.num_shard_bits = 0;
-    std::shared_ptr<SecondaryCache> secondary_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
-    opts.secondary_cache = secondary_cache;
-    std::shared_ptr<Cache> cache = NewLRUCache(opts);
-
-    Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    auto item1 = std::make_unique<TestItem>(str1.data(), 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, this, Cache::Priority::LOW, true);
-    ASSERT_EQ(handle, nullptr);
-    handle = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, false);
-    ASSERT_EQ(handle, nullptr);
-
-    cache.reset();
-    secondary_cache.reset();
-  }
-
-  void IntegrationSaveFailTest(bool sec_cache_is_compressed) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 6000;
-    secondary_cache_opts.num_shard_bits = 0;
-
-    std::shared_ptr<SecondaryCache> secondary_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
-    opts.secondary_cache = secondary_cache;
-    std::shared_ptr<Cache> cache = NewLRUCache(opts);
-
-    Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    auto item1 = new TestItem(str1.data(), 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, &kHelperFail, str2.length()));
-
-    Cache::Handle* handle;
-    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", &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", &kHelperFail, this, Cache::Priority::LOW, true);
-    ASSERT_NE(handle, nullptr);
-    cache->Release(handle);
-
-    cache.reset();
-    secondary_cache.reset();
-  }
-
-  void IntegrationCreateFailTest(bool sec_cache_is_compressed) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 6000;
-    secondary_cache_opts.num_shard_bits = 0;
-
-    std::shared_ptr<SecondaryCache> secondary_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
-    opts.secondary_cache = secondary_cache;
-    std::shared_ptr<Cache> cache = NewLRUCache(opts);
-
-    Random rnd(301);
-    std::string str1 = rnd.RandomString(1001);
-    auto item1 = new TestItem(str1.data(), 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, &kHelper, str2.length()));
-
-    Cache::Handle* handle;
-    SetFailCreate(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", &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", &kHelper, this, Cache::Priority::LOW, true);
-    ASSERT_NE(handle, nullptr);
-    cache->Release(handle);
-
-    cache.reset();
-    secondary_cache.reset();
-  }
-
-  void IntegrationFullCapacityTest(bool sec_cache_is_compressed) {
-    CompressedSecondaryCacheOptions secondary_cache_opts;
-
-    if (sec_cache_is_compressed) {
-      if (!LZ4_Supported()) {
-        ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-        secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-      }
-    } else {
-      secondary_cache_opts.compression_type = CompressionType::kNoCompression;
-    }
-
-    secondary_cache_opts.capacity = 6000;
-    secondary_cache_opts.num_shard_bits = 0;
-
-    std::shared_ptr<SecondaryCache> secondary_cache =
-        NewCompressedSecondaryCache(secondary_cache_opts);
-
-    LRUCacheOptions opts(
-        /*_capacity=*/1300, /*_num_shard_bits=*/0,
-        /*_strict_capacity_limit=*/false, /*_high_pri_pool_ratio=*/0.5,
-        /*_memory_allocator=*/nullptr, kDefaultToAdaptiveMutex,
-        kDefaultCacheMetadataChargePolicy, /*_low_pri_pool_ratio=*/0.0);
-    opts.secondary_cache = secondary_cache;
-    std::shared_ptr<Cache> cache = NewLRUCache(opts);
-
-    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, &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, &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, &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, &kHelper, str2.length()));
-
-    Cache::Handle* handle2;
-    handle2 = cache->Lookup("k2", &kHelper, this, Cache::Priority::LOW, true);
-    ASSERT_NE(handle2, nullptr);
-    cache->Release(handle2);
-
-    // k1 promotion should fail because cache is at capacity and
-    // strict_capacity_limit is true, but the lookup should still succeed.
-    // A k1's dummy item is inserted into primary cache.
-    Cache::Handle* handle1;
-    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", &kHelper, this, Cache::Priority::LOW, true);
-    ASSERT_NE(handle2, nullptr);
-    cache->Release(handle2);
-
-    cache.reset();
-    secondary_cache.reset();
-  }
-
-  void SplitValueIntoChunksTest() {
-    JemallocAllocatorOptions jopts;
-    std::shared_ptr<MemoryAllocator> allocator;
-    std::string msg;
-    if (JemallocNodumpAllocator::IsSupported(&msg)) {
-      Status s = NewJemallocNodumpAllocator(jopts, &allocator);
-      if (!s.ok()) {
-        ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-      }
-    } else {
-      ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-    }
-
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
-    Random rnd(301);
-    // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
-    size_t str_size{8500};
-    std::string str = rnd.RandomString(static_cast<int>(str_size));
-    size_t charge{0};
-    CacheValueChunk* chunks_head =
-        sec_cache->SplitValueIntoChunks(str, kLZ4Compression, charge);
-    ASSERT_EQ(charge, str_size + 3 * (sizeof(CacheValueChunk) - 1));
-
-    CacheValueChunk* current_chunk = chunks_head;
-    ASSERT_EQ(current_chunk->size, 8192 - sizeof(CacheValueChunk) + 1);
-    current_chunk = current_chunk->next;
-    ASSERT_EQ(current_chunk->size, 256 - sizeof(CacheValueChunk) + 1);
-    current_chunk = current_chunk->next;
-    ASSERT_EQ(current_chunk->size, 98);
-
-    sec_cache->GetHelper(true)->del_cb(chunks_head, /*alloc*/ nullptr);
-  }
-
-  void MergeChunksIntoValueTest() {
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    Random rnd(301);
-    size_t size1{2048};
-    std::string str1 = rnd.RandomString(static_cast<int>(size1));
-    CacheValueChunk* current_chunk = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size1]);
-    CacheValueChunk* chunks_head = current_chunk;
-    memcpy(current_chunk->data, str1.data(), size1);
-    current_chunk->size = size1;
-
-    size_t size2{256};
-    std::string str2 = rnd.RandomString(static_cast<int>(size2));
-    current_chunk->next = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size2]);
-    current_chunk = current_chunk->next;
-    memcpy(current_chunk->data, str2.data(), size2);
-    current_chunk->size = size2;
-
-    size_t size3{31};
-    std::string str3 = rnd.RandomString(static_cast<int>(size3));
-    current_chunk->next = reinterpret_cast<CacheValueChunk*>(
-        new char[sizeof(CacheValueChunk) - 1 + size3]);
-    current_chunk = current_chunk->next;
-    memcpy(current_chunk->data, str3.data(), size3);
-    current_chunk->size = size3;
-    current_chunk->next = nullptr;
-
-    std::string str = str1 + str2 + str3;
-
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0);
-    size_t charge{0};
-    CacheAllocationPtr value =
-        sec_cache->MergeChunksIntoValue(chunks_head, charge);
-    ASSERT_EQ(charge, size1 + size2 + size3);
-    std::string value_str{value.get(), charge};
-    ASSERT_EQ(strcmp(value_str.data(), str.data()), 0);
-
-    while (chunks_head != nullptr) {
-      CacheValueChunk* tmp_chunk = chunks_head;
-      chunks_head = chunks_head->next;
-      tmp_chunk->Free();
-    }
-  }
-
-  void SplictValueAndMergeChunksTest() {
-    JemallocAllocatorOptions jopts;
-    std::shared_ptr<MemoryAllocator> allocator;
-    std::string msg;
-    if (JemallocNodumpAllocator::IsSupported(&msg)) {
-      Status s = NewJemallocNodumpAllocator(jopts, &allocator);
-      if (!s.ok()) {
-        ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-      }
-    } else {
-      ROCKSDB_GTEST_BYPASS("JEMALLOC not supported");
-    }
-
-    using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
-    std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
-    Random rnd(301);
-    // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
-    size_t str_size{8500};
-    std::string str = rnd.RandomString(static_cast<int>(str_size));
-    size_t charge{0};
-    CacheValueChunk* chunks_head =
-        sec_cache->SplitValueIntoChunks(str, kLZ4Compression, charge);
-    ASSERT_EQ(charge, str_size + 3 * (sizeof(CacheValueChunk) - 1));
-
-    CacheAllocationPtr value =
-        sec_cache->MergeChunksIntoValue(chunks_head, charge);
-    ASSERT_EQ(charge, str_size);
-    std::string value_str{value.get(), charge};
-    ASSERT_EQ(strcmp(value_str.data(), str.data()), 0);
-
-    sec_cache->GetHelper(true)->del_cb(chunks_head, /*alloc*/ nullptr);
-  }
-
- private:
-  bool fail_create_;
-};
-
-class CompressedSecCacheTestWithCompressAndAllocatorParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  CompressedSecCacheTestWithCompressAndAllocatorParam() {
-    sec_cache_is_compressed_ = std::get<0>(GetParam());
-    use_jemalloc_ = std::get<1>(GetParam());
-  }
-  bool sec_cache_is_compressed_;
-  bool use_jemalloc_;
-};
-
-TEST_P(CompressedSecCacheTestWithCompressAndAllocatorParam, BasicTes) {
-  BasicTest(sec_cache_is_compressed_, use_jemalloc_);
-}
-
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecCacheTestWithCompressAndAllocatorParam,
-                        ::testing::Combine(testing::Bool(), testing::Bool()));
-
-class CompressedSecondaryCacheTestWithCompressionParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<bool> {
- public:
-  CompressedSecondaryCacheTestWithCompressionParam() {
-    sec_cache_is_compressed_ = GetParam();
-  }
-  bool sec_cache_is_compressed_;
-};
-
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam, BasicTestFromString) {
-  std::shared_ptr<SecondaryCache> sec_cache{nullptr};
-  std::string sec_cache_uri;
-  if (sec_cache_is_compressed_) {
-    if (LZ4_Supported()) {
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kLZ4Compression;"
-          "compress_format_version=2";
-    } else {
-      ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kNoCompression";
-      sec_cache_is_compressed_ = false;
-    }
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  } else {
-    sec_cache_uri =
-        "compressed_secondary_cache://"
-        "capacity=2048;num_shard_bits=0;compression_type=kNoCompression";
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  }
-  BasicTestHelper(sec_cache, sec_cache_is_compressed_);
-}
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       BasicTestFromStringWithSplit) {
-  std::shared_ptr<SecondaryCache> sec_cache{nullptr};
-  std::string sec_cache_uri;
-  if (sec_cache_is_compressed_) {
-    if (LZ4_Supported()) {
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kLZ4Compression;"
-          "compress_format_version=2;enable_custom_split_merge=true";
-    } else {
-      ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-      sec_cache_uri =
-          "compressed_secondary_cache://"
-          "capacity=2048;num_shard_bits=0;compression_type=kNoCompression;"
-          "enable_custom_split_merge=true";
-      sec_cache_is_compressed_ = false;
-    }
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  } else {
-    sec_cache_uri =
-        "compressed_secondary_cache://"
-        "capacity=2048;num_shard_bits=0;compression_type=kNoCompression;"
-        "enable_custom_split_merge=true";
-    Status s = SecondaryCache::CreateFromString(ConfigOptions(), sec_cache_uri,
-                                                &sec_cache);
-    EXPECT_OK(s);
-  }
-  BasicTestHelper(sec_cache, sec_cache_is_compressed_);
-}
-
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam, FailsTest) {
-  FailsTest(sec_cache_is_compressed_);
-}
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       BasicIntegrationFailTest) {
-  BasicIntegrationFailTest(sec_cache_is_compressed_);
-}
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationSaveFailTest) {
-  IntegrationSaveFailTest(sec_cache_is_compressed_);
-}
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationCreateFailTest) {
-  IntegrationCreateFailTest(sec_cache_is_compressed_);
-}
-
-TEST_P(CompressedSecondaryCacheTestWithCompressionParam,
-       IntegrationFullCapacityTest) {
-  IntegrationFullCapacityTest(sec_cache_is_compressed_);
-}
-
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecondaryCacheTestWithCompressionParam,
-                        testing::Bool());
-
-class CompressedSecCacheTestWithCompressAndSplitParam
-    : public CompressedSecondaryCacheTest,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
- public:
-  CompressedSecCacheTestWithCompressAndSplitParam() {
-    sec_cache_is_compressed_ = std::get<0>(GetParam());
-    enable_custom_split_merge_ = std::get<1>(GetParam());
-  }
-  bool sec_cache_is_compressed_;
-  bool enable_custom_split_merge_;
-};
-
-TEST_P(CompressedSecCacheTestWithCompressAndSplitParam, BasicIntegrationTest) {
-  BasicIntegrationTest(sec_cache_is_compressed_, enable_custom_split_merge_);
-}
-
-INSTANTIATE_TEST_CASE_P(CompressedSecCacheTests,
-                        CompressedSecCacheTestWithCompressAndSplitParam,
-                        ::testing::Combine(testing::Bool(), testing::Bool()));
-
-TEST_F(CompressedSecondaryCacheTest, SplitValueIntoChunksTest) {
-  SplitValueIntoChunksTest();
-}
-
-TEST_F(CompressedSecondaryCacheTest, MergeChunksIntoValueTest) {
-  MergeChunksIntoValueTest();
-}
-
-TEST_F(CompressedSecondaryCacheTest, SplictValueAndMergeChunksTest) {
-  SplictValueAndMergeChunksTest();
-}
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

cache/lru_cache.h

@@ -13,15 +13,12 @@
 
 #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"
 #include "util/autovector.h"
-#include "util/distributed_mutex.h"
 
 namespace ROCKSDB_NAMESPACE {
-namespace lru_cache {
 
 // LRU cache implementation. This class is not thread-safe.
 
@@ -39,18 +36,27 @@ namespace lru_cache {
 //    (refs == 0 && in_cache == true)
 // 3. Referenced externally AND not in hash table.
 //    In that case the entry is not in the LRU list and not in hash table.
-//    The entry must be freed if refs becomes 0 in this state.
+//    The entry can be freed when refs becomes 0.
 //    (refs >= 1 && in_cache == false)
-// If you call LRUCacheShard::Release enough times on an entry in state 1, it
-// will go into state 2. To move from state 1 to state 3, either call
-// LRUCacheShard::Erase or LRUCacheShard::Insert with the same key (but
-// possibly different value). To move from state 2 to state 1, use
-// LRUCacheShard::Lookup.
-// While refs > 0, public properties like value and deleter must not change.
+//
+// All newly created LRUHandles are in state 1. If you call
+// LRUCacheShard::Release on entry in state 1, it will go into state 2.
+// To move from state 1 to state 3, either call LRUCacheShard::Erase or
+// LRUCacheShard::Insert with the same key (but possibly different value).
+// To move from state 2 to state 1, use LRUCacheShard::Lookup.
+// Before destruction, make sure that no handles are in state 1. This means
+// that any successful LRUCacheShard::Lookup/LRUCacheShard::Insert have a
+// matching LRUCache::Release (to move into state 2) or LRUCacheShard::Erase
+// (to move into state 3).
 
 struct LRUHandle {
-  Cache::ObjectPtr value;
-  const Cache::CacheItemHelper* helper;
+  void* value;
+  union Info {
+    Info() {}
+    ~Info() {}
+    Cache::DeleterFn deleter;
+    const ShardedCache::CacheItemHelper* helper;
+  } info_;
   // An entry is not added to the LRUHandleTable until the secondary cache
   // lookup is complete, so its safe to have this union.
   union {
@@ -59,52 +65,45 @@ struct LRUHandle {
   };
   LRUHandle* next;
   LRUHandle* prev;
-  size_t total_charge;  // TODO(opt): Only allow uint32_t?
+  size_t charge;  // TODO(opt): Only allow uint32_t?
   size_t key_length;
   // The hash of key(). Used for fast sharding and comparisons.
   uint32_t hash;
   // The number of external refs to this entry. The cache itself is not counted.
   uint32_t refs;
 
-  // Mutable flags - access controlled by mutex
-  // The m_ and M_ prefixes (and im_ and IM_ later) are to hopefully avoid
-  // checking an M_ flag on im_flags or an IM_ flag on m_flags.
-  uint8_t m_flags;
-  enum MFlags : uint8_t {
+  enum Flags : uint8_t {
     // Whether this entry is referenced by the hash table.
-    M_IN_CACHE = (1 << 0),
-    // Whether this entry has had any lookups (hits).
-    M_HAS_HIT = (1 << 1),
+    IN_CACHE = (1 << 0),
+    // Whether this entry is high priority entry.
+    IS_HIGH_PRI = (1 << 1),
     // Whether this entry is in high-pri pool.
-    M_IN_HIGH_PRI_POOL = (1 << 2),
-    // Whether this entry is in low-pri pool.
-    M_IN_LOW_PRI_POOL = (1 << 3),
+    IN_HIGH_PRI_POOL = (1 << 2),
+    // Whether this entry has had any lookups (hits).
+    HAS_HIT = (1 << 3),
+    // Can this be inserted into the secondary cache
+    IS_SECONDARY_CACHE_COMPATIBLE = (1 << 4),
+    // Is the handle still being read from a lower tier
+    IS_PENDING = (1 << 5),
+    // Has the item been promoted from a lower tier
+    IS_PROMOTED = (1 << 6),
   };
 
-  // "Immutable" flags - only set in single-threaded context and then
-  // can be accessed without mutex
-  uint8_t im_flags;
-  enum ImFlags : uint8_t {
-    // Whether this entry is high priority entry.
-    IM_IS_HIGH_PRI = (1 << 0),
-    // Whether this entry is low priority entry.
-    IM_IS_LOW_PRI = (1 << 1),
-    // Is the handle still being read from a lower tier.
-    IM_IS_PENDING = (1 << 2),
-    // Whether this handle is still in a lower tier
-    IM_IS_IN_SECONDARY_CACHE = (1 << 3),
-    // Marks result handles that should not be inserted into cache
-    IM_IS_STANDALONE = (1 << 4),
-  };
+  uint8_t flags;
+
+#ifdef __SANITIZE_THREAD__
+  // TSAN can report a false data race on flags, where one thread is writing
+  // to one of the mutable bits and another thread is reading this immutable
+  // bit. So precisely suppress that TSAN warning, we separate out this bit
+  // during TSAN runs.
+  bool is_secondary_cache_compatible_for_tsan;
+#endif  // __SANITIZE_THREAD__
 
   // Beginning of the key (MUST BE THE LAST FIELD IN THIS STRUCT!)
   char key_data[1];
 
   Slice key() const { return Slice(key_data, key_length); }
 
-  // For HandleImpl concept
-  uint32_t GetHash() const { return hash; }
-
   // Increase the reference count by 1.
   void Ref() { refs++; }
 
@@ -118,126 +117,110 @@ struct LRUHandle {
   // Return true if there are external refs, false otherwise.
   bool HasRefs() const { return refs > 0; }
 
-  bool InCache() const { return m_flags & M_IN_CACHE; }
-  bool IsHighPri() const { return im_flags & IM_IS_HIGH_PRI; }
-  bool InHighPriPool() const { return m_flags & M_IN_HIGH_PRI_POOL; }
-  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 helper->size_cb != nullptr; }
-  bool IsPending() const { return im_flags & IM_IS_PENDING; }
-  bool IsInSecondaryCache() const {
-    return im_flags & IM_IS_IN_SECONDARY_CACHE;
+  bool InCache() const { return flags & IN_CACHE; }
+  bool IsHighPri() const { return flags & IS_HIGH_PRI; }
+  bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
+  bool HasHit() const { return flags & HAS_HIT; }
+  bool IsSecondaryCacheCompatible() const {
+#ifdef __SANITIZE_THREAD__
+    return is_secondary_cache_compatible_for_tsan;
+#else
+    return flags & IS_SECONDARY_CACHE_COMPATIBLE;
+#endif  // __SANITIZE_THREAD__
   }
-  bool IsStandalone() const { return im_flags & IM_IS_STANDALONE; }
+  bool IsPending() const { return flags & IS_PENDING; }
+  bool IsPromoted() const { return flags & IS_PROMOTED; }
 
   void SetInCache(bool in_cache) {
     if (in_cache) {
-      m_flags |= M_IN_CACHE;
+      flags |= IN_CACHE;
     } else {
-      m_flags &= ~M_IN_CACHE;
+      flags &= ~IN_CACHE;
     }
   }
 
   void SetPriority(Cache::Priority priority) {
     if (priority == Cache::Priority::HIGH) {
-      im_flags |= IM_IS_HIGH_PRI;
-      im_flags &= ~IM_IS_LOW_PRI;
-    } else if (priority == Cache::Priority::LOW) {
-      im_flags &= ~IM_IS_HIGH_PRI;
-      im_flags |= IM_IS_LOW_PRI;
+      flags |= IS_HIGH_PRI;
     } else {
-      im_flags &= ~IM_IS_HIGH_PRI;
-      im_flags &= ~IM_IS_LOW_PRI;
+      flags &= ~IS_HIGH_PRI;
     }
   }
 
   void SetInHighPriPool(bool in_high_pri_pool) {
     if (in_high_pri_pool) {
-      m_flags |= M_IN_HIGH_PRI_POOL;
+      flags |= IN_HIGH_PRI_POOL;
     } else {
-      m_flags &= ~M_IN_HIGH_PRI_POOL;
+      flags &= ~IN_HIGH_PRI_POOL;
     }
   }
 
-  void SetInLowPriPool(bool in_low_pri_pool) {
-    if (in_low_pri_pool) {
-      m_flags |= M_IN_LOW_PRI_POOL;
+  void SetHit() { flags |= HAS_HIT; }
+
+  void SetSecondaryCacheCompatible(bool compat) {
+    if (compat) {
+      flags |= IS_SECONDARY_CACHE_COMPATIBLE;
     } else {
-      m_flags &= ~M_IN_LOW_PRI_POOL;
+      flags &= ~IS_SECONDARY_CACHE_COMPATIBLE;
+    }
+#ifdef __SANITIZE_THREAD__
+    is_secondary_cache_compatible_for_tsan = compat;
+#endif  // __SANITIZE_THREAD__
+  }
+
+  void SetIncomplete(bool incomp) {
+    if (incomp) {
+      flags |= IS_PENDING;
+    } else {
+      flags &= ~IS_PENDING;
     }
   }
 
-  void SetHit() { m_flags |= M_HAS_HIT; }
-
-  void SetIsPending(bool pending) {
-    if (pending) {
-      im_flags |= IM_IS_PENDING;
+  void SetPromoted(bool promoted) {
+    if (promoted) {
+      flags |= IS_PROMOTED;
     } else {
-      im_flags &= ~IM_IS_PENDING;
+      flags &= ~IS_PROMOTED;
     }
   }
 
-  void SetIsInSecondaryCache(bool is_in_secondary_cache) {
-    if (is_in_secondary_cache) {
-      im_flags |= IM_IS_IN_SECONDARY_CACHE;
-    } else {
-      im_flags &= ~IM_IS_IN_SECONDARY_CACHE;
-    }
-  }
-
-  void SetIsStandalone(bool is_standalone) {
-    if (is_standalone) {
-      im_flags |= IM_IS_STANDALONE;
-    } else {
-      im_flags &= ~IM_IS_STANDALONE;
-    }
-  }
-
-  void Free(MemoryAllocator* allocator) {
+  void Free() {
     assert(refs == 0);
-
-    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;
+#ifdef __SANITIZE_THREAD__
+    // Here we can safely assert they are the same without a data race reported
+    assert(((flags & IS_SECONDARY_CACHE_COMPATIBLE) != 0) ==
+           is_secondary_cache_compatible_for_tsan);
+#endif  // __SANITIZE_THREAD__
+    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);
+      }
     }
-    assert(helper);
-    if (helper->del_cb) {
-      helper->del_cb(value, allocator);
-    }
-
-    free(this);
+    delete[] reinterpret_cast<char*>(this);
   }
 
-  inline size_t CalcuMetaCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) const {
-    if (metadata_charge_policy != kFullChargeCacheMetadata) {
-      return 0;
-    } else {
+  // Calculate the memory usage by metadata
+  inline size_t CalcTotalCharge(
+      CacheMetadataChargePolicy metadata_charge_policy) {
+    size_t meta_charge = 0;
+    if (metadata_charge_policy == kFullChargeCacheMetadata) {
 #ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      return malloc_usable_size(
-          const_cast<void*>(static_cast<const void*>(this)));
+      meta_charge += malloc_usable_size(static_cast<void*>(this));
 #else
-      // This is the size that is used when a new handle is created.
-      return sizeof(LRUHandle) - 1 + key_length;
+      // This is the size that is used when a new handle is created
+      meta_charge += sizeof(LRUHandle) - 1 + key_length;
 #endif
     }
-  }
-
-  // Calculate the memory usage by metadata.
-  inline void CalcTotalCharge(
-      size_t charge, CacheMetadataChargePolicy metadata_charge_policy) {
-    total_charge = charge + CalcuMetaCharge(metadata_charge_policy);
-  }
-
-  inline size_t GetCharge(
-      CacheMetadataChargePolicy metadata_charge_policy) const {
-    size_t meta_charge = CalcuMetaCharge(metadata_charge_policy);
-    assert(total_charge >= meta_charge);
-    return total_charge - meta_charge;
+    return charge + meta_charge;
   }
 };
 
@@ -248,7 +231,10 @@ struct LRUHandle {
 // 4.4.3's builtin hashtable.
 class LRUHandleTable {
  public:
-  explicit LRUHandleTable(int max_upper_hash_bits, MemoryAllocator* allocator);
+  // If the table uses more hash bits than `max_upper_hash_bits`,
+  // it will eat into the bits used for sharding, which are constant
+  // for a given LRUHandleTable.
+  explicit LRUHandleTable(int max_upper_hash_bits);
   ~LRUHandleTable();
 
   LRUHandle* Lookup(const Slice& key, uint32_t hash);
@@ -256,8 +242,8 @@ class LRUHandleTable {
   LRUHandle* Remove(const Slice& key, uint32_t hash);
 
   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++) {
+  void ApplyToEntriesRange(T func, uint32_t index_begin, uint32_t index_end) {
+    for (uint32_t i = index_begin; i < index_end; i++) {
       LRUHandle* h = list_[i];
       while (h != nullptr) {
         auto n = h->next_hash;
@@ -270,10 +256,6 @@ class LRUHandleTable {
 
   int GetLengthBits() const { return length_bits_; }
 
-  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
@@ -290,110 +272,107 @@ class LRUHandleTable {
   // a linked list of cache entries that hash into the bucket.
   std::unique_ptr<LRUHandle*[]> list_;
 
-  // Number of elements currently in the table.
+  // Number of elements currently in the table
   uint32_t elems_;
 
-  // Set from max_upper_hash_bits (see constructor).
+  // 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.
-class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
+class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  public:
   LRUCacheShard(size_t capacity, bool strict_capacity_limit,
-                double high_pri_pool_ratio, double low_pri_pool_ratio,
-                bool use_adaptive_mutex,
+                double high_pri_pool_ratio, bool use_adaptive_mutex,
                 CacheMetadataChargePolicy metadata_charge_policy,
-                int max_upper_hash_bits, MemoryAllocator* allocator,
-                SecondaryCache* secondary_cache);
-
- public:  // Type definitions expected as parameter to ShardedCache
-  using HandleImpl = LRUHandle;
-  using HashVal = uint32_t;
-  using HashCref = uint32_t;
-
- public:  // Function definitions expected as parameter to ShardedCache
-  static inline HashVal ComputeHash(const Slice& key) {
-    return Lower32of64(GetSliceNPHash64(key));
-  }
+                int max_upper_hash_bits,
+                const std::shared_ptr<SecondaryCache>& secondary_cache);
+  virtual ~LRUCacheShard() override = default;
 
   // 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);
+  // free the needed space
+  virtual void SetCapacity(size_t capacity) override;
 
   // Set the flag to reject insertion if cache if full.
-  void SetStrictCapacityLimit(bool strict_capacity_limit);
+  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override;
 
   // Set percentage of capacity reserved for high-pri cache entries.
   void SetHighPriorityPoolRatio(double high_pri_pool_ratio);
 
-  // Set percentage of capacity reserved for low-pri cache entries.
-  void SetLowPriorityPoolRatio(double low_pri_pool_ratio);
-
   // Like Cache methods, but with an extra "hash" parameter.
-  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,
-                    Cache::CreateContext* create_context,
-                    Cache::Priority priority, bool wait, Statistics* stats);
-
-  bool Release(LRUHandle* handle, bool useful, bool erase_if_last_ref);
-  bool IsReady(LRUHandle* /*handle*/);
-  void Wait(LRUHandle* /*handle*/) {}
-  bool Ref(LRUHandle* handle);
-  void Erase(const Slice& key, uint32_t hash);
+  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
+                        size_t charge, Cache::DeleterFn deleter,
+                        Cache::Handle** handle,
+                        Cache::Priority priority) override {
+    return Insert(key, hash, value, charge, deleter, nullptr, handle, priority);
+  }
+  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
+                        const Cache::CacheItemHelper* helper, size_t charge,
+                        Cache::Handle** handle,
+                        Cache::Priority priority) override {
+    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
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
+                                const ShardedCache::CacheItemHelper* helper,
+                                const ShardedCache::CreateCallback& create_cb,
+                                ShardedCache::Priority priority, bool wait,
+                                Statistics* stats) override;
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) override {
+    return Lookup(key, hash, nullptr, nullptr, Cache::Priority::LOW, true,
+                  nullptr);
+  }
+  virtual bool Release(Cache::Handle* handle, bool /*useful*/,
+                       bool force_erase) override {
+    return Release(handle, force_erase);
+  }
+  virtual bool IsReady(Cache::Handle* /*handle*/) override;
+  virtual void Wait(Cache::Handle* /*handle*/) override {}
+  virtual bool Ref(Cache::Handle* handle) override;
+  virtual bool Release(Cache::Handle* handle,
+                       bool force_erase = false) override;
+  virtual void Erase(const Slice& key, uint32_t hash) override;
 
   // Although in some platforms the update of size_t is atomic, to make sure
   // GetUsage() and GetPinnedUsage() work correctly under any platform, we'll
   // protect them with mutex_.
 
-  size_t GetUsage() const;
-  size_t GetPinnedUsage() const;
-  size_t GetOccupancyCount() const;
-  size_t GetTableAddressCount() const;
+  virtual size_t GetUsage() const override;
+  virtual size_t GetPinnedUsage() const override;
 
-  void ApplyToSomeEntries(
-      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);
+  virtual void ApplyToSomeEntries(
+      const std::function<void(const Slice& key, void* value, size_t charge,
+                               DeleterFn deleter)>& callback,
+      uint32_t average_entries_per_lock, uint32_t* state) override;
 
-  void EraseUnRefEntries();
+  virtual void EraseUnRefEntries() override;
 
- public:  // other function definitions
-  void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri,
-                       LRUHandle** lru_bottom_pri);
+  virtual std::string GetPrintableOptions() const override;
 
-  // Retrieves number of elements in LRU, for unit test purpose only.
-  // Not threadsafe.
+  void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri);
+
+  //  Retrieves number of elements in LRU, for unit test purpose only
+  //  not threadsafe
   size_t TEST_GetLRUSize();
 
-  // Retrieves high pri pool ratio
+  //  Retrieves high pri pool ratio
   double GetHighPriPoolRatio();
 
-  // Retrieves low pri pool ratio
-  double GetLowPriPoolRatio();
-
-  void AppendPrintableOptions(std::string& /*str*/) const;
-
  private:
   friend class LRUCache;
   // Insert an item into the hash table and, if handle is null, insert into
   // the LRU list. Older items are evicted as necessary. If the cache is full
-  // and free_handle_on_fail is true, the item is deleted and handle is set to
-  // nullptr.
-  Status InsertItem(LRUHandle* item, LRUHandle** handle,
+  // and free_handle_on_fail is true, the item is deleted and handle is set to.
+  Status InsertItem(LRUHandle* item, Cache::Handle** handle,
                     bool free_handle_on_fail);
-  // 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
+  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
+                DeleterFn deleter, const Cache::CacheItemHelper* helper,
+                Cache::Handle** handle, Cache::Priority priority);
+  // Promote an item looked up from the secondary cache to the LRU cache. The
+  // item is only inserted into the hash table and not the LRU list, and only
   // if the cache is not at full capacity, as is the case during Insert.  The
   // caller should hold a reference on the LRUHandle. When the caller releases
   // the last reference, the item is added to the LRU list.
@@ -410,21 +389,15 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
   // 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_.
+  // holding the mutex_
   void EvictFromLRU(size_t charge, autovector<LRUHandle*>* deleted);
 
-  // Try to insert the evicted handles into the secondary cache.
-  void TryInsertIntoSecondaryCache(autovector<LRUHandle*> evicted_handles);
-
   // Initialized before use.
   size_t capacity_;
 
   // Memory size for entries in high-pri pool.
   size_t high_pri_pool_usage_;
 
-  // Memory size for entries in low-pri pool.
-  size_t low_pri_pool_usage_;
-
   // Whether to reject insertion if cache reaches its full capacity.
   bool strict_capacity_limit_;
 
@@ -435,13 +408,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
   // Remember the value to avoid recomputing each time.
   double high_pri_pool_capacity_;
 
-  // Ratio of capacity reserved for low priority cache entries.
-  double low_pri_pool_ratio_;
-
-  // Low-pri pool size, equals to capacity * low_pri_pool_ratio.
-  // Remember the value to avoid recomputing each time.
-  double low_pri_pool_capacity_;
-
   // Dummy head of LRU list.
   // lru.prev is newest entry, lru.next is oldest entry.
   // LRU contains items which can be evicted, ie reference only by cache
@@ -450,9 +416,6 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
   // Pointer to head of low-pri pool in LRU list.
   LRUHandle* lru_low_pri_;
 
-  // Pointer to head of bottom-pri pool in LRU list.
-  LRUHandle* lru_bottom_pri_;
-
   // ------------^^^^^^^^^^^^^-----------
   // Not frequently modified data members
   // ------------------------------------
@@ -466,55 +429,53 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
   // ------------vvvvvvvvvvvvv-----------
   LRUHandleTable table_;
 
-  // Memory size for entries residing in the cache.
+  // Memory size for entries residing in the cache
   size_t usage_;
 
-  // Memory size for entries residing only in the LRU list.
+  // 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_;
+  mutable port::Mutex mutex_;
 
-  // Owned by LRUCache
-  SecondaryCache* secondary_cache_;
+  std::shared_ptr<SecondaryCache> secondary_cache_;
 };
 
 class LRUCache
 #ifdef NDEBUG
     final
 #endif
-    : public ShardedCache<LRUCacheShard> {
+    : public ShardedCache {
  public:
   LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-           double high_pri_pool_ratio, double low_pri_pool_ratio,
+           double high_pri_pool_ratio,
            std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
            bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
            CacheMetadataChargePolicy metadata_charge_policy =
                kDontChargeCacheMetadata,
-           std::shared_ptr<SecondaryCache> secondary_cache = nullptr);
-  const char* Name() const override { return "LRUCache"; }
-  ObjectPtr Value(Handle* handle) override;
-  size_t GetCharge(Handle* handle) const override;
-  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
-  void WaitAll(std::vector<Handle*>& handles) override;
+           const std::shared_ptr<SecondaryCache>& secondary_cache = nullptr);
+  virtual ~LRUCache();
+  virtual const char* Name() const override { return "LRUCache"; }
+  virtual CacheShard* GetShard(uint32_t shard) override;
+  virtual const CacheShard* GetShard(uint32_t shard) const override;
+  virtual void* Value(Handle* handle) override;
+  virtual size_t GetCharge(Handle* handle) const override;
+  virtual uint32_t GetHash(Handle* handle) const override;
+  virtual DeleterFn GetDeleter(Handle* handle) const override;
+  virtual void DisownData() override;
+  virtual void WaitAll(std::vector<Handle*>& handles) override;
 
-  // Retrieves number of elements in LRU, for unit test purpose only.
+  //  Retrieves number of elements in LRU, for unit test purpose only
   size_t TEST_GetLRUSize();
-  // Retrieves high pri pool ratio.
+  //  Retrieves high pri pool ratio
   double GetHighPriPoolRatio();
 
-  void AppendPrintableOptions(std::string& str) const override;
-
  private:
+  LRUCacheShard* shards_ = nullptr;
+  int num_shards_ = 0;
   std::shared_ptr<SecondaryCache> secondary_cache_;
 };
 
-}  // namespace lru_cache
-
-using LRUCache = lru_cache::LRUCache;
-using LRUHandle = lru_cache::LRUHandle;
-using LRUCacheShard = lru_cache::LRUCacheShard;
-
 }  // namespace ROCKSDB_NAMESPACE

cache/secondary_cache.cc

@@ -1,41 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "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

cache/sharded_cache.cc

@@ -19,49 +19,183 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-ShardedCacheBase::ShardedCacheBase(size_t capacity, int num_shard_bits,
-                                   bool strict_capacity_limit,
-                                   std::shared_ptr<MemoryAllocator> allocator)
+namespace {
+
+inline uint32_t HashSlice(const Slice& s) {
+  return Lower32of64(GetSliceNPHash64(s));
+}
+
+}  // namespace
+
+ShardedCache::ShardedCache(size_t capacity, int num_shard_bits,
+                           bool strict_capacity_limit,
+                           std::shared_ptr<MemoryAllocator> allocator)
     : Cache(std::move(allocator)),
-      last_id_(1),
       shard_mask_((uint32_t{1} << num_shard_bits) - 1),
+      capacity_(capacity),
       strict_capacity_limit_(strict_capacity_limit),
-      capacity_(capacity) {}
+      last_id_(1) {}
 
-size_t ShardedCacheBase::ComputePerShardCapacity(size_t capacity) const {
+void ShardedCache::SetCapacity(size_t capacity) {
   uint32_t num_shards = GetNumShards();
-  return (capacity + (num_shards - 1)) / num_shards;
+  const size_t per_shard = (capacity + (num_shards - 1)) / num_shards;
+  MutexLock l(&capacity_mutex_);
+  for (uint32_t s = 0; s < num_shards; s++) {
+    GetShard(s)->SetCapacity(per_shard);
+  }
+  capacity_ = capacity;
 }
 
-size_t ShardedCacheBase::GetPerShardCapacity() const {
-  return ComputePerShardCapacity(GetCapacity());
+void ShardedCache::SetStrictCapacityLimit(bool strict_capacity_limit) {
+  uint32_t num_shards = GetNumShards();
+  MutexLock l(&capacity_mutex_);
+  for (uint32_t s = 0; s < num_shards; s++) {
+    GetShard(s)->SetStrictCapacityLimit(strict_capacity_limit);
+  }
+  strict_capacity_limit_ = strict_capacity_limit;
 }
 
-uint64_t ShardedCacheBase::NewId() {
+Status ShardedCache::Insert(const Slice& key, void* value, size_t charge,
+                            DeleterFn deleter, Handle** handle,
+                            Priority priority) {
+  uint32_t hash = HashSlice(key);
+  return GetShard(Shard(hash))
+      ->Insert(key, hash, value, charge, deleter, handle, priority);
+}
+
+Status ShardedCache::Insert(const Slice& key, void* value,
+                            const CacheItemHelper* helper, size_t charge,
+                            Handle** handle, Priority priority) {
+  uint32_t hash = HashSlice(key);
+  if (!helper) {
+    return Status::InvalidArgument();
+  }
+  return GetShard(Shard(hash))
+      ->Insert(key, hash, value, helper, charge, handle, priority);
+}
+
+Cache::Handle* ShardedCache::Lookup(const Slice& key, Statistics* /*stats*/) {
+  uint32_t hash = HashSlice(key);
+  return GetShard(Shard(hash))->Lookup(key, hash);
+}
+
+Cache::Handle* ShardedCache::Lookup(const Slice& key,
+                                    const CacheItemHelper* helper,
+                                    const CreateCallback& create_cb,
+                                    Priority priority, bool wait,
+                                    Statistics* stats) {
+  uint32_t hash = HashSlice(key);
+  return GetShard(Shard(hash))
+      ->Lookup(key, hash, helper, create_cb, priority, wait, stats);
+}
+
+bool ShardedCache::IsReady(Handle* handle) {
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->IsReady(handle);
+}
+
+void ShardedCache::Wait(Handle* handle) {
+  uint32_t hash = GetHash(handle);
+  GetShard(Shard(hash))->Wait(handle);
+}
+
+bool ShardedCache::Ref(Handle* handle) {
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->Ref(handle);
+}
+
+bool ShardedCache::Release(Handle* handle, bool force_erase) {
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->Release(handle, force_erase);
+}
+
+bool ShardedCache::Release(Handle* handle, bool useful, bool force_erase) {
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->Release(handle, useful, force_erase);
+}
+
+void ShardedCache::Erase(const Slice& key) {
+  uint32_t hash = HashSlice(key);
+  GetShard(Shard(hash))->Erase(key, hash);
+}
+
+uint64_t ShardedCache::NewId() {
   return last_id_.fetch_add(1, std::memory_order_relaxed);
 }
 
-size_t ShardedCacheBase::GetCapacity() const {
-  MutexLock l(&config_mutex_);
+size_t ShardedCache::GetCapacity() const {
+  MutexLock l(&capacity_mutex_);
   return capacity_;
 }
 
-bool ShardedCacheBase::HasStrictCapacityLimit() const {
-  MutexLock l(&config_mutex_);
+bool ShardedCache::HasStrictCapacityLimit() const {
+  MutexLock l(&capacity_mutex_);
   return strict_capacity_limit_;
 }
 
-size_t ShardedCacheBase::GetUsage(Handle* handle) const {
+size_t ShardedCache::GetUsage() const {
+  // We will not lock the cache when getting the usage from shards.
+  uint32_t num_shards = GetNumShards();
+  size_t usage = 0;
+  for (uint32_t s = 0; s < num_shards; s++) {
+    usage += GetShard(s)->GetUsage();
+  }
+  return usage;
+}
+
+size_t ShardedCache::GetUsage(Handle* handle) const {
   return GetCharge(handle);
 }
 
-std::string ShardedCacheBase::GetPrintableOptions() const {
+size_t ShardedCache::GetPinnedUsage() const {
+  // We will not lock the cache when getting the usage from shards.
+  uint32_t num_shards = GetNumShards();
+  size_t usage = 0;
+  for (uint32_t s = 0; s < num_shards; s++) {
+    usage += GetShard(s)->GetPinnedUsage();
+  }
+  return usage;
+}
+
+void ShardedCache::ApplyToAllEntries(
+    const std::function<void(const Slice& key, void* value, size_t charge,
+                             DeleterFn deleter)>& callback,
+    const ApplyToAllEntriesOptions& opts) {
+  uint32_t num_shards = GetNumShards();
+  // Iterate over part of each shard, rotating between shards, to
+  // minimize impact on latency of concurrent operations.
+  std::unique_ptr<uint32_t[]> states(new uint32_t[num_shards]{});
+
+  uint32_t aepl_in_32 = static_cast<uint32_t>(
+      std::min(size_t{UINT32_MAX}, opts.average_entries_per_lock));
+  aepl_in_32 = std::min(aepl_in_32, uint32_t{1});
+
+  bool remaining_work;
+  do {
+    remaining_work = false;
+    for (uint32_t s = 0; s < num_shards; s++) {
+      if (states[s] != UINT32_MAX) {
+        GetShard(s)->ApplyToSomeEntries(callback, aepl_in_32, &states[s]);
+        remaining_work |= states[s] != UINT32_MAX;
+      }
+    }
+  } while (remaining_work);
+}
+
+void ShardedCache::EraseUnRefEntries() {
+  uint32_t num_shards = GetNumShards();
+  for (uint32_t s = 0; s < num_shards; s++) {
+    GetShard(s)->EraseUnRefEntries();
+  }
+}
+
+std::string ShardedCache::GetPrintableOptions() const {
   std::string ret;
   ret.reserve(20000);
   const int kBufferSize = 200;
   char buffer[kBufferSize];
   {
-    MutexLock l(&config_mutex_);
+    MutexLock l(&capacity_mutex_);
     snprintf(buffer, kBufferSize, "    capacity : %" ROCKSDB_PRIszt "\n",
              capacity_);
     ret.append(buffer);
@@ -75,12 +209,12 @@ std::string ShardedCacheBase::GetPrintableOptions() const {
   snprintf(buffer, kBufferSize, "    memory_allocator : %s\n",
            memory_allocator() ? memory_allocator()->Name() : "None");
   ret.append(buffer);
-  AppendPrintableOptions(ret);
+  ret.append(GetShard(0)->GetPrintableOptions());
   return ret;
 }
-
-int GetDefaultCacheShardBits(size_t capacity, size_t min_shard_size) {
+int GetDefaultCacheShardBits(size_t capacity) {
   int num_shard_bits = 0;
+  size_t min_shard_size = 512L * 1024L;  // Every shard is at least 512KB.
   size_t num_shards = capacity / min_shard_size;
   while (num_shards >>= 1) {
     if (++num_shard_bits >= 6) {
@@ -91,10 +225,8 @@ int GetDefaultCacheShardBits(size_t capacity, size_t min_shard_size) {
   return num_shard_bits;
 }
 
-int ShardedCacheBase::GetNumShardBits() const {
-  return BitsSetToOne(shard_mask_);
-}
+int ShardedCache::GetNumShardBits() const { return BitsSetToOne(shard_mask_); }
 
-uint32_t ShardedCacheBase::GetNumShards() const { return shard_mask_ + 1; }
+uint32_t ShardedCache::GetNumShards() const { return shard_mask_ + 1; }
 
 }  // namespace ROCKSDB_NAMESPACE

cache/sharded_cache.h

@@ -10,298 +10,123 @@
 #pragma once
 
 #include <atomic>
-#include <cstdint>
 #include <string>
 
-#include "port/lang.h"
 #include "port/port.h"
 #include "rocksdb/cache.h"
-#include "util/hash.h"
-#include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
 
-// Optional base class for classes implementing the CacheShard concept
-class CacheShardBase {
+// Single cache shard interface.
+class CacheShard {
  public:
-  explicit CacheShardBase(CacheMetadataChargePolicy metadata_charge_policy)
-      : metadata_charge_policy_(metadata_charge_policy) {}
+  CacheShard() = default;
+  virtual ~CacheShard() = default;
 
   using DeleterFn = Cache::DeleterFn;
-
-  // Expected by concept CacheShard (TODO with C++20 support)
-  // Some Defaults
-  std::string GetPrintableOptions() const { return ""; }
-  using HashVal = uint64_t;
-  using HashCref = uint64_t;
-  static inline HashVal ComputeHash(const Slice& key) {
-    return GetSliceNPHash64(key);
-  }
-  static inline uint32_t HashPieceForSharding(HashCref hash) {
-    return Lower32of64(hash);
-  }
-  void AppendPrintableOptions(std::string& /*str*/) const {}
-
-  // Must be provided for concept CacheShard (TODO with C++20 support)
-  /*
-  struct HandleImpl {  // for concept HandleImpl
-    HashVal hash;
-    HashCref GetHash() const;
-    ...
-  };
-  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,
-                        const Cache::CacheItemHelper* helper,
-                        Cache::CreateContext* create_context,
-                        Cache::Priority priority, bool wait,
-                        Statistics* stats) = 0;
-  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref) = 0;
-  bool IsReady(HandleImpl* handle) = 0;
-  void Wait(HandleImpl* handle) = 0;
-  bool Ref(HandleImpl* handle) = 0;
-  void Erase(const Slice& key, HashCref hash) = 0;
-  void SetCapacity(size_t capacity) = 0;
-  void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
-  size_t GetUsage() const = 0;
-  size_t GetPinnedUsage() const = 0;
-  size_t GetOccupancyCount() const = 0;
-  size_t GetTableAddressCount() const = 0;
+  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
+                        size_t charge, DeleterFn deleter,
+                        Cache::Handle** handle, Cache::Priority priority) = 0;
+  virtual Status Insert(const Slice& key, uint32_t hash, void* value,
+                        const Cache::CacheItemHelper* helper, size_t charge,
+                        Cache::Handle** handle, Cache::Priority priority) = 0;
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) = 0;
+  virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
+                                const Cache::CacheItemHelper* helper,
+                                const Cache::CreateCallback& create_cb,
+                                Cache::Priority priority, bool wait,
+                                Statistics* stats) = 0;
+  virtual bool Release(Cache::Handle* handle, bool useful,
+                       bool force_erase) = 0;
+  virtual bool IsReady(Cache::Handle* handle) = 0;
+  virtual void Wait(Cache::Handle* handle) = 0;
+  virtual bool Ref(Cache::Handle* handle) = 0;
+  virtual bool Release(Cache::Handle* handle, bool force_erase) = 0;
+  virtual void Erase(const Slice& key, uint32_t hash) = 0;
+  virtual void SetCapacity(size_t capacity) = 0;
+  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
+  virtual size_t GetUsage() const = 0;
+  virtual size_t GetPinnedUsage() const = 0;
   // Handles iterating over roughly `average_entries_per_lock` entries, using
   // `state` to somehow record where it last ended up. Caller initially uses
-  // *state == 0 and implementation sets *state = SIZE_MAX to indicate
+  // *state == 0 and implementation sets *state = UINT32_MAX to indicate
   // completion.
-  void ApplyToSomeEntries(
-      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;
-  */
+  virtual void ApplyToSomeEntries(
+      const std::function<void(const Slice& key, void* value, size_t charge,
+                               DeleterFn deleter)>& callback,
+      uint32_t average_entries_per_lock, uint32_t* state) = 0;
+  virtual void EraseUnRefEntries() = 0;
+  virtual std::string GetPrintableOptions() const { return ""; }
+  void set_metadata_charge_policy(
+      CacheMetadataChargePolicy metadata_charge_policy) {
+    metadata_charge_policy_ = metadata_charge_policy;
+  }
 
  protected:
-  const CacheMetadataChargePolicy metadata_charge_policy_;
+  CacheMetadataChargePolicy metadata_charge_policy_ = kDontChargeCacheMetadata;
 };
 
-// Portions of ShardedCache that do not depend on the template parameter
-class ShardedCacheBase : public Cache {
+// Generic cache interface which shards cache by hash of keys. 2^num_shard_bits
+// shards will be created, with capacity split evenly to each of the shards.
+// Keys are sharded by the highest num_shard_bits bits of hash value.
+class ShardedCache : public Cache {
  public:
-  ShardedCacheBase(size_t capacity, int num_shard_bits,
-                   bool strict_capacity_limit,
-                   std::shared_ptr<MemoryAllocator> memory_allocator);
-  virtual ~ShardedCacheBase() = default;
+  ShardedCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+               std::shared_ptr<MemoryAllocator> memory_allocator = nullptr);
+  virtual ~ShardedCache() = default;
+  virtual CacheShard* GetShard(uint32_t shard) = 0;
+  virtual const CacheShard* GetShard(uint32_t shard) const = 0;
+
+  virtual uint32_t GetHash(Handle* handle) const = 0;
+
+  virtual void SetCapacity(size_t capacity) override;
+  virtual void SetStrictCapacityLimit(bool strict_capacity_limit) override;
+
+  virtual Status Insert(const Slice& key, void* value, size_t charge,
+                        DeleterFn deleter, Handle** handle,
+                        Priority priority) override;
+  virtual Status Insert(const Slice& key, void* value,
+                        const CacheItemHelper* helper, size_t chargge,
+                        Handle** handle = nullptr,
+                        Priority priority = Priority::LOW) override;
+  virtual Handle* Lookup(const Slice& key, Statistics* stats) override;
+  virtual Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
+                         const CreateCallback& create_cb, Priority priority,
+                         bool wait, Statistics* stats = nullptr) override;
+  virtual bool Release(Handle* handle, bool useful,
+                       bool force_erase = false) override;
+  virtual bool IsReady(Handle* handle) override;
+  virtual void Wait(Handle* handle) override;
+  virtual bool Ref(Handle* handle) override;
+  virtual bool Release(Handle* handle, bool force_erase = false) override;
+  virtual void Erase(const Slice& key) override;
+  virtual uint64_t NewId() override;
+  virtual size_t GetCapacity() const override;
+  virtual bool HasStrictCapacityLimit() const override;
+  virtual size_t GetUsage() const override;
+  virtual size_t GetUsage(Handle* handle) const override;
+  virtual size_t GetPinnedUsage() const override;
+  virtual void ApplyToAllEntries(
+      const std::function<void(const Slice& key, void* value, size_t charge,
+                               DeleterFn deleter)>& callback,
+      const ApplyToAllEntriesOptions& opts) override;
+  virtual void EraseUnRefEntries() override;
+  virtual std::string GetPrintableOptions() const override;
 
   int GetNumShardBits() const;
   uint32_t GetNumShards() const;
 
-  uint64_t NewId() override;
-
-  bool HasStrictCapacityLimit() const override;
-  size_t GetCapacity() const override;
-
-  using Cache::GetUsage;
-  size_t GetUsage(Handle* handle) const override;
-  std::string GetPrintableOptions() const override;
-
- protected:  // fns
-  virtual void AppendPrintableOptions(std::string& str) const = 0;
-  size_t GetPerShardCapacity() const;
-  size_t ComputePerShardCapacity(size_t capacity) const;
-
- protected:                        // data
-  std::atomic<uint64_t> last_id_;  // For NewId
-  const uint32_t shard_mask_;
-
-  // Dynamic configuration parameters, guarded by config_mutex_
-  bool strict_capacity_limit_;
-  size_t capacity_;
-  mutable port::Mutex config_mutex_;
-};
-
-// Generic cache interface that shards cache by hash of keys. 2^num_shard_bits
-// shards will be created, with capacity split evenly to each of the shards.
-// Keys are typically sharded by the lowest num_shard_bits bits of hash value
-// so that the upper bits of the hash value can keep a stable ordering of
-// table entries even as the table grows (using more upper hash bits).
-// See CacheShardBase above for what is expected of the CacheShard parameter.
-template <class CacheShard>
-class ShardedCache : public ShardedCacheBase {
- public:
-  using HashVal = typename CacheShard::HashVal;
-  using HashCref = typename CacheShard::HashCref;
-  using HandleImpl = typename CacheShard::HandleImpl;
-
-  ShardedCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-               std::shared_ptr<MemoryAllocator> allocator)
-      : ShardedCacheBase(capacity, num_shard_bits, strict_capacity_limit,
-                         allocator),
-        shards_(reinterpret_cast<CacheShard*>(port::cacheline_aligned_alloc(
-            sizeof(CacheShard) * GetNumShards()))),
-        destroy_shards_in_dtor_(false) {}
-
-  virtual ~ShardedCache() {
-    if (destroy_shards_in_dtor_) {
-      ForEachShard([](CacheShard* cs) { cs->~CacheShard(); });
-    }
-    port::cacheline_aligned_free(shards_);
-  }
-
-  CacheShard& GetShard(HashCref hash) {
-    return shards_[CacheShard::HashPieceForSharding(hash) & shard_mask_];
-  }
-
-  const CacheShard& GetShard(HashCref hash) const {
-    return shards_[CacheShard::HashPieceForSharding(hash) & shard_mask_];
-  }
-
-  void SetCapacity(size_t capacity) override {
-    MutexLock l(&config_mutex_);
-    capacity_ = capacity;
-    auto per_shard = ComputePerShardCapacity(capacity);
-    ForEachShard([=](CacheShard* cs) { cs->SetCapacity(per_shard); });
-  }
-
-  void SetStrictCapacityLimit(bool s_c_l) override {
-    MutexLock l(&config_mutex_);
-    strict_capacity_limit_ = s_c_l;
-    ForEachShard(
-        [s_c_l](CacheShard* cs) { cs->SetStrictCapacityLimit(s_c_l); });
-  }
-
-  Status Insert(const Slice& key, ObjectPtr value,
-                const CacheItemHelper* helper, size_t charge,
-                Handle** handle = nullptr,
-                Priority priority = Priority::LOW) override {
-    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, 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_context, priority, wait, stats);
-    return reinterpret_cast<Handle*>(result);
-  }
-
-  void Erase(const Slice& key) override {
-    HashVal hash = CacheShard::ComputeHash(key);
-    GetShard(hash).Erase(key, hash);
-  }
-
-  bool Release(Handle* handle, bool useful,
-               bool erase_if_last_ref = false) override {
-    auto h = reinterpret_cast<HandleImpl*>(handle);
-    return GetShard(h->GetHash()).Release(h, useful, erase_if_last_ref);
-  }
-  bool IsReady(Handle* handle) override {
-    auto h = reinterpret_cast<HandleImpl*>(handle);
-    return GetShard(h->GetHash()).IsReady(h);
-  }
-  void Wait(Handle* handle) override {
-    auto h = reinterpret_cast<HandleImpl*>(handle);
-    GetShard(h->GetHash()).Wait(h);
-  }
-  bool Ref(Handle* handle) override {
-    auto h = reinterpret_cast<HandleImpl*>(handle);
-    return GetShard(h->GetHash()).Ref(h);
-  }
-  bool Release(Handle* handle, bool erase_if_last_ref = false) override {
-    return Release(handle, true /*useful*/, erase_if_last_ref);
-  }
-  using ShardedCacheBase::GetUsage;
-  size_t GetUsage() const override {
-    return SumOverShards2(&CacheShard::GetUsage);
-  }
-  size_t GetPinnedUsage() const override {
-    return SumOverShards2(&CacheShard::GetPinnedUsage);
-  }
-  size_t GetOccupancyCount() const override {
-    return SumOverShards2(&CacheShard::GetPinnedUsage);
-  }
-  size_t GetTableAddressCount() const override {
-    return SumOverShards2(&CacheShard::GetTableAddressCount);
-  }
-  void ApplyToAllEntries(
-      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
-    // minimize impact on latency of concurrent operations.
-    std::unique_ptr<size_t[]> states(new size_t[num_shards]{});
-
-    size_t aepl = opts.average_entries_per_lock;
-    aepl = std::min(aepl, size_t{1});
-
-    bool remaining_work;
-    do {
-      remaining_work = false;
-      for (uint32_t i = 0; i < num_shards; i++) {
-        if (states[i] != SIZE_MAX) {
-          shards_[i].ApplyToSomeEntries(callback, aepl, &states[i]);
-          remaining_work |= states[i] != SIZE_MAX;
-        }
-      }
-    } while (remaining_work);
-  }
-
-  virtual void EraseUnRefEntries() override {
-    ForEachShard([](CacheShard* cs) { cs->EraseUnRefEntries(); });
-  }
-
-  void DisownData() override {
-    // Leak data only if that won't generate an ASAN/valgrind warning.
-    if (!kMustFreeHeapAllocations) {
-      destroy_shards_in_dtor_ = false;
-    }
-  }
-
  protected:
-  inline void ForEachShard(const std::function<void(CacheShard*)>& fn) {
-    uint32_t num_shards = GetNumShards();
-    for (uint32_t i = 0; i < num_shards; i++) {
-      fn(shards_ + i);
-    }
-  }
-
-  inline size_t SumOverShards(
-      const std::function<size_t(CacheShard&)>& fn) const {
-    uint32_t num_shards = GetNumShards();
-    size_t result = 0;
-    for (uint32_t i = 0; i < num_shards; i++) {
-      result += fn(shards_[i]);
-    }
-    return result;
-  }
-
-  inline size_t SumOverShards2(size_t (CacheShard::*fn)() const) const {
-    return SumOverShards([fn](CacheShard& cs) { return (cs.*fn)(); });
-  }
-
-  // Must be called exactly once by derived class constructor
-  void InitShards(const std::function<void(CacheShard*)>& placement_new) {
-    ForEachShard(placement_new);
-    destroy_shards_in_dtor_ = true;
-  }
-
-  void AppendPrintableOptions(std::string& str) const override {
-    shards_[0].AppendPrintableOptions(str);
-  }
+  inline uint32_t Shard(uint32_t hash) { return hash & shard_mask_; }
 
  private:
-  CacheShard* const shards_;
-  bool destroy_shards_in_dtor_;
+  const uint32_t shard_mask_;
+  mutable port::Mutex capacity_mutex_;
+  size_t capacity_;
+  bool strict_capacity_limit_;
+  std::atomic<uint64_t> last_id_;
 };
 
-// 512KB is traditional minimum shard size.
-int GetDefaultCacheShardBits(size_t capacity,
-                             size_t min_shard_size = 512U * 1024U);
+extern int GetDefaultCacheShardBits(size_t capacity);
 
 }  // namespace ROCKSDB_NAMESPACE

cache/typed_cache.h

@@ -1,339 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-// 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

cmake/modules/Finduring.cmake

@@ -1,26 +0,0 @@
-# - Find liburing
-#
-# uring_INCLUDE_DIR - Where to find liburing.h
-# uring_LIBRARIES - List of libraries when using uring.
-# uring_FOUND - True if uring found.
-
-find_path(uring_INCLUDE_DIR
-  NAMES liburing.h)
-find_library(uring_LIBRARIES
-  NAMES liburing.a liburing)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(uring
-  DEFAULT_MSG uring_LIBRARIES uring_INCLUDE_DIR)
-
-mark_as_advanced(
-  uring_INCLUDE_DIR
-  uring_LIBRARIES)
-
-if(uring_FOUND AND NOT TARGET uring::uring)
-  add_library(uring::uring UNKNOWN IMPORTED)
-  set_target_properties(uring::uring PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "${uring_INCLUDE_DIR}"
-    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-    IMPORTED_LOCATION "${uring_LIBRARIES}")
-endif()

common.mk

@@ -1,30 +0,0 @@
-ifndef PYTHON
-
-# Default to python3. Some distros like CentOS 8 do not have `python`.
-ifeq ($(origin PYTHON), undefined)
-	PYTHON := $(shell which python3 || which python || echo python3)
-endif
-export PYTHON
-
-endif
-
-# To setup tmp directory, first recognize some old variables for setting
-# test tmp directory or base tmp directory. TEST_TMPDIR is usually read
-# by RocksDB tools though Env/FileSystem::GetTestDirectory.
-ifeq ($(TEST_TMPDIR),)
-TEST_TMPDIR := $(TMPD)
-endif
-ifeq ($(TEST_TMPDIR),)
-ifeq ($(BASE_TMPDIR),)
-BASE_TMPDIR :=$(TMPDIR)
-endif
-ifeq ($(BASE_TMPDIR),)
-BASE_TMPDIR :=/tmp
-endif
-# Use /dev/shm if it has the sticky bit set (otherwise, /tmp or other
-# base dir), and create a randomly-named rocksdb.XXXX directory therein.
-TEST_TMPDIR := $(shell f=/dev/shm; test -k $$f || f=$(BASE_TMPDIR); \
-  perl -le 'use File::Temp "tempdir";'	                            \
-    -e 'print tempdir("'$$f'/rocksdb.XXXX", CLEANUP => 0)')
-endif
-export TEST_TMPDIR

coverage/coverage_test.sh

@@ -12,7 +12,7 @@ fi
 ROOT=".."
 # Fetch right version of gcov
 if [ -d /mnt/gvfs/third-party -a -z "$CXX" ]; then
-  source $ROOT/build_tools/fbcode_config_platform009.sh
+  source $ROOT/build_tools/fbcode_config_platform007.sh
   GCOV=$GCC_BASE/bin/gcov
 else
   GCOV=$(which gcov)

coverage/parse_gcov_output.py

@@ -47,39 +47,35 @@ def parse_gcov_report(gcov_input):
 
     return per_file_coverage, total_coverage
 
-
 def get_option_parser():
-    usage = (
-        "Parse the gcov output and generate more human-readable code "
-        + "coverage report."
-    )
+    usage = "Parse the gcov output and generate more human-readable code " +\
+            "coverage report."
     parser = optparse.OptionParser(usage)
 
     parser.add_option(
-        "--interested-files",
-        "-i",
+        "--interested-files", "-i",
         dest="filenames",
-        help="Comma separated files names. if specified, we will display "
-        + "the coverage report only for interested source files. "
-        + "Otherwise we will display the coverage report for all "
-        + "source files.",
+        help="Comma separated files names. if specified, we will display " +
+             "the coverage report only for interested source files. " +
+             "Otherwise we will display the coverage report for all " +
+             "source files."
     )
     return parser
 
-
 def display_file_coverage(per_file_coverage, total_coverage):
     # To print out auto-adjustable column, we need to know the longest
     # length of file names.
-    max_file_name_length = max(len(fname) for fname in per_file_coverage.keys())
+    max_file_name_length = max(
+        len(fname) for fname in per_file_coverage.keys()
+    )
 
     # -- Print header
     # size of separator is determined by 3 column sizes:
     # file name, coverage percentage and lines.
-    header_template = "%" + str(max_file_name_length) + "s\t%s\t%s"
+    header_template = \
+        "%" + str(max_file_name_length) + "s\t%s\t%s"
     separator = "-" * (max_file_name_length + 10 + 20)
-    print(
-        header_template % ("Filename", "Coverage", "Lines")
-    )  # noqa: E999 T25377293 Grandfathered in
+    print(header_template % ("Filename", "Coverage", "Lines"))  # noqa: E999 T25377293 Grandfathered in
     print(separator)
 
     # -- Print body
@@ -95,14 +91,13 @@ def display_file_coverage(per_file_coverage, total_coverage):
         print(separator)
         print(record_template % ("Total", total_coverage[0], total_coverage[1]))
 
-
 def report_coverage():
     parser = get_option_parser()
     (options, args) = parser.parse_args()
 
     interested_files = set()
     if options.filenames is not None:
-        interested_files = {f.strip() for f in options.filenames.split(",")}
+        interested_files = set(f.strip() for f in options.filenames.split(','))
 
     # To make things simple, right now we only read gcov report from the input
     per_file_coverage, total_coverage = parse_gcov_report(sys.stdin)
@@ -110,8 +105,7 @@ def report_coverage():
     # Check if we need to display coverage info for interested files.
     if len(interested_files):
         per_file_coverage = dict(
-            (fname, per_file_coverage[fname])
-            for fname in interested_files
+            (fname, per_file_coverage[fname]) for fname in interested_files
             if fname in per_file_coverage
         )
         # If we only interested in several files, it makes no sense to report
@@ -123,6 +117,5 @@ def report_coverage():
         return
     display_file_coverage(per_file_coverage, total_coverage)
 
-
 if __name__ == "__main__":
     report_coverage()

crash_test.mk

@@ -1,107 +0,0 @@
-# This file is used by Meta-internal infrastructure as well as by Makefile
-
-# When included from Makefile, there are rules to build DB_STRESS_CMD. When
-# used directly with `make -f crashtest.mk ...` there will be no rules to
-# build DB_STRESS_CMD so it must exist prior.
-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) --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 \
-	blackbox_crash_test blackbox_crash_test_with_atomic_flush \
-	blackbox_crash_test_with_txn blackbox_crash_test_with_ts \
-	blackbox_crash_test_with_best_efforts_recovery \
-	whitebox_crash_test whitebox_crash_test_with_atomic_flush \
-	whitebox_crash_test_with_txn whitebox_crash_test_with_ts \
-	blackbox_crash_test_with_multiops_wc_txn \
-	blackbox_crash_test_with_multiops_wp_txn \
-	crash_test_with_tiered_storage blackbox_crash_test_with_tiered_storage \
-	whitebox_crash_test_with_tiered_storage \
-
-crash_test: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test
-	$(CRASHTEST_MAKE) blackbox_crash_test
-
-crash_test_with_atomic_flush: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_atomic_flush
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_atomic_flush
-
-crash_test_with_txn: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_txn
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_txn
-
-crash_test_with_best_efforts_recovery: blackbox_crash_test_with_best_efforts_recovery
-
-crash_test_with_ts: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_ts
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_ts
-
-crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-# Do not parallelize
-	$(CRASHTEST_MAKE) whitebox_crash_test_with_tiered_storage
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_tiered_storage
-
-crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_multiops_wc_txn
-
-crash_test_with_multiops_wp_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_MAKE) blackbox_crash_test_with_multiops_wp_txn
-
-blackbox_crash_test: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --simple blackbox $(CRASH_TEST_EXT_ARGS)
-	$(CRASHTEST_PY) blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_atomic_flush: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --cf_consistency blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_best_efforts_recovery: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_best_efforts_recovery blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_ts: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --enable_ts blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_multiops_wc_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_multiops_txn --write_policy write_committed blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_multiops_wp_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_multiops_txn --write_policy write_prepared blackbox $(CRASH_TEST_EXT_ARGS)
-
-blackbox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_tiered_storage blackbox $(CRASH_TEST_EXT_ARGS)
-
-ifeq ($(CRASH_TEST_KILL_ODD),)
-  CRASH_TEST_KILL_ODD=888887
-endif
-
-whitebox_crash_test: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --simple whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-	$(CRASHTEST_PY) whitebox  --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_atomic_flush: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --cf_consistency whitebox  --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_txn: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --txn whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_ts: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --enable_ts whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)
-
-whitebox_crash_test_with_tiered_storage: $(DB_STRESS_CMD)
-	$(CRASHTEST_PY) --test_tiered_storage whitebox --random_kill_odd \
-      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

db/arena_wrapped_db_iter.cc

@@ -8,7 +8,6 @@
 // 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"
@@ -24,7 +23,7 @@ Status ArenaWrappedDBIter::GetProperty(std::string prop_name,
   if (prop_name == "rocksdb.iterator.super-version-number") {
     // First try to pass the value returned from inner iterator.
     if (!db_iter_->GetProperty(prop_name, prop).ok()) {
-      *prop = std::to_string(sv_number_);
+      *prop = ToString(sv_number_);
     }
     return Status::OK();
   }
@@ -46,7 +45,6 @@ void ArenaWrappedDBIter::Init(
   sv_number_ = version_number;
   read_options_ = read_options;
   allow_refresh_ = allow_refresh;
-  memtable_range_tombstone_iter_ = nullptr;
 }
 
 Status ArenaWrappedDBIter::Refresh() {
@@ -60,7 +58,7 @@ Status ArenaWrappedDBIter::Refresh() {
   uint64_t cur_sv_number = cfd_->GetSuperVersionNumber();
   TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:1");
   TEST_SYNC_POINT("ArenaWrappedDBIter::Refresh:2");
-  auto reinit_internal_iter = [&]() {
+  if (sv_number_ != cur_sv_number) {
     Env* env = db_iter_->env();
     db_iter_->~DBIter();
     arena_.~Arena();
@@ -78,64 +76,12 @@ Status ArenaWrappedDBIter::Refresh() {
          allow_refresh_);
 
     InternalIterator* internal_iter = db_impl_->NewInternalIterator(
-        read_options_, cfd_, sv, &arena_, latest_seq,
-        /* allow_unprepared_value */ true, /* db_iter */ this);
+        read_options_, cfd_, sv, &arena_, db_iter_->GetRangeDelAggregator(),
+        latest_seq, /* allow_unprepared_value */ true);
     SetIterUnderDBIter(internal_iter);
-  };
-  while (true) {
-    if (sv_number_ != cur_sv_number) {
-      reinit_internal_iter();
-      break;
-    } else {
-      SequenceNumber latest_seq = db_impl_->GetLatestSequenceNumber();
-      // Refresh range-tombstones in MemTable
-      if (!read_options_.ignore_range_deletions) {
-        SuperVersion* sv = cfd_->GetThreadLocalSuperVersion(db_impl_);
-        TEST_SYNC_POINT_CALLBACK("ArenaWrappedDBIter::Refresh:SV", nullptr);
-        auto t = sv->mem->NewRangeTombstoneIterator(
-            read_options_, latest_seq, false /* immutable_memtable */);
-        if (!t || t->empty()) {
-          // If memtable_range_tombstone_iter_ points to a non-empty tombstone
-          // iterator, then it means sv->mem is not the memtable that
-          // memtable_range_tombstone_iter_ points to, so SV must have changed
-          // after the sv_number_ != cur_sv_number check above. We will fall
-          // back to re-init the InternalIterator, and the tombstone iterator
-          // will be freed during db_iter destruction there.
-          if (memtable_range_tombstone_iter_) {
-            assert(!*memtable_range_tombstone_iter_ ||
-                   sv_number_ != cfd_->GetSuperVersionNumber());
-          }
-          delete t;
-        } else {  // current mutable memtable has range tombstones
-          if (!memtable_range_tombstone_iter_) {
-            delete t;
-            db_impl_->ReturnAndCleanupSuperVersion(cfd_, sv);
-            // The memtable under DBIter did not have range tombstone before
-            // refresh.
-            reinit_internal_iter();
-            break;
-          } else {
-            delete *memtable_range_tombstone_iter_;
-            *memtable_range_tombstone_iter_ = new TruncatedRangeDelIterator(
-                std::unique_ptr<FragmentedRangeTombstoneIterator>(t),
-                &cfd_->internal_comparator(), nullptr, nullptr);
-          }
-        }
-        db_impl_->ReturnAndCleanupSuperVersion(cfd_, sv);
-      }
-      // Refresh latest sequence number
-      db_iter_->set_sequence(latest_seq);
-      db_iter_->set_valid(false);
-      // Check again if the latest super version number is changed
-      uint64_t latest_sv_number = cfd_->GetSuperVersionNumber();
-      if (latest_sv_number != cur_sv_number) {
-        // If the super version number is changed after refreshing,
-        // fallback to Re-Init the InternalIterator
-        cur_sv_number = latest_sv_number;
-        continue;
-      }
-      break;
-    }
+  } else {
+    db_iter_->set_sequence(db_impl_->GetLatestSequenceNumber());
+    db_iter_->set_valid(false);
   }
   return Status::OK();
 }

db/arena_wrapped_db_iter.h

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

db/blob/blob_contents.cc

@@ -1,42 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/blob/blob_contents.h"
-
-#include <cassert>
-
-#include "cache/cache_entry_roles.h"
-#include "cache/cache_helpers.h"
-#include "port/malloc.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-size_t BlobContents::ApproximateMemoryUsage() const {
-  size_t usage = 0;
-
-  if (allocation_) {
-    MemoryAllocator* const allocator = allocation_.get_deleter().allocator;
-
-    if (allocator) {
-      usage += allocator->UsableSize(allocation_.get(), data_.size());
-    } else {
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-      usage += malloc_usable_size(allocation_.get());
-#else
-      usage += data_.size();
-#endif
-    }
-  }
-
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-  usage += malloc_usable_size(const_cast<BlobContents*>(this));
-#else
-  usage += sizeof(*this);
-#endif
-
-  return usage;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_contents.h

@@ -1,59 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <memory>
-
-#include "memory/memory_allocator.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/rocksdb_namespace.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A class representing a single uncompressed value read from a blob file.
-class BlobContents {
- public:
-  BlobContents(CacheAllocationPtr&& allocation, size_t size)
-      : allocation_(std::move(allocation)), data_(allocation_.get(), size) {}
-
-  BlobContents(const BlobContents&) = delete;
-  BlobContents& operator=(const BlobContents&) = delete;
-
-  BlobContents(BlobContents&&) = default;
-  BlobContents& operator=(BlobContents&&) = default;
-
-  ~BlobContents() = default;
-
-  const Slice& data() const { return data_; }
-  size_t size() const { return data_.size(); }
-
-  size_t ApproximateMemoryUsage() const;
-
-  // For TypedCacheInterface
-  const Slice& ContentSlice() const { return data_; }
-  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kBlobValue;
-
- private:
-  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

db/blob/blob_counting_iterator_test.cc

@@ -321,7 +321,6 @@ TEST(BlobCountingIteratorTest, CorruptBlobIndex) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

db/blob/blob_fetcher.cc

@@ -9,26 +9,14 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-Status BlobFetcher::FetchBlob(const Slice& user_key,
-                              const Slice& blob_index_slice,
-                              FilePrefetchBuffer* prefetch_buffer,
-                              PinnableSlice* blob_value,
-                              uint64_t* bytes_read) const {
+Status BlobFetcher::FetchBlob(const Slice& user_key, const Slice& blob_index,
+                              PinnableSlice* blob_value) {
+  Status s;
   assert(version_);
-
-  return version_->GetBlob(read_options_, user_key, blob_index_slice,
-                           prefetch_buffer, blob_value, bytes_read);
+  constexpr uint64_t* bytes_read = nullptr;
+  s = version_->GetBlob(read_options_, user_key, blob_index, blob_value,
+                        bytes_read);
+  return s;
 }
 
-Status BlobFetcher::FetchBlob(const Slice& user_key,
-                              const BlobIndex& blob_index,
-                              FilePrefetchBuffer* prefetch_buffer,
-                              PinnableSlice* blob_value,
-                              uint64_t* bytes_read) const {
-  assert(version_);
-
-  return version_->GetBlob(read_options_, user_key, blob_index, prefetch_buffer,
-                           blob_value, bytes_read);
-}
-
-}  // namespace ROCKSDB_NAMESPACE
+}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_fetcher.h

@@ -9,29 +9,18 @@
 #include "rocksdb/status.h"
 
 namespace ROCKSDB_NAMESPACE {
-
 class Version;
-class Slice;
-class FilePrefetchBuffer;
-class PinnableSlice;
-class BlobIndex;
 
-// A thin wrapper around the blob retrieval functionality of Version.
 class BlobFetcher {
  public:
-  BlobFetcher(const Version* version, const ReadOptions& read_options)
+  BlobFetcher(Version* version, const ReadOptions& read_options)
       : version_(version), read_options_(read_options) {}
 
-  Status FetchBlob(const Slice& user_key, const Slice& blob_index_slice,
-                   FilePrefetchBuffer* prefetch_buffer,
-                   PinnableSlice* blob_value, uint64_t* bytes_read) const;
-
-  Status FetchBlob(const Slice& user_key, const BlobIndex& blob_index,
-                   FilePrefetchBuffer* prefetch_buffer,
-                   PinnableSlice* blob_value, uint64_t* bytes_read) const;
+  Status FetchBlob(const Slice& user_key, const Slice& blob_index,
+                   PinnableSlice* blob_value);
 
  private:
-  const Version* version_;
+  Version* version_;
   ReadOptions read_options_;
 };
-}  // namespace ROCKSDB_NAMESPACE
+}  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_addition_test.cc

@@ -205,7 +205,6 @@ TEST_F(BlobFileAdditionTest, ForwardIncompatibleCustomField) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

db/blob/blob_file_builder.cc

@@ -7,13 +7,11 @@
 
 #include <cassert>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_file_addition.h"
 #include "db/blob/blob_file_completion_callback.h"
 #include "db/blob/blob_index.h"
 #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"
@@ -34,9 +32,9 @@ BlobFileBuilder::BlobFileBuilder(
     VersionSet* versions, FileSystem* fs,
     const ImmutableOptions* immutable_options,
     const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
-    std::string db_id, std::string db_session_id, int job_id,
-    uint32_t column_family_id, const std::string& column_family_name,
-    Env::IOPriority io_priority, Env::WriteLifeTimeHint write_hint,
+    int job_id, uint32_t column_family_id,
+    const std::string& column_family_name, Env::IOPriority io_priority,
+    Env::WriteLifeTimeHint write_hint,
     const std::shared_ptr<IOTracer>& io_tracer,
     BlobFileCompletionCallback* blob_callback,
     BlobFileCreationReason creation_reason,
@@ -44,18 +42,17 @@ BlobFileBuilder::BlobFileBuilder(
     std::vector<BlobFileAddition>* blob_file_additions)
     : BlobFileBuilder([versions]() { return versions->NewFileNumber(); }, fs,
                       immutable_options, mutable_cf_options, file_options,
-                      db_id, db_session_id, job_id, column_family_id,
-                      column_family_name, io_priority, write_hint, io_tracer,
-                      blob_callback, creation_reason, blob_file_paths,
-                      blob_file_additions) {}
+                      job_id, column_family_id, column_family_name, io_priority,
+                      write_hint, io_tracer, blob_callback, creation_reason,
+                      blob_file_paths, blob_file_additions) {}
 
 BlobFileBuilder::BlobFileBuilder(
     std::function<uint64_t()> file_number_generator, FileSystem* fs,
     const ImmutableOptions* immutable_options,
     const MutableCFOptions* mutable_cf_options, const FileOptions* file_options,
-    std::string db_id, std::string db_session_id, int job_id,
-    uint32_t column_family_id, const std::string& column_family_name,
-    Env::IOPriority io_priority, Env::WriteLifeTimeHint write_hint,
+    int job_id, uint32_t column_family_id,
+    const std::string& column_family_name, Env::IOPriority io_priority,
+    Env::WriteLifeTimeHint write_hint,
     const std::shared_ptr<IOTracer>& io_tracer,
     BlobFileCompletionCallback* blob_callback,
     BlobFileCreationReason creation_reason,
@@ -67,10 +64,7 @@ BlobFileBuilder::BlobFileBuilder(
       min_blob_size_(mutable_cf_options->min_blob_size),
       blob_file_size_(mutable_cf_options->blob_file_size),
       blob_compression_type_(mutable_cf_options->blob_compression_type),
-      prepopulate_blob_cache_(mutable_cf_options->prepopulate_blob_cache),
       file_options_(file_options),
-      db_id_(std::move(db_id)),
-      db_session_id_(std::move(db_session_id)),
       job_id_(job_id),
       column_family_id_(column_family_id),
       column_family_name_(column_family_name),
@@ -139,16 +133,6 @@ Status BlobFileBuilder::Add(const Slice& key, const Slice& value,
     }
   }
 
-  {
-    const Status s =
-        PutBlobIntoCacheIfNeeded(value, blob_file_number, blob_offset);
-    if (!s.ok()) {
-      ROCKS_LOG_WARN(immutable_options_->info_log,
-                     "Failed to pre-populate the blob into blob cache: %s",
-                     s.ToString().c_str());
-    }
-  }
-
   BlobIndex::EncodeBlob(blob_index, blob_file_number, blob_offset, blob.size(),
                         blob_compression_type_);
 
@@ -388,38 +372,4 @@ void BlobFileBuilder::Abandon(const Status& s) {
   blob_count_ = 0;
   blob_bytes_ = 0;
 }
-
-Status BlobFileBuilder::PutBlobIntoCacheIfNeeded(const Slice& blob,
-                                                 uint64_t blob_file_number,
-                                                 uint64_t blob_offset) const {
-  Status s = Status::OK();
-
-  BlobSource::SharedCacheInterface blob_cache{immutable_options_->blob_cache};
-  auto statistics = immutable_options_->statistics.get();
-  bool warm_cache =
-      prepopulate_blob_cache_ == PrepopulateBlobCache::kFlushOnly &&
-      creation_reason_ == BlobFileCreationReason::kFlush;
-
-  if (blob_cache && warm_cache) {
-    const OffsetableCacheKey base_cache_key(db_id_, db_session_id_,
-                                            blob_file_number);
-    const CacheKey cache_key = base_cache_key.WithOffset(blob_offset);
-    const Slice key = cache_key.AsSlice();
-
-    const Cache::Priority priority = Cache::Priority::BOTTOM;
-
-    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, blob.size());
-    } else {
-      RecordTick(statistics, BLOB_DB_CACHE_ADD_FAILURES);
-    }
-  }
-
-  return s;
-}
-
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_builder.h

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

db/blob/blob_file_builder_test.cc

@@ -144,9 +144,8 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckOneFile) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
@@ -229,9 +228,8 @@ TEST_F(BlobFileBuilderTest, BuildAndCheckMultipleFiles) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   std::vector<std::pair<std::string, std::string>> expected_key_value_pairs(
@@ -317,9 +315,8 @@ TEST_F(BlobFileBuilderTest, InlinedValues) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   for (size_t i = 0; i < number_of_blobs; ++i) {
@@ -372,9 +369,8 @@ TEST_F(BlobFileBuilderTest, Compression) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   const std::string key("1");
@@ -456,9 +452,8 @@ TEST_F(BlobFileBuilderTest, CompressionError) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   SyncPoint::GetInstance()->SetCallBack("CompressData:TamperWithReturnValue",
@@ -536,9 +531,8 @@ TEST_F(BlobFileBuilderTest, Checksum) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   const std::string key("1");
@@ -634,9 +628,8 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
 
   BlobFileBuilder builder(
       TestFileNumberGenerator(), fs_, &immutable_options, &mutable_cf_options,
-      &file_options_, "" /*db_id*/, "" /*db_session_id*/, job_id,
-      column_family_id, column_family_name, io_priority, write_hint,
-      nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
+      &file_options_, job_id, column_family_id, column_family_name, io_priority,
+      write_hint, nullptr /*IOTracer*/, nullptr /*BlobFileCompletionCallback*/,
       BlobFileCreationReason::kFlush, &blob_file_paths, &blob_file_additions);
 
   SyncPoint::GetInstance()->SetCallBack(sync_point_, [this](void* arg) {
@@ -674,7 +667,6 @@ TEST_P(BlobFileBuilderIOErrorTest, IOError) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

db/blob/blob_file_cache.cc

@@ -42,13 +42,13 @@ Status BlobFileCache::GetBlobFileReader(
   assert(blob_file_reader);
   assert(blob_file_reader->IsEmpty());
 
-  const Slice key = GetSliceForKey(&blob_file_number);
+  const Slice key = GetSlice(&blob_file_number);
 
   assert(cache_);
 
-  TypedHandle* handle = cache_.Lookup(key);
+  Cache::Handle* handle = cache_->Lookup(key);
   if (handle) {
-    *blob_file_reader = cache_.Guard(handle);
+    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, 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 = cache_.Guard(handle);
+    *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
     return Status::OK();
   }
 
@@ -84,7 +84,8 @@ Status BlobFileCache::GetBlobFileReader(
   {
     constexpr size_t charge = 1;
 
-    const Status s = cache_.Insert(key, reader.get(), charge, &handle);
+    const Status s = cache_->Insert(key, reader.get(), charge,
+                                    &DeleteCacheEntry<BlobFileReader>, &handle);
     if (!s.ok()) {
       RecordTick(statistics, NO_FILE_ERRORS);
       return s;
@@ -93,7 +94,7 @@ Status BlobFileCache::GetBlobFileReader(
 
   reader.release();
 
-  *blob_file_reader = cache_.Guard(handle);
+  *blob_file_reader = CacheHandleGuard<BlobFileReader>(cache_, handle);
 
   return Status::OK();
 }

db/blob/blob_file_cache.h

@@ -7,8 +7,7 @@
 
 #include <cinttypes>
 
-#include "cache/typed_cache.h"
-#include "db/blob/blob_file_reader.h"
+#include "cache/cache_helpers.h"
 #include "rocksdb/rocksdb_namespace.h"
 #include "util/mutexlock.h"
 
@@ -19,6 +18,7 @@ struct ImmutableOptions;
 struct FileOptions;
 class HistogramImpl;
 class Status;
+class BlobFileReader;
 class Slice;
 class IOTracer;
 
@@ -36,10 +36,7 @@ class BlobFileCache {
                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
 
  private:
-  using CacheInterface =
-      BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
-  using TypedHandle = CacheInterface::TypedHandle;
-  CacheInterface cache_;
+  Cache* cache_;
   // Note: mutex_ below is used to guard against multiple threads racing to open
   // the same file.
   Striped<port::Mutex, Slice> mutex_;

db/blob/blob_file_cache_test.cc

@@ -254,7 +254,7 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
   CacheHandleGuard<BlobFileReader> reader;
 
   ASSERT_TRUE(blob_file_cache.GetBlobFileReader(blob_file_number, &reader)
-                  .IsMemoryLimit());
+                  .IsIncomplete());
   ASSERT_EQ(reader.GetValue(), nullptr);
   ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_OPENS), 1);
   ASSERT_EQ(options.statistics->getTickerCount(NO_FILE_ERRORS), 1);
@@ -263,7 +263,6 @@ TEST_F(BlobFileCacheTest, GetBlobFileReader_CacheFull) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

db/blob/blob_file_completion_callback.h

@@ -23,19 +23,32 @@ 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,
@@ -48,6 +61,7 @@ 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
@@ -60,6 +74,7 @@ class BlobFileCompletionCallback {
         error_handler_->SetBGError(s, BackgroundErrorReason::kFlush);
       }
     }
+#endif  // !ROCKSDB_LITE
 
     // Notify the listeners.
     EventHelpers::LogAndNotifyBlobFileCreationFinished(
@@ -74,9 +89,11 @@ 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_;

db/blob/blob_file_garbage_test.cc

@@ -168,7 +168,6 @@ TEST_F(BlobFileGarbageTest, ForwardIncompatibleCustomField) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

db/blob/blob_file_reader.cc

@@ -8,16 +8,13 @@
 #include <cassert>
 #include <string>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
-#include "file/file_prefetch_buffer.h"
 #include "file/filename.h"
 #include "monitoring/statistics.h"
 #include "options/cf_options.h"
 #include "rocksdb/file_system.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
-#include "table/multiget_context.h"
 #include "test_util/sync_point.h"
 #include "util/compression.h"
 #include "util/crc32c.h"
@@ -150,10 +147,9 @@ Status BlobFileReader::ReadHeader(const RandomAccessFileReader* file_reader,
     constexpr uint64_t read_offset = 0;
     constexpr size_t read_size = BlobLogHeader::kSize;
 
-    // TODO: rate limit reading headers from blob files.
-    const Status s = ReadFromFile(file_reader, read_offset, read_size,
-                                  statistics, &header_slice, &buf, &aligned_buf,
-                                  Env::IO_TOTAL /* rate_limiter_priority */);
+    const Status s =
+        ReadFromFile(file_reader, read_offset, read_size, statistics,
+                     &header_slice, &buf, &aligned_buf);
     if (!s.ok()) {
       return s;
     }
@@ -201,10 +197,9 @@ Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
     const uint64_t read_offset = file_size - BlobLogFooter::kSize;
     constexpr size_t read_size = BlobLogFooter::kSize;
 
-    // TODO: rate limit reading footers from blob files.
-    const Status s = ReadFromFile(file_reader, read_offset, read_size,
-                                  statistics, &footer_slice, &buf, &aligned_buf,
-                                  Env::IO_TOTAL /* rate_limiter_priority */);
+    const Status s =
+        ReadFromFile(file_reader, read_offset, read_size, statistics,
+                     &footer_slice, &buf, &aligned_buf);
     if (!s.ok()) {
       return s;
     }
@@ -234,8 +229,7 @@ Status BlobFileReader::ReadFooter(const RandomAccessFileReader* file_reader,
 Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
                                     uint64_t read_offset, size_t read_size,
                                     Statistics* statistics, Slice* slice,
-                                    Buffer* buf, AlignedBuf* aligned_buf,
-                                    Env::IOPriority rate_limiter_priority) {
+                                    Buffer* buf, AlignedBuf* aligned_buf) {
   assert(slice);
   assert(buf);
   assert(aligned_buf);
@@ -250,13 +244,13 @@ Status BlobFileReader::ReadFromFile(const RandomAccessFileReader* file_reader,
     constexpr char* scratch = nullptr;
 
     s = file_reader->Read(IOOptions(), read_offset, read_size, slice, scratch,
-                          aligned_buf, rate_limiter_priority);
+                          aligned_buf);
   } else {
     buf->reset(new char[read_size]);
     constexpr AlignedBuf* aligned_scratch = nullptr;
 
     s = file_reader->Read(IOOptions(), read_offset, read_size, slice,
-                          buf->get(), aligned_scratch, rate_limiter_priority);
+                          buf->get(), aligned_scratch);
   }
 
   if (!s.ok()) {
@@ -284,12 +278,13 @@ BlobFileReader::BlobFileReader(
 
 BlobFileReader::~BlobFileReader() = default;
 
-Status BlobFileReader::GetBlob(
-    const ReadOptions& read_options, const Slice& user_key, uint64_t offset,
-    uint64_t value_size, CompressionType compression_type,
-    FilePrefetchBuffer* prefetch_buffer, MemoryAllocator* allocator,
-    std::unique_ptr<BlobContents>* result, uint64_t* bytes_read) const {
-  assert(result);
+Status BlobFileReader::GetBlob(const ReadOptions& read_options,
+                               const Slice& user_key, uint64_t offset,
+                               uint64_t value_size,
+                               CompressionType compression_type,
+                               PinnableSlice* value,
+                               uint64_t* bytes_read) const {
+  assert(value);
 
   const uint64_t key_size = user_key.size();
 
@@ -318,37 +313,19 @@ Status BlobFileReader::GetBlob(
   Buffer buf;
   AlignedBuf aligned_buf;
 
-  bool prefetched = false;
-
-  if (prefetch_buffer) {
-    Status s;
-    constexpr bool for_compaction = true;
-
-    prefetched = prefetch_buffer->TryReadFromCache(
-        IOOptions(), file_reader_.get(), record_offset,
-        static_cast<size_t>(record_size), &record_slice, &s,
-        read_options.rate_limiter_priority, for_compaction);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  if (!prefetched) {
+  {
     TEST_SYNC_POINT("BlobFileReader::GetBlob:ReadFromFile");
-    PERF_COUNTER_ADD(blob_read_count, 1);
-    PERF_COUNTER_ADD(blob_read_byte, record_size);
-    PERF_TIMER_GUARD(blob_read_time);
+
     const Status s = ReadFromFile(file_reader_.get(), record_offset,
                                   static_cast<size_t>(record_size), statistics_,
-                                  &record_slice, &buf, &aligned_buf,
-                                  read_options.rate_limiter_priority);
+                                  &record_slice, &buf, &aligned_buf);
     if (!s.ok()) {
       return s;
     }
-  }
 
-  TEST_SYNC_POINT_CALLBACK("BlobFileReader::GetBlob:TamperWithResult",
-                           &record_slice);
+    TEST_SYNC_POINT_CALLBACK("BlobFileReader::GetBlob:TamperWithResult",
+                             &record_slice);
+  }
 
   if (read_options.verify_checksums) {
     const Status s = VerifyBlob(record_slice, user_key, value_size);
@@ -360,8 +337,8 @@ Status BlobFileReader::GetBlob(
   const Slice value_slice(record_slice.data() + adjustment, value_size);
 
   {
-    const Status s = UncompressBlobIfNeeded(
-        value_slice, compression_type, allocator, clock_, statistics_, result);
+    const Status s = UncompressBlobIfNeeded(value_slice, compression_type,
+                                            clock_, statistics_, value);
     if (!s.ok()) {
       return s;
     }
@@ -375,56 +352,39 @@ Status BlobFileReader::GetBlob(
 }
 
 void BlobFileReader::MultiGetBlob(
-    const ReadOptions& read_options, MemoryAllocator* allocator,
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>&
-        blob_reqs,
-    uint64_t* bytes_read) const {
-  const size_t num_blobs = blob_reqs.size();
+    const ReadOptions& read_options,
+    const autovector<std::reference_wrapper<const Slice>>& user_keys,
+    const autovector<uint64_t>& offsets,
+    const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
+    autovector<PinnableSlice*>& values, uint64_t* bytes_read) const {
+  const size_t num_blobs = user_keys.size();
   assert(num_blobs > 0);
-  assert(num_blobs <= MultiGetContext::MAX_BATCH_SIZE);
+  assert(num_blobs == offsets.size());
+  assert(num_blobs == value_sizes.size());
+  assert(num_blobs == statuses.size());
+  assert(num_blobs == values.size());
 
 #ifndef NDEBUG
-  for (size_t i = 0; i < num_blobs - 1; ++i) {
-    assert(blob_reqs[i].first->offset <= blob_reqs[i + 1].first->offset);
+  for (size_t i = 0; i < offsets.size() - 1; ++i) {
+    assert(offsets[i] <= offsets[i + 1]);
   }
 #endif  // !NDEBUG
 
-  std::vector<FSReadRequest> read_reqs;
+  std::vector<FSReadRequest> read_reqs(num_blobs);
   autovector<uint64_t> adjustments;
   uint64_t total_len = 0;
-  read_reqs.reserve(num_blobs);
   for (size_t i = 0; i < num_blobs; ++i) {
-    BlobReadRequest* const req = blob_reqs[i].first;
-    assert(req);
-    assert(req->user_key);
-    assert(req->status);
-
-    const size_t key_size = req->user_key->size();
-    const uint64_t offset = req->offset;
-    const uint64_t value_size = req->len;
-
-    if (!IsValidBlobOffset(offset, key_size, value_size, file_size_)) {
-      *req->status = Status::Corruption("Invalid blob offset");
-      continue;
-    }
-    if (req->compression != compression_type_) {
-      *req->status =
-          Status::Corruption("Compression type mismatch when reading a blob");
-      continue;
-    }
-
+    const size_t key_size = user_keys[i].get().size();
+    assert(IsValidBlobOffset(offsets[i], key_size, value_sizes[i], file_size_));
     const uint64_t adjustment =
         read_options.verify_checksums
             ? BlobLogRecord::CalculateAdjustmentForRecordHeader(key_size)
             : 0;
-    assert(req->offset >= adjustment);
+    assert(offsets[i] >= adjustment);
     adjustments.push_back(adjustment);
-
-    FSReadRequest read_req = {};
-    read_req.offset = req->offset - adjustment;
-    read_req.len = req->len + adjustment;
-    read_reqs.emplace_back(read_req);
-    total_len += read_req.len;
+    read_reqs[i].offset = offsets[i] - adjustment;
+    read_reqs[i].len = value_sizes[i] + adjustment;
+    total_len += read_reqs[i].len;
   }
 
   RecordTick(statistics_, BLOB_DB_BLOB_FILE_BYTES_READ, total_len);
@@ -447,81 +407,70 @@ void BlobFileReader::MultiGetBlob(
     }
   }
   TEST_SYNC_POINT("BlobFileReader::MultiGetBlob:ReadFromFile");
-  PERF_COUNTER_ADD(blob_read_count, num_blobs);
-  PERF_COUNTER_ADD(blob_read_byte, total_len);
   s = file_reader_->MultiRead(IOOptions(), read_reqs.data(), read_reqs.size(),
-                              direct_io ? &aligned_buf : nullptr,
-                              read_options.rate_limiter_priority);
+                              direct_io ? &aligned_buf : nullptr);
   if (!s.ok()) {
     for (auto& req : read_reqs) {
       req.status.PermitUncheckedError();
     }
-    for (auto& blob_req : blob_reqs) {
-      BlobReadRequest* const req = blob_req.first;
-      assert(req);
-      assert(req->status);
-
-      if (!req->status->IsCorruption()) {
-        // Avoid overwriting corruption status.
-        *req->status = s;
-      }
+    for (size_t i = 0; i < num_blobs; ++i) {
+      assert(statuses[i]);
+      *statuses[i] = s;
     }
     return;
   }
 
   assert(s.ok());
-
-  uint64_t total_bytes = 0;
-  for (size_t i = 0, j = 0; i < num_blobs; ++i) {
-    BlobReadRequest* const req = blob_reqs[i].first;
-    assert(req);
-    assert(req->user_key);
-    assert(req->status);
-
-    if (!req->status->ok()) {
-      continue;
+  for (size_t i = 0; i < num_blobs; ++i) {
+    auto& req = read_reqs[i];
+    assert(statuses[i]);
+    if (req.status.ok() && req.result.size() != req.len) {
+      req.status = IOStatus::Corruption("Failed to read data from blob file");
     }
+    *statuses[i] = req.status;
+  }
 
-    assert(j < read_reqs.size());
-    auto& read_req = read_reqs[j++];
-    const auto& record_slice = read_req.result;
-    if (read_req.status.ok() && record_slice.size() != read_req.len) {
-      read_req.status =
-          IOStatus::Corruption("Failed to read data from blob file");
-    }
-
-    *req->status = read_req.status;
-    if (!req->status->ok()) {
-      continue;
-    }
-
-    // Verify checksums if enabled
-    if (read_options.verify_checksums) {
-      *req->status = VerifyBlob(record_slice, *req->user_key, req->len);
-      if (!req->status->ok()) {
+  if (read_options.verify_checksums) {
+    for (size_t i = 0; i < num_blobs; ++i) {
+      assert(statuses[i]);
+      if (!statuses[i]->ok()) {
         continue;
       }
+      const Slice& record_slice = read_reqs[i].result;
+      s = VerifyBlob(record_slice, user_keys[i], value_sizes[i]);
+      if (!s.ok()) {
+        assert(statuses[i]);
+        *statuses[i] = s;
+      }
     }
+  }
 
-    // Uncompress blob if needed
-    Slice value_slice(record_slice.data() + adjustments[i], req->len);
-    *req->status =
-        UncompressBlobIfNeeded(value_slice, compression_type_, allocator,
-                               clock_, statistics_, &blob_reqs[i].second);
-    if (req->status->ok()) {
-      total_bytes += record_slice.size();
+  for (size_t i = 0; i < num_blobs; ++i) {
+    assert(statuses[i]);
+    if (!statuses[i]->ok()) {
+      continue;
+    }
+    const Slice& record_slice = read_reqs[i].result;
+    const Slice value_slice(record_slice.data() + adjustments[i],
+                            value_sizes[i]);
+    s = UncompressBlobIfNeeded(value_slice, compression_type_, clock_,
+                               statistics_, values[i]);
+    if (!s.ok()) {
+      *statuses[i] = s;
     }
   }
 
   if (bytes_read) {
+    uint64_t total_bytes = 0;
+    for (const auto& req : read_reqs) {
+      total_bytes += req.result.size();
+    }
     *bytes_read = total_bytes;
   }
 }
 
 Status BlobFileReader::VerifyBlob(const Slice& record_slice,
                                   const Slice& user_key, uint64_t value_size) {
-  PERF_TIMER_GUARD(blob_checksum_time);
-
   BlobLogRecord record;
 
   const Slice header_slice(record_slice.data(), BlobLogRecord::kHeaderSize);
@@ -562,14 +511,16 @@ Status BlobFileReader::VerifyBlob(const Slice& record_slice,
   return Status::OK();
 }
 
-Status BlobFileReader::UncompressBlobIfNeeded(
-    const Slice& value_slice, CompressionType compression_type,
-    MemoryAllocator* allocator, SystemClock* clock, Statistics* statistics,
-    std::unique_ptr<BlobContents>* result) {
-  assert(result);
+Status BlobFileReader::UncompressBlobIfNeeded(const Slice& value_slice,
+                                              CompressionType compression_type,
+                                              SystemClock* clock,
+                                              Statistics* statistics,
+                                              PinnableSlice* value) {
+  assert(value);
 
   if (compression_type == kNoCompression) {
-    BlobContentsCreator::Create(result, nullptr, value_slice, allocator);
+    SaveValue(value_slice, value);
+
     return Status::OK();
   }
 
@@ -579,11 +530,11 @@ Status BlobFileReader::UncompressBlobIfNeeded(
 
   size_t uncompressed_size = 0;
   constexpr uint32_t compression_format_version = 2;
+  constexpr MemoryAllocator* allocator = nullptr;
 
   CacheAllocationPtr output;
 
   {
-    PERF_TIMER_GUARD(blob_decompress_time);
     StopWatch stop_watch(clock, statistics, BLOB_DB_DECOMPRESSION_MICROS);
     output = UncompressData(info, value_slice.data(), value_slice.size(),
                             &uncompressed_size, compression_format_version,
@@ -597,9 +548,19 @@ Status BlobFileReader::UncompressBlobIfNeeded(
     return Status::Corruption("Unable to uncompress blob");
   }
 
-  result->reset(new BlobContents(std::move(output), uncompressed_size));
+  SaveValue(Slice(output.get(), uncompressed_size), value);
 
   return Status::OK();
 }
 
+void BlobFileReader::SaveValue(const Slice& src, PinnableSlice* dst) {
+  assert(dst);
+
+  if (dst->IsPinned()) {
+    dst->Reset();
+  }
+
+  dst->PinSelf(src);
+}
+
 }  // namespace ROCKSDB_NAMESPACE

db/blob/blob_file_reader.h

@@ -8,7 +8,6 @@
 #include <cinttypes>
 #include <memory>
 
-#include "db/blob/blob_read_request.h"
 #include "file/random_access_file_reader.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/rocksdb_namespace.h"
@@ -22,8 +21,7 @@ struct FileOptions;
 class HistogramImpl;
 struct ReadOptions;
 class Slice;
-class FilePrefetchBuffer;
-class BlobContents;
+class PinnableSlice;
 class Statistics;
 
 class BlobFileReader {
@@ -43,18 +41,16 @@ class BlobFileReader {
 
   Status GetBlob(const ReadOptions& read_options, const Slice& user_key,
                  uint64_t offset, uint64_t value_size,
-                 CompressionType compression_type,
-                 FilePrefetchBuffer* prefetch_buffer,
-                 MemoryAllocator* allocator,
-                 std::unique_ptr<BlobContents>* result,
+                 CompressionType compression_type, PinnableSlice* value,
                  uint64_t* bytes_read) const;
 
   // offsets must be sorted in ascending order by caller.
   void MultiGetBlob(
-      const ReadOptions& read_options, MemoryAllocator* allocator,
-      autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>&
-          blob_reqs,
-      uint64_t* bytes_read) const;
+      const ReadOptions& read_options,
+      const autovector<std::reference_wrapper<const Slice>>& user_keys,
+      const autovector<uint64_t>& offsets,
+      const autovector<uint64_t>& value_sizes, autovector<Status*>& statuses,
+      autovector<PinnableSlice*>& values, uint64_t* bytes_read) const;
 
   CompressionType GetCompressionType() const { return compression_type_; }
 
@@ -85,18 +81,18 @@ class BlobFileReader {
   static Status ReadFromFile(const RandomAccessFileReader* file_reader,
                              uint64_t read_offset, size_t read_size,
                              Statistics* statistics, Slice* slice, Buffer* buf,
-                             AlignedBuf* aligned_buf,
-                             Env::IOPriority rate_limiter_priority);
+                             AlignedBuf* aligned_buf);
 
   static Status VerifyBlob(const Slice& record_slice, const Slice& user_key,
                            uint64_t value_size);
 
   static Status UncompressBlobIfNeeded(const Slice& value_slice,
                                        CompressionType compression_type,
-                                       MemoryAllocator* allocator,
                                        SystemClock* clock,
                                        Statistics* statistics,
-                                       std::unique_ptr<BlobContents>* result);
+                                       PinnableSlice* value);
+
+  static void SaveValue(const Slice& src, PinnableSlice* dst);
 
   std::unique_ptr<RandomAccessFileReader> file_reader_;
   uint64_t file_size_;

db/blob/blob_file_reader_test.cc

@@ -8,7 +8,6 @@
 #include <cassert>
 #include <string>
 
-#include "db/blob/blob_contents.h"
 #include "db/blob/blob_log_format.h"
 #include "db/blob/blob_log_writer.h"
 #include "env/mock_env.h"
@@ -180,44 +179,37 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   ReadOptions read_options;
   read_options.verify_checksums = false;
 
-  constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, keys[0], blob_offsets[0],
-                              blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blobs[0]);
+                              blob_sizes[0], kNoCompression, &value,
+                              &bytes_read));
+    ASSERT_EQ(value, blobs[0]);
     ASSERT_EQ(bytes_read, blob_sizes[0]);
 
     // MultiGetBlob
     bytes_read = 0;
     size_t total_size = 0;
-
-    std::array<Status, num_blobs> statuses_buf;
-    std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
-
-    for (size_t i = 0; i < num_blobs; ++i) {
-      requests_buf[i] =
-          BlobReadRequest(keys[i], blob_offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
+    autovector<std::reference_wrapper<const Slice>> key_refs;
+    for (const auto& key_ref : keys) {
+      key_refs.emplace_back(std::cref(key_ref));
     }
-
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
-
+    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
+                                 blob_offsets[2]};
+    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
+    std::array<Status, num_blobs> statuses_buf;
+    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
+                                 &statuses_buf[2]};
+    std::array<PinnableSlice, num_blobs> value_buf;
+    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
+                                      &value_buf[2]};
+    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
+                         values, &bytes_read);
     for (size_t i = 0; i < num_blobs; ++i) {
-      const auto& result = blob_reqs[i].second;
-
       ASSERT_OK(statuses_buf[i]);
-      ASSERT_NE(result, nullptr);
-      ASSERT_EQ(result->data(), blobs[i]);
+      ASSERT_EQ(value_buf[i], blobs[i]);
       total_size += blob_sizes[i];
     }
     ASSERT_EQ(bytes_read, total_size);
@@ -226,14 +218,13 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   read_options.verify_checksums = true;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, keys[1], blob_offsets[1],
-                              blob_sizes[1], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blobs[1]);
+                              blob_sizes[1], kNoCompression, &value,
+                              &bytes_read));
+    ASSERT_EQ(value, blobs[1]);
 
     const uint64_t key_size = keys[1].size();
     ASSERT_EQ(bytes_read,
@@ -243,60 +234,55 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
 
   // Invalid offset (too close to start of file)
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[0], blob_offsets[0] - 1,
-                              blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              blob_sizes[0], kNoCompression, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Invalid offset (too close to end of file)
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[2], blob_offsets[2] + 1,
-                              blob_sizes[2], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              blob_sizes[2], kNoCompression, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Incorrect compression type
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[0], blob_offsets[0],
-                              blob_sizes[0], kZSTD, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              blob_sizes[0], kZSTD, &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
   // Incorrect key size
   {
     constexpr char shorter_key[] = "k";
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, shorter_key,
                               blob_offsets[0] -
                                   (keys[0].size() - sizeof(shorter_key) + 1),
-                              blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              blob_sizes[0], kNoCompression, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -311,21 +297,15 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
         blob_offsets[0],
         blob_offsets[1] - (keys[1].size() - key_refs[1].get().size()),
         blob_offsets[2]};
-
+    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
     std::array<Status, num_blobs> statuses_buf;
-    std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
-
-    for (size_t i = 0; i < num_blobs; ++i) {
-      requests_buf[i] =
-          BlobReadRequest(key_refs[i], offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
-    }
-
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
-
+    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
+                                 &statuses_buf[2]};
+    std::array<PinnableSlice, num_blobs> value_buf;
+    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
+                                      &value_buf[2]};
+    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
+                         values, &bytes_read);
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i == 1) {
         ASSERT_TRUE(statuses_buf[i].IsCorruption());
@@ -338,15 +318,14 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
   // Incorrect key
   {
     constexpr char incorrect_key[] = "foo1";
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, incorrect_key, blob_offsets[0],
-                              blob_sizes[0], kNoCompression, prefetch_buffer,
-                              allocator, &value, &bytes_read)
+                              blob_sizes[0], kNoCompression, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -357,20 +336,17 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
     Slice wrong_key_slice(incorrect_key, sizeof(incorrect_key) - 1);
     key_refs[2] = std::cref(wrong_key_slice);
 
+    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
+                                 blob_offsets[2]};
+    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1], blob_sizes[2]};
     std::array<Status, num_blobs> statuses_buf;
-    std::array<BlobReadRequest, num_blobs> requests_buf;
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
-
-    for (size_t i = 0; i < num_blobs; ++i) {
-      requests_buf[i] =
-          BlobReadRequest(key_refs[i], blob_offsets[i], blob_sizes[i],
-                          kNoCompression, nullptr, &statuses_buf[i]);
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
-    }
-
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
-
+    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
+                                 &statuses_buf[2]};
+    std::array<PinnableSlice, num_blobs> value_buf;
+    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
+                                      &value_buf[2]};
+    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
+                         values, &bytes_read);
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i == num_blobs - 1) {
         ASSERT_TRUE(statuses_buf[i].IsCorruption());
@@ -382,15 +358,14 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
 
   // Incorrect value size
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(read_options, keys[1], blob_offsets[1],
-                              blob_sizes[1] + 1, kNoCompression,
-                              prefetch_buffer, allocator, &value, &bytes_read)
+                              blob_sizes[1] + 1, kNoCompression, &value,
+                              &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
 
     // MultiGetBlob
@@ -398,29 +373,17 @@ TEST_F(BlobFileReaderTest, CreateReaderAndGetBlob) {
     for (const auto& key_ref : keys) {
       key_refs.emplace_back(std::cref(key_ref));
     }
-
+    autovector<uint64_t> offsets{blob_offsets[0], blob_offsets[1],
+                                 blob_offsets[2]};
+    autovector<uint64_t> sizes{blob_sizes[0], blob_sizes[1] + 1, blob_sizes[2]};
     std::array<Status, num_blobs> statuses_buf;
-    std::array<BlobReadRequest, num_blobs> requests_buf;
-
-    requests_buf[0] =
-        BlobReadRequest(key_refs[0], blob_offsets[0], blob_sizes[0],
-                        kNoCompression, nullptr, &statuses_buf[0]);
-    requests_buf[1] =
-        BlobReadRequest(key_refs[1], blob_offsets[1], blob_sizes[1] + 1,
-                        kNoCompression, nullptr, &statuses_buf[1]);
-    requests_buf[2] =
-        BlobReadRequest(key_refs[2], blob_offsets[2], blob_sizes[2],
-                        kNoCompression, nullptr, &statuses_buf[2]);
-
-    autovector<std::pair<BlobReadRequest*, std::unique_ptr<BlobContents>>>
-        blob_reqs;
-
-    for (size_t i = 0; i < num_blobs; ++i) {
-      blob_reqs.emplace_back(&requests_buf[i], std::unique_ptr<BlobContents>());
-    }
-
-    reader->MultiGetBlob(read_options, allocator, blob_reqs, &bytes_read);
-
+    autovector<Status*> statuses{&statuses_buf[0], &statuses_buf[1],
+                                 &statuses_buf[2]};
+    std::array<PinnableSlice, num_blobs> value_buf;
+    autovector<PinnableSlice*> values{&value_buf[0], &value_buf[1],
+                                      &value_buf[2]};
+    reader->MultiGetBlob(read_options, key_refs, offsets, sizes, statuses,
+                         values, &bytes_read);
     for (size_t i = 0; i < num_blobs; ++i) {
       if (i != 1) {
         ASSERT_OK(statuses_buf[i]);
@@ -679,18 +642,13 @@ TEST_F(BlobFileReaderTest, BlobCRCError) {
 
   SyncPoint::GetInstance()->EnableProcessing();
 
-  constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
-  std::unique_ptr<BlobContents> value;
+  PinnableSlice value;
   uint64_t bytes_read = 0;
 
   ASSERT_TRUE(reader
                   ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kNoCompression, prefetch_buffer, allocator, &value,
-                            &bytes_read)
+                            kNoCompression, &value, &bytes_read)
                   .IsCorruption());
-  ASSERT_EQ(value, nullptr);
   ASSERT_EQ(bytes_read, 0);
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -737,32 +695,25 @@ TEST_F(BlobFileReaderTest, Compression) {
   ReadOptions read_options;
   read_options.verify_checksums = false;
 
-  constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blob);
+                              kSnappyCompression, &value, &bytes_read));
+    ASSERT_EQ(value, blob);
     ASSERT_EQ(bytes_read, blob_size);
   }
 
   read_options.verify_checksums = true;
 
   {
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_OK(reader->GetBlob(read_options, key, blob_offset, blob_size,
-                              kSnappyCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read));
-    ASSERT_NE(value, nullptr);
-    ASSERT_EQ(value->data(), blob);
+                              kSnappyCompression, &value, &bytes_read));
+    ASSERT_EQ(value, blob);
 
     constexpr uint64_t key_size = sizeof(key) - 1;
     ASSERT_EQ(bytes_read,
@@ -819,18 +770,13 @@ TEST_F(BlobFileReaderTest, UncompressionError) {
 
   SyncPoint::GetInstance()->EnableProcessing();
 
-  constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-  constexpr MemoryAllocator* allocator = nullptr;
-
-  std::unique_ptr<BlobContents> value;
+  PinnableSlice value;
   uint64_t bytes_read = 0;
 
   ASSERT_TRUE(reader
                   ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                            kSnappyCompression, prefetch_buffer, allocator,
-                            &value, &bytes_read)
+                            kSnappyCompression, &value, &bytes_read)
                   .IsCorruption());
-  ASSERT_EQ(value, nullptr);
   ASSERT_EQ(bytes_read, 0);
 
   SyncPoint::GetInstance()->DisableProcessing();
@@ -908,18 +854,13 @@ TEST_P(BlobFileReaderIOErrorTest, IOError) {
   } else {
     ASSERT_OK(s);
 
-    constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-    constexpr MemoryAllocator* allocator = nullptr;
-
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              kNoCompression, &value, &bytes_read)
                     .IsIOError());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
@@ -996,18 +937,13 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
   } else {
     ASSERT_OK(s);
 
-    constexpr FilePrefetchBuffer* prefetch_buffer = nullptr;
-    constexpr MemoryAllocator* allocator = nullptr;
-
-    std::unique_ptr<BlobContents> value;
+    PinnableSlice value;
     uint64_t bytes_read = 0;
 
     ASSERT_TRUE(reader
                     ->GetBlob(ReadOptions(), key, blob_offset, blob_size,
-                              kNoCompression, prefetch_buffer, allocator,
-                              &value, &bytes_read)
+                              kNoCompression, &value, &bytes_read)
                     .IsCorruption());
-    ASSERT_EQ(value, nullptr);
     ASSERT_EQ(bytes_read, 0);
   }
 
@@ -1018,7 +954,6 @@ TEST_P(BlobFileReaderDecodingErrorTest, DecodingError) {
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }