Improve HISTORY.md

Summary:
It seems that an incorrect native source file entry was introduced in https://github.com/facebook/rocksdb/pull/8999. For some reason it appears that CI was not run against that PR, and so the problem was not detected.

This PR fixes the problem by removing the invalid entry, allowing RocksJava to build correctly again.

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

Reviewed By: pdillinger

Differential Revision: D32300976

fbshipit-source-id: dbd763b806bacf0fc08f4deaf07c63d0a266c4cf

.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/actions/build-folly/action.yml

@@ -1,7 +0,0 @@
-name: build-folly
-runs:
-  using: composite
-  steps:
-  - name: Build folly and dependencies
-    run: make build_folly
-    shell: bash

.github/actions/build-for-benchmarks/action.yml

@@ -1,8 +0,0 @@
-name: build-for-benchmarks
-runs:
-  using: composite
-  steps:
-  - uses: "./.github/actions/pre-steps"
-  - name: Linux build for benchmarks
-    run: make V=1 J=8 -j8 release
-    shell: bash

.github/actions/increase-max-open-files-on-macos/action.yml

@@ -1,10 +0,0 @@
-name: increase-max-open-files-on-macos
-runs:
-  using: composite
-  steps:
-  - name: Increase max open files
-    run: |-
-      sudo sysctl -w kern.maxfiles=1048576
-      sudo sysctl -w kern.maxfilesperproc=1048576
-      sudo launchctl limit maxfiles 1048576
-    shell: bash

.github/actions/install-gflags-on-macos/action.yml

@@ -1,7 +0,0 @@
-name: install-gflags-on-macos
-runs:
-  using: composite
-  steps:
-  - name: Install gflags on macos
-    run: HOMEBREW_NO_AUTO_UPDATE=1 brew install gflags
-    shell: bash

.github/actions/install-gflags/action.yml

@@ -1,7 +0,0 @@
-name: install-gflags
-runs:
-  using: composite
-  steps:
-  - name: Install gflags
-    run: sudo apt-get update -y && sudo apt-get install -y libgflags-dev
-    shell: bash

.github/actions/install-jdk8-on-macos/action.yml

@@ -1,9 +0,0 @@
-name: install-jdk8-on-macos
-runs:
-  using: composite
-  steps:
-  - name: Install JDK 8 on macos
-    run: |-
-      HOMEBREW_NO_AUTO_UPDATE=1 brew tap bell-sw/liberica
-      HOMEBREW_NO_AUTO_UPDATE=1 brew install --cask liberica-jdk8
-    shell: bash

.github/actions/install-maven/action.yml

@@ -1,11 +0,0 @@
-name: install-maven
-runs:
-  using: composite
-  steps:
-  - name: Install Maven
-    run: |
-      wget --no-check-certificate https://dlcdn.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz
-      tar zxf apache-maven-3.9.6-bin.tar.gz
-      echo "export M2_HOME=$(pwd)/apache-maven-3.9.6" >> $GITHUB_ENV
-      echo "$(pwd)/apache-maven-3.9.6/bin" >> $GITHUB_PATH
-    shell: bash

.github/actions/perform-benchmarks/action.yml

@@ -1,22 +0,0 @@
-name: perform-benchmarks
-runs:
-  using: composite
-  steps:
-  - name: Test low-variance benchmarks
-    run: "./tools/benchmark_ci.py --db_dir ${{ runner.temp }}/rocksdb-benchmark-datadir --output_dir ${{ runner.temp }}/benchmark-results --num_keys 20000000"
-    env:
-      LD_LIBRARY_PATH: "/usr/local/lib"
-      DURATION_RO: 300
-      DURATION_RW: 500
-      NUM_THREADS: 1
-      MAX_BACKGROUND_JOBS: 4
-      CI_TESTS_ONLY: 'true'
-      WRITE_BUFFER_SIZE_MB: 16
-      TARGET_FILE_SIZE_BASE_MB: 16
-      MAX_BYTES_FOR_LEVEL_BASE_MB: 64
-      COMPRESSION_TYPE: none
-      CACHE_INDEX_AND_FILTER_BLOCKS: 1
-      MIN_LEVEL_TO_COMPRESS: 3
-      CACHE_SIZE_MB: 10240
-      MB_WRITE_PER_SEC: 2
-    shell: bash

.github/actions/post-benchmarks/action.yml

@@ -1,17 +0,0 @@
-name: post-benchmarks
-runs:
-  using: composite
-  steps:
-  - name: Upload Benchmark Results artifact
-    uses: actions/upload-artifact@v4.0.0
-    with:
-      name: benchmark-results
-      path: "${{ runner.temp }}/benchmark-results/**"
-      if-no-files-found: error
-  - name: Send benchmark report to visualisation
-    run: |-
-      set +e
-      set +o pipefail
-      ./build_tools/benchmark_log_tool.py --tsvfile ${{ runner.temp }}/benchmark-results/report.tsv --esdocument https://search-rocksdb-bench-k2izhptfeap2hjfxteolsgsynm.us-west-2.es.amazonaws.com/bench_test3_rix/_doc
-      true
-    shell: bash

.github/actions/post-steps/action.yml

@@ -1,38 +0,0 @@
-name: post-steps
-description: Steps that are taken after a RocksDB job
-inputs:
-  artifact-prefix:
-    description: Prefix to append to the name of artifacts that are uploaded
-    required: true
-    default: "${{ github.job }}"
-runs:
-  using: composite
-  steps:
-  - name: Upload Test Results artifact
-    uses: actions/upload-artifact@v4.0.0
-    with:
-      name: "${{ inputs.artifact-prefix }}-test-results"
-      path: "${{ runner.temp }}/test-results/**"
-  - name: Upload DB LOG file artifact
-    uses: actions/upload-artifact@v4.0.0
-    with:
-      name: "${{ inputs.artifact-prefix }}-db-log-file"
-      path: LOG
-  - name: Copy Test Logs (on Failure)
-    if: ${{ failure() }}
-    run: |
-      mkdir -p ${{ runner.temp }}/failure-test-logs
-      cp -r t/* ${{ runner.temp }}/failure-test-logs
-    shell: bash
-  - name: Upload Test Logs (on Failure) artifact
-    uses: actions/upload-artifact@v4.0.0
-    with:
-      name: "${{ inputs.artifact-prefix }}-failure-test-logs"
-      path: ${{ runner.temp }}/failure-test-logs/**
-      if-no-files-found: ignore
-  - name: Upload Core Dumps artifact
-    uses: actions/upload-artifact@v4.0.0
-    with:
-      name: "${{ inputs.artifact-prefix }}-core-dumps"
-      path: "core.*"
-      if-no-files-found: ignore

.github/actions/pre-steps-macos/action.yml

@@ -1,5 +0,0 @@
-name: pre-steps-macos
-runs:
-  using: composite
-  steps:
-  - uses: "./.github/actions/pre-steps"

.github/actions/pre-steps/action.yml

@@ -1,18 +0,0 @@
-name: pre-steps
-runs:
-  using: composite
-  steps:
-  - name: Setup Environment Variables
-    run: |-
-      echo "GTEST_THROW_ON_FAILURE=0" >> "$GITHUB_ENV"
-      echo "GTEST_OUTPUT=\"xml:${{ runner.temp }}/test-results/\"" >> "$GITHUB_ENV"
-      echo "SKIP_FORMAT_BUCK_CHECKS=1" >> "$GITHUB_ENV"
-      echo "GTEST_COLOR=1" >> "$GITHUB_ENV"
-      echo "CTEST_OUTPUT_ON_FAILURE=1" >> "$GITHUB_ENV"
-      echo "CTEST_TEST_TIMEOUT=300" >> "$GITHUB_ENV"
-      echo "ZLIB_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zlib" >> "$GITHUB_ENV"
-      echo "BZIP2_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/bzip2" >> "$GITHUB_ENV"
-      echo "SNAPPY_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/snappy" >> "$GITHUB_ENV"
-      echo "LZ4_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/lz4" >> "$GITHUB_ENV"
-      echo "ZSTD_DOWNLOAD_BASE=https://rocksdb-deps.s3.us-west-2.amazonaws.com/pkgs/zstd" >> "$GITHUB_ENV"
-    shell: bash

.github/actions/setup-folly/action.yml

@@ -1,7 +0,0 @@
-name: setup-folly
-runs:
-  using: composite
-  steps:
-  - name: Checkout folly sources
-    run: make checkout_folly
-    shell: bash

.github/actions/setup-upstream/action.yml

@@ -1,20 +0,0 @@
-name: build-folly
-runs:
-  using: composite
-  steps:
-  - name: Fix repo ownership
-    # Needed in some cases, as safe.directory setting doesn't take effect
-    # under env -i
-    run: chown `whoami` . || true
-    shell: bash
-  - name: Set upstream
-    run: git remote add upstream https://github.com/facebook/rocksdb.git
-    shell: bash
-  - name: Fetch upstream
-    run: git fetch upstream
-    shell: bash
-  - name: Git status
-    # NOTE: some old branch builds under check_format_compatible.sh invoke
-    # git under env -i
-    run: git status && git remote -v && env -i git branch
-    shell: bash

.github/actions/windows-build-steps/action.yml

@@ -1,54 +0,0 @@
-name: windows-build-steps
-runs:
-  using: composite
-  steps:
-  - name: Add msbuild to PATH
-    uses: microsoft/setup-msbuild@v1.3.1
-  - name: Custom steps
-    env:
-      THIRDPARTY_HOME: ${{ github.workspace }}/thirdparty
-      CMAKE_HOME: C:/Program Files/CMake
-      CMAKE_BIN: C:/Program Files/CMake/bin/cmake.exe
-      CTEST_BIN: C:/Program Files/CMake/bin/ctest.exe
-      JAVA_HOME: C:/Program Files/BellSoft/LibericaJDK-8
-      SNAPPY_HOME: ${{ github.workspace }}/thirdparty/snappy-1.1.8
-      SNAPPY_INCLUDE: ${{ github.workspace }}/thirdparty/snappy-1.1.8;${{ github.workspace }}/thirdparty/snappy-1.1.8/build
-      SNAPPY_LIB_DEBUG: ${{ github.workspace }}/thirdparty/snappy-1.1.8/build/Debug/snappy.lib
-    run: |-
-      # NOTE: if ... Exit $LASTEXITCODE lines needed to exit and report failure
-      echo ===================== Install Dependencies =====================
-      choco install liberica8jdk -y
-      if(!$?) { Exit $LASTEXITCODE }
-      mkdir $Env:THIRDPARTY_HOME
-      cd $Env:THIRDPARTY_HOME
-      echo "Building Snappy dependency..."
-      curl -Lo snappy-1.1.8.zip https://github.com/google/snappy/archive/refs/tags/1.1.8.zip
-      if(!$?) { Exit $LASTEXITCODE }
-      unzip -q snappy-1.1.8.zip
-      if(!$?) { Exit $LASTEXITCODE }
-      cd snappy-1.1.8
-      mkdir build
-      cd build
-      & cmake -G "$Env:CMAKE_GENERATOR" ..
-      if(!$?) { Exit $LASTEXITCODE }
-      msbuild Snappy.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
-      if(!$?) { Exit $LASTEXITCODE }
-      echo ======================== Build RocksDB =========================
-      cd ${{ github.workspace }}
-      $env:Path = $env:JAVA_HOME + ";" + $env:Path
-      mkdir build
-      cd build
-      & cmake -G "$Env:CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=Debug -DOPTDBG=1 -DPORTABLE="$Env:CMAKE_PORTABLE" -DSNAPPY=1 -DJNI=1 ..
-      if(!$?) { Exit $LASTEXITCODE }
-      cd ..
-      echo "Building with VS version: $Env:CMAKE_GENERATOR"
-      msbuild build/rocksdb.sln -maxCpuCount -property:Configuration=Debug -property:Platform=x64
-      if(!$?) { Exit $LASTEXITCODE }
-      echo ========================= Test RocksDB =========================
-      build_tools\run_ci_db_test.ps1 -SuiteRun arena_test,db_basic_test,db_test,db_test2,db_merge_operand_test,bloom_test,c_test,coding_test,crc32c_test,dynamic_bloom_test,env_basic_test,env_test,hash_test,random_test -Concurrency 16
-      if(!$?) { Exit $LASTEXITCODE }
-      echo ======================== Test RocksJava ========================
-      cd build\java
-      & ctest -C Debug -j 16
-      if(!$?) { Exit $LASTEXITCODE }
-    shell: pwsh

.github/workflows/benchmark-linux.yml

@@ -1,15 +0,0 @@
-name: facebook/rocksdb/benchmark-linux
-on: workflow_dispatch
-jobs:
-  # FIXME: when this job is fixed, it should be given a cron schedule like
-  # schedule:
-  # - cron: 0 * * * *
-  # workflow_dispatch:
-  benchmark-linux:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/build-for-benchmarks"
-    - uses: "./.github/actions/perform-benchmarks"
-    - uses: "./.github/actions/post-benchmarks"

.github/workflows/nightly-candidate.yml

@@ -1,18 +0,0 @@
-name: facebook/rocksdb/nightly
-on: workflow_dispatch
-jobs:
-  # These jobs would be in nightly but are failing or otherwise broken for
-  # some reason.
-  build-linux-arm-test-full:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: arm64large
-    container:
-      image: ubuntu-2004:202111-02
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/install-gflags"
-    - run: make V=1 J=4 -j4 check
-    - uses: "./.github/actions/post-steps"

.github/workflows/nightly.yml

@@ -1,108 +0,0 @@
-name: facebook/rocksdb/nightly
-on:
-  schedule:
-  - cron: 0 9 * * *
-  workflow_dispatch:
-jobs:
-  build-format-compatible:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-      with:
-        fetch-depth: 0 # Need full repo history
-        fetch-tags: true
-    - uses: "./.github/actions/setup-upstream"
-    - uses: "./.github/actions/pre-steps"
-    - name: test
-      run: |-
-        export TEST_TMPDIR=/dev/shm/rocksdb
-        rm -rf /dev/shm/rocksdb
-        mkdir /dev/shm/rocksdb
-        git config --global --add safe.directory /__w/rocksdb/rocksdb
-        tools/check_format_compatible.sh
-    - uses: "./.github/actions/post-steps"
-  build-linux-run-microbench:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: DEBUG_LEVEL=0 make -j32 run_microbench
-    - uses: "./.github/actions/post-steps"
-  build-linux-non-shm:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    env:
-      TEST_TMPDIR: "/tmp/rocksdb_test_tmp"
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: make V=1 -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-clang-13-asan-ubsan-with-folly:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - uses: "./.github/actions/build-folly"
-    - run: CC=clang-13 CXX=clang++-13 LIB_MODE=static USE_CLANG=1 USE_FOLLY=1 COMPILE_WITH_UBSAN=1 COMPILE_WITH_ASAN=1 make -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-valgrind:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: PORTABLE=1 make V=1 -j32 valgrind_test
-    - uses: "./.github/actions/post-steps"
-  build-windows-vs2022-avx2:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: windows-2022
-    env:
-      CMAKE_GENERATOR: Visual Studio 17 2022
-      CMAKE_PORTABLE: AVX2
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/windows-build-steps"
-  build-windows-vs2022:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: windows-2022
-    env:
-      CMAKE_GENERATOR: Visual Studio 17 2022
-      CMAKE_PORTABLE: 1
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/windows-build-steps"
-  build-linux-arm-test-full:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu-arm
-    steps:
-      - uses: actions/checkout@v4.1.0
-      - uses: "./.github/actions/pre-steps"
-      - run: sudo apt-get update && sudo apt-get install -y build-essential libgflags-dev
-      - run: make V=1 J=4 -j4 check
-      - uses: "./.github/actions/post-steps"

.github/workflows/pr-jobs-candidate.yml

@@ -1,46 +0,0 @@
-name: facebook/rocksdb/pr-jobs-candidate
-on: workflow_dispatch
-jobs:
-  # These jobs would be in pr-jobs but are failing or otherwise broken for
-  # some reason.
-  # =========================== ARM Jobs ============================ #
-  build-linux-arm:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: arm64large # GitHub hosted ARM runners do not yet exist
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/install-gflags"
-    - run: ROCKSDBTESTS_PLATFORM_DEPENDENT=only make V=1 J=4 -j4 all_but_some_tests check_some
-    - uses: "./.github/actions/post-steps"
-  build-linux-arm-cmake-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: arm64large # GitHub hosted ARM runners do not yet exist
-    env:
-      JAVA_HOME: "/usr/lib/jvm/java-8-openjdk-arm64"
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/install-gflags"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        echo 'export PATH=$JAVA_HOME/bin:$PATH' >> $BASH_ENV
-        which java && java -version
-        which javac && javac -version
-    - name: Build with cmake
-      run: |-
-        mkdir build
-        cd build
-        cmake -DCMAKE_BUILD_TYPE=Release -DWITH_TESTS=0 -DWITH_GFLAGS=1 -DWITH_BENCHMARK_TOOLS=0 -DWITH_TOOLS=0 -DWITH_CORE_TOOLS=1 ..
-        make -j4
-    - name: Build Java with cmake
-      run: |-
-        rm -rf build
-        mkdir build
-        cd build
-        cmake -DJNI=1 -DCMAKE_BUILD_TYPE=Release -DWITH_GFLAGS=1 ..
-        make -j4 rocksdb rocksdbjni
-    - uses: "./.github/actions/post-steps"

.github/workflows/pr-jobs.yml

@@ -1,619 +0,0 @@
-name: facebook/rocksdb/pr-jobs
-on: [push, pull_request]
-jobs:
-  # NOTE: multiple workflows would be recommended, but the current GHA UI in
-  # PRs doesn't make it clear when there's an overall error with a workflow,
-  # making it easy to overlook something broken. Grouping everything into one
-  # workflow minimizes the problem because it will be suspicious if there are
-  # no GHA results.
-  #
-  # The if: ${{ github.repository_owner == 'facebook' }} lines prevent the
-  # jobs from attempting to run on repo forks, because of a few problems:
-  # * runs-on labels are repository (owner) specific, so the job might wait
-  # for days waiting for a runner that simply isn't available.
-  # * Pushes to branches on forks for pull requests (the normal process) would
-  # run the workflow jobs twice: once in the pull-from fork and once for the PR
-  # destination repo. This is wasteful and dumb.
-  # * It is not known how to avoid copy-pasting the line to each job,
-  # increasing the risk of misconfiguration, especially on forks that might
-  # want to run with this GHA setup.
-  #
-  # DEBUGGING WITH SSH: Temporarily add this as a job step, either before the
-  # step of interest without the "if:" line or after the failing step with the
-  # "if:" line. Then use ssh command printed in CI output.
-  #  - name: Setup tmate session # TEMPORARY!
-  #    if: ${{ failure() }}
-  #    uses: mxschmitt/action-tmate@v3
-  #    with:
-  #      limit-access-to-actor: true
-
-  # ======================== Fast Initial Checks ====================== #
-  check-format-and-targets:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4.1.0
-      with:
-        fetch-depth: 0 # Need full checkout to determine merge base
-        fetch-tags: true
-    - uses: "./.github/actions/setup-upstream"
-    - name: Setup Python
-      uses: actions/setup-python@v5
-    - name: Install Dependencies
-      run: python -m pip install --upgrade pip
-    - name: Install argparse
-      run: pip install argparse
-    - name: Download clang-format-diff.py
-      run: wget https://raw.githubusercontent.com/llvm/llvm-project/release/12.x/clang/tools/clang-format/clang-format-diff.py
-    - name: Check format
-      run: VERBOSE_CHECK=1 make check-format
-    - name: Compare buckify output
-      run: make check-buck-targets
-    - name: Simple source code checks
-      run: make check-sources
-  # ========================= Linux With Tests ======================== #
-  build-linux:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: make V=1 J=32 -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-mingw:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
-    - name: Build cmake-mingw
-      run: |-
-        export PATH=$JAVA_HOME/bin:$PATH
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-        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
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-with-folly:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - uses: "./.github/actions/build-folly"
-    - run: "(mkdir build && cd build && cmake -DUSE_FOLLY=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 .. && make V=1 -j20 && ctest -j20)"
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-with-folly-lite-no-test:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - run: "(mkdir build && cd build && cmake -DUSE_FOLLY_LITE=1 -DWITH_GFLAGS=1 .. && make V=1 -j20)"
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-7-with-folly:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - uses: "./.github/actions/build-folly"
-    - run: USE_FOLLY=1 LIB_MODE=static CC=gcc-7 CXX=g++-7 V=1 make -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-7-with-folly-lite-no-test:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - run: USE_FOLLY_LITE=1 CC=gcc-7 CXX=g++-7 V=1 make -j32 all
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-with-folly-coroutines:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    env:
-      CC: gcc-10
-      CXX: g++-10
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - uses: "./.github/actions/setup-folly"
-    - uses: "./.github/actions/build-folly"
-    - run: "(mkdir build && cd build && cmake -DUSE_COROUTINES=1 -DWITH_GFLAGS=1 -DROCKSDB_BUILD_SHARED=0 .. && make V=1 -j20 && ctest -j20)"
-    - uses: "./.github/actions/post-steps"
-  build-linux-cmake-with-benchmark:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: mkdir build && cd build && cmake -DWITH_GFLAGS=1 -DWITH_BENCHMARK=1 .. && make V=1 -j20 && ctest -j20
-    - uses: "./.github/actions/post-steps"
-  build-linux-encrypted_env-no_compression:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: ENCRYPTED_ENV=1 ROCKSDB_DISABLE_SNAPPY=1 ROCKSDB_DISABLE_ZLIB=1 ROCKSDB_DISABLE_BZIP=1 ROCKSDB_DISABLE_LZ4=1 ROCKSDB_DISABLE_ZSTD=1 make V=1 J=32 -j32 check
-    - run: "./sst_dump --help | grep -E -q 'Supported compression types: kNoCompression$' # Verify no compiled in compression\n"
-    - uses: "./.github/actions/post-steps"
-  # ======================== Linux No Test Runs ======================= #
-  build-linux-release:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - run: make V=1 -j32 LIB_MODE=shared release
-    - run: ls librocksdb.so
-    - run: "./db_stress --version"
-    - run: make clean
-    - run: make V=1 -j32 release
-    - run: ls librocksdb.a
-    - run: "./db_stress --version"
-    - run: make clean
-    - run: apt-get remove -y libgflags-dev
-    - run: make V=1 -j32 LIB_MODE=shared release
-    - run: ls librocksdb.so
-    - run: if ./db_stress --version; then false; else true; fi
-    - run: make clean
-    - run: make V=1 -j32 release
-    - run: ls librocksdb.a
-    - run: if ./db_stress --version; then false; else true; fi
-    - uses: "./.github/actions/post-steps"
-  build-linux-release-rtti:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 8-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
-    - run: "./db_stress --version"
-    - run: make clean
-    - run: apt-get remove -y libgflags-dev
-    - run: USE_RTTI=1 DEBUG_LEVEL=0 make V=1 -j16 static_lib tools db_bench
-    - run: if ./db_stress --version; then false; else true; fi
-  build-examples:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - name: Build examples
-      run: make V=1 -j4 static_lib && cd examples && make V=1 -j4
-    - uses: "./.github/actions/post-steps"
-  build-fuzzers:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - name: Build rocksdb lib
-      run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j4 static_lib
-    - name: Build fuzzers
-      run: cd fuzz && make sst_file_writer_fuzzer db_fuzzer db_map_fuzzer
-    - uses: "./.github/actions/post-steps"
-  build-linux-clang-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 8-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - run: CC=clang CXX=clang++ USE_CLANG=1 PORTABLE=1 make V=1 -j16 all
-    - uses: "./.github/actions/post-steps"
-  build-linux-clang-13-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: CC=clang-13 CXX=clang++-13 USE_CLANG=1 make -j32 all microbench
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-8-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: CC=gcc-8 CXX=g++-8 V=1 make -j32 all
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-10-cxx20-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: CC=gcc-10 CXX=g++-10 V=1 ROCKSDB_CXX_STANDARD=c++20 make -j32 all
-    - uses: "./.github/actions/post-steps"
-  build-linux-gcc-11-no_test_run:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: LIB_MODE=static CC=gcc-11 CXX=g++-11 V=1 make -j32 all microbench
-    - uses: "./.github/actions/post-steps"
-  # ======================== Linux Other Checks ======================= #
-  build-linux-clang10-clang-analyze:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 CLANG_ANALYZER="/usr/bin/clang++-10" CLANG_SCAN_BUILD=scan-build-10 USE_CLANG=1 make V=1 -j32 analyze
-    - uses: "./.github/actions/post-steps"
-    - name: compress test report
-      run: tar -cvzf scan_build_report.tar.gz scan_build_report
-      if: failure()
-    - uses: actions/upload-artifact@v4.0.0
-      with:
-        name: scan-build-report
-        path: scan_build_report.tar.gz
-  build-linux-unity-and-headers:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: gcc:latest
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - run: apt-get update -y && apt-get install -y libgflags-dev
-    - name: Unity build
-      run: make V=1 -j8 unity_test
-    - run: make V=1 -j8 -k check-headers
-    - uses: "./.github/actions/post-steps"
-  build-linux-mini-crashtest:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: ulimit -S -n `ulimit -H -n` && make V=1 -j8 CRASH_TEST_EXT_ARGS='--duration=960 --max_key=2500000' blackbox_crash_test_with_atomic_flush
-    - uses: "./.github/actions/post-steps"
-  # ======================= Linux with Sanitizers ===================== #
-  build-linux-clang10-asan:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 32-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: COMPILE_WITH_ASAN=1 CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-clang10-ubsan:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: COMPILE_WITH_UBSAN=1 OPT="-fsanitize-blacklist=.circleci/ubsan_suppression_list.txt" CC=clang-10 CXX=clang++-10 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 ubsan_check
-    - uses: "./.github/actions/post-steps"
-  build-linux-clang10-mini-tsan:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 32-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: COMPILE_WITH_TSAN=1 CC=clang-13 CXX=clang++-13 ROCKSDB_DISABLE_ALIGNED_NEW=1 USE_CLANG=1 make V=1 -j32 check
-    - uses: "./.github/actions/post-steps"
-  build-linux-static_lib-alt_namespace-status_checked:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 16-core-ubuntu
-    container:
-      image: zjay437/rocksdb:0.6
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/pre-steps"
-    - run: ASSERT_STATUS_CHECKED=1 TEST_UINT128_COMPAT=1 ROCKSDB_MODIFY_NPHASH=1 LIB_MODE=static OPT="-DROCKSDB_NAMESPACE=alternative_rocksdb_ns" make V=1 -j24 check
-    - uses: "./.github/actions/post-steps"
-  # ========================= MacOS build only ======================== #
-  build-macos:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: macos-13
-    env:
-      ROCKSDB_DISABLE_JEMALLOC: 1
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: maxim-lobanov/setup-xcode@v1.6.0
-      with:
-        xcode-version: 14.3.1
-    - uses: "./.github/actions/increase-max-open-files-on-macos"
-    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/pre-steps-macos"
-    - name: Build
-      run: ulimit -S -n `ulimit -H -n` && make V=1 J=16 -j16 all
-    - uses: "./.github/actions/post-steps"
-  # ========================= MacOS with Tests ======================== #
-  build-macos-cmake:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: macos-13
-    strategy:
-      matrix:
-        run_even_tests: [true, false]
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: maxim-lobanov/setup-xcode@v1.6.0
-      with:
-        xcode-version: 14.3.1
-    - uses: "./.github/actions/increase-max-open-files-on-macos"
-    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/pre-steps-macos"
-    - name: cmake generate project file
-      run: ulimit -S -n `ulimit -H -n` && mkdir build && cd build && cmake -DWITH_GFLAGS=1 ..
-    - name: Build tests
-      run: cd build && make V=1 -j16
-    - name: Run even tests
-      run: ulimit -S -n `ulimit -H -n` && cd build && ctest -j16 -I 0,,2
-      if: ${{ matrix.run_even_tests }}
-    - name: Run odd tests
-      run: ulimit -S -n `ulimit -H -n` && cd build && ctest -j16 -I 1,,2
-      if: ${{ ! matrix.run_even_tests  }}
-    - uses: "./.github/actions/post-steps"
-  # ======================== Windows with Tests ======================= #
-  # NOTE: some windows jobs are in "nightly" to save resources
-  build-windows-vs2019:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: windows-2019
-    env:
-      CMAKE_GENERATOR: Visual Studio 16 2019
-      CMAKE_PORTABLE: 1
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/windows-build-steps"
-  # ============================ Java Jobs ============================ #
-  build-linux-java:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: evolvedbinary/rocksjava:centos6_x64-be
-      options: --shm-size=16gb
-    steps:
-    # The docker image is intentionally based on an OS that has an older GLIBC version.
-    # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step.
-    - name: Checkout
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        chown `whoami` . || true
-        git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git .
-        git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }}
-        git checkout --progress --force ${{ github.ref }}
-        git log -1 --format='%H'
-    - uses: "./.github/actions/pre-steps"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: Test RocksDBJava
-      run: scl enable devtoolset-7 'make V=1 J=8 -j8 jtest'
-    # NOTE: post-steps skipped because of compatibility issues with docker image
-  build-linux-java-static:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: evolvedbinary/rocksjava:centos6_x64-be
-      options: --shm-size=16gb
-    steps:
-    # The docker image is intentionally based on an OS that has an older GLIBC version.
-    # That GLIBC is incompatibile with GitHub's actions/checkout. Thus we implement a manual checkout step.
-    - name: Checkout
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        chown `whoami` . || true
-        git clone --no-checkout https://oath2:$GH_TOKEN@github.com/${{ github.repository }}.git .
-        git -c protocol.version=2 fetch --update-head-ok --no-tags --prune --no-recurse-submodules --depth=1 origin +${{ github.sha }}:${{ github.ref }}
-        git checkout --progress --force ${{ github.ref }}
-        git log -1 --format='%H'
-    - uses: "./.github/actions/pre-steps"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: Build RocksDBJava Static Library
-      run: scl enable devtoolset-7 'make V=1 J=8 -j8 rocksdbjavastatic'
-    # NOTE: post-steps skipped because of compatibility issues with docker image
-  build-macos-java:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: macos-13
-    env:
-      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
-      ROCKSDB_DISABLE_JEMALLOC: 1
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: maxim-lobanov/setup-xcode@v1.6.0
-      with:
-        xcode-version: 14.3.1
-    - uses: "./.github/actions/increase-max-open-files-on-macos"
-    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/install-jdk8-on-macos"
-    - uses: "./.github/actions/pre-steps-macos"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: Test RocksDBJava
-      run: make V=1 J=16 -j16 jtest
-    - uses: "./.github/actions/post-steps"
-  build-macos-java-static:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: macos-13
-    env:
-      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: maxim-lobanov/setup-xcode@v1.6.0
-      with:
-        xcode-version: 14.3.1
-    - uses: "./.github/actions/increase-max-open-files-on-macos"
-    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/install-jdk8-on-macos"
-    - uses: "./.github/actions/pre-steps-macos"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: Build RocksDBJava x86 and ARM Static Libraries
-      run: make V=1 J=16 -j16 rocksdbjavastaticosx
-    - uses: "./.github/actions/post-steps"
-  build-macos-java-static-universal:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on: macos-13
-    env:
-      JAVA_HOME: "/Library/Java/JavaVirtualMachines/liberica-jdk-8.jdk/Contents/Home"
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: maxim-lobanov/setup-xcode@v1.6.0
-      with:
-        xcode-version: 14.3.1
-    - uses: "./.github/actions/increase-max-open-files-on-macos"
-    - uses: "./.github/actions/install-gflags-on-macos"
-    - uses: "./.github/actions/install-jdk8-on-macos"
-    - uses: "./.github/actions/pre-steps-macos"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: Build RocksDBJava Universal Binary Static Library
-      run: make V=1 J=16 -j16 rocksdbjavastaticosx_ub
-    - uses: "./.github/actions/post-steps"
-  build-linux-java-pmd:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu
-    container:
-      image: evolvedbinary/rocksjava:rockylinux8_x64-be
-      options: --shm-size=16gb
-    steps:
-    - uses: actions/checkout@v4.1.0
-    - uses: "./.github/actions/install-maven"
-    - uses: "./.github/actions/pre-steps"
-    - name: Set Java Environment
-      run: |-
-        echo "JAVA_HOME=${JAVA_HOME}"
-        which java && java -version
-        which javac && javac -version
-    - name: PMD RocksDBJava
-      run: make V=1 J=8 -j8 jpmd
-    - uses: actions/upload-artifact@v4.0.0
-      with:
-        name: pmd-report
-        path: "${{ github.workspace }}/java/target/pmd.xml"
-    - uses: actions/upload-artifact@v4.0.0
-      with:
-        name: maven-site
-        path: "${{ github.workspace }}/java/target/site"
-  build-linux-arm:
-    if: ${{ github.repository_owner == 'facebook' }}
-    runs-on:
-      labels: 4-core-ubuntu-arm
-    steps:
-      - uses: actions/checkout@v4.1.0
-      - uses: "./.github/actions/pre-steps"
-      - run: sudo apt-get update && sudo apt-get install -y build-essential
-      - run: ROCKSDBTESTS_PLATFORM_DEPENDENT=only make V=1 J=4 -j4 all_but_some_tests check_some
-      - uses: "./.github/actions/post-steps"

.github/workflows/sanity_check.yml

@@ -0,0 +1,44 @@
+name: Check buck targets and code format
+on: [push, pull_request]
+jobs:
+  check:
+    name: Check TARGETS file and code format
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout feature branch
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Fetch from upstream
+      run: |
+        git remote add upstream https://github.com/facebook/rocksdb.git && git fetch upstream
+
+    - name: Where am I
+      run: |
+        echo git status && git status
+        echo "git remote -v" && git remote -v
+        echo git branch && git branch
+
+    - name: Setup Python
+      uses: actions/setup-python@v1
+
+    - name: Install Dependencies
+      run: python -m pip install --upgrade pip
+
+    - name: Install argparse
+      run: pip install argparse
+
+    - name: Download clang-format-diff.py
+      uses: wei/wget@v1
+      with:
+        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
+
+    - name: Compare buckify output
+      run: make check-buck-targets
+
+    - name: Simple source code checks
+      run: make check-sources

.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
@@ -85,7 +86,6 @@ fbcode/
 fbcode
 buckifier/*.pyc
 buckifier/__pycache__
-.arcconfig
 
 compile_commands.json
 clang-format-diff.py
@@ -95,6 +95,3 @@ fuzz/proto/gen/
 fuzz/crash-*
 
 cmake-build-*
-third-party/folly/
-.cache
-*.sublime-*

.travis.yml

@@ -0,0 +1,254 @@
+dist: xenial
+language: cpp
+os:
+  - linux
+arch:
+  - arm64
+  - ppc64le
+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
+    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: 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: 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: 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: 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/
+    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: 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: 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: 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: 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: arm64
+    env: JOB_NAME=status_checked
+  - if: type = pull_request AND commit_message !~ /FULL_CI/
+    os: linux
+    arch: ppc64le
+    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

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.
 

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:
 
@@ -17,18 +17,15 @@ There are few options when compiling RocksDB:
 * `make check` will compile and run all the unit tests. `make check` will compile RocksDB in debug mode.
 
 * `make all` will compile our static library, and all our tools and unit tests. Our tools
-depend on gflags 2.2.0 or newer. You will need to have gflags installed to run `make all`. This will compile RocksDB in debug mode. Don't
+depend on gflags. You will need to have gflags installed to run `make all`. This will compile RocksDB in debug mode. Don't
 use binaries compiled by `make all` in production.
 
-* By default the binary we produce is optimized for the CPU you're compiling on
-(`-march=native` or the equivalent). To build a binary compatible with the most
-general architecture supported by your CPU and compiler, set `PORTABLE=1` for
-the build, but performance will suffer as many operations benefit from newer
-and wider instructions. In addition to `PORTABLE=0` (default) and `PORTABLE=1`,
-it can be set to an architecture name recognized by your compiler. For example,
-on 64-bit x86, a reasonable compromise is `PORTABLE=haswell` which supports
-many or most of the available optimizations while still being compatible with
-most processors made since roughly 2013.
+* By default the binary we produce is optimized for the platform you're compiling on
+(`-march=native` or the equivalent). SSE4.2 will thus be enabled automatically if your
+CPU supports it. To print a warning if your CPU does not support SSE4.2, build with
+`USE_SSE=1 make static_lib` or, if using CMake, `cmake -DFORCE_SSE42=ON`. If you want
+to build a portable binary, add `PORTABLE=1` before your make commands, like this:
+`PORTABLE=1 make static_lib`.
 
 ## Dependencies
 
@@ -50,17 +47,10 @@ most processors made since roughly 2013.
 
 * 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.
-* You can do the following to install Google benchmark. These commands are copied from `./build_tools/ubuntu20_image/Dockerfile`:
-
-`$ git clone --depth 1 --branch v1.7.0 https://github.com/google/benchmark.git ~/benchmark`
-
-`$ cd ~/benchmark && mkdir build && cd build && cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release -DBENCHMARK_ENABLE_GTEST_TESTS=0 && ninja && ninja install`
-
 ## 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)
@@ -72,12 +62,13 @@ most processors made since roughly 2013.
     * 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
               cd gflags
-              git checkout v2.2.0
+              git checkout v2.0
               ./configure && make && sudo make install
 
       **Notice**: Once installed, please add the include path for gflags to your `CPATH` environment variable and the
@@ -122,10 +113,11 @@ most processors made since roughly 2013.
               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 gcc48 --use-llvm` to install gcc 4.8 (or higher).
     * run `brew install rocksdb`
 
 * **FreeBSD** (11.01):
@@ -168,39 +160,35 @@ most processors made since roughly 2013.
 
     * Install the dependencies for RocksDB:
 
-      `pkg_add gmake gflags snappy bzip2 lz4 zstd git bash findutils gnuwatch`
+        pkg_add gmake gflags snappy bzip2 lz4 zstd git jdk bash findutils gnuwatch 
 
     * Build RocksDB from source:
 
-        ```bash
         cd ~
         git clone https://github.com/facebook/rocksdb.git
         cd rocksdb
         gmake static_lib
-        ```
 
     * Build RocksJava from source (optional):
-        * In OpenBSD, JDK depends on XWindows system, so please check that you installed OpenBSD with `xbase` package.
-        * Install dependencies : `pkg_add -v jdk%1.8`
-        ```bash
+
         cd rocksdb
         export JAVA_HOME=/usr/local/jdk-1.8.0
         export PATH=$PATH:/usr/local/jdk-1.8.0/bin
-        gmake rocksdbjava SHA256_CMD='sha256 -q'
-        ```
+        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"
@@ -211,9 +199,9 @@ most processors made since roughly 2013.
              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
@@ -222,3 +210,4 @@ most processors made since roughly 2013.
              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,9 +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.
-* [IPPCP](https://github.com/intel/ippcp-plugin-rocksdb): a plugin to enable encryption on RocksDB based on Intel optimized open source IPP-Crypto library.
-* [encfs](https://github.com/pegasus-kv/encfs): a plugin to enable encryption on RocksDB based on OpenSSL library.

README.md

@@ -1,6 +1,9 @@
 ## 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)
 
 RocksDB is developed and maintained by Facebook Database Engineering Team.
 It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
@@ -22,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

@@ -15,28 +15,6 @@ At Facebook, we use RocksDB as storage engines in multiple data management servi
 
 [2] https://code.facebook.com/posts/357056558062811/logdevice-a-distributed-data-store-for-logs/
 
-## Bilibili
-[Bilibili](bilibili.com) [uses](https://www.alluxio.io/blog/when-ai-meets-alluxio-at-bilibili-building-an-efficient-ai-platform-for-data-preprocessing-and-model-training/) Alluxio to speed up its ML training workloads, and Alluxio uses RocksDB to store its filesystem metadata, so Bilibili uses RocksDB.
-
-Bilibili's [real-time platform](https://www.alibabacloud.com/blog/architecture-and-practices-of-bilibilis-real-time-platform_596676) uses Flink, and uses RocksDB as Flink's state store.
-
-## TikTok
-TikTok, or its parent company ByteDance, uses RocksDB as the storage engine for some storage systems, such as its distributed graph database [ByteGraph](https://vldb.org/pvldb/vol15/p3306-li.pdf). 
-
-Also, TikTok uses [Alluxio](alluxio.io) to [speed up Presto queries](https://www.alluxio.io/resources/videos/improving-presto-performance-with-alluxio-at-tiktok/), and Alluxio stores the files' metadata in RocksDB.
-
-## FoundationDB
-[FoundationDB](https://www.foundationdb.org/) [uses](https://github.com/apple/foundationdb/blob/377f1f692da6ab2fe5bdac57035651db3e5fb66d/fdbserver/KeyValueStoreRocksDB.actor.cpp) RocksDB to implement a [key-value store interface](https://github.com/apple/foundationdb/blob/377f1f692da6ab2fe5bdac57035651db3e5fb66d/fdbserver/KeyValueStoreRocksDB.actor.cpp#L1127) in its server backend.
-
-## Apple
-Apple [uses](https://opensource.apple.com/projects/foundationdb/) FoundationDB, so it also uses RocksDB.
-
-## Snowflake
-Snowflake [uses](https://www.snowflake.com/blog/how-foundationdb-powers-snowflake-metadata-forward/) FoundationDB, so it also uses RocksDB.
-
-## Microsoft
-The Bing search engine from Microsoft uses RocksDB as the storage engine for its web data platform: https://blogs.bing.com/Engineering-Blog/october-2021/RocksDB-in-Microsoft-Bing
-
 ## LinkedIn
 Two different use cases at Linkedin are using RocksDB as a storage engine:
 
@@ -48,9 +26,6 @@ Learn more about those use cases in a Tech Talk by Ankit Gupta and Naveen Somasu
 ## Yahoo
 Yahoo is using RocksDB as a storage engine for their biggest distributed data store Sherpa. Learn more about it here: http://yahooeng.tumblr.com/post/120730204806/sherpa-scales-new-heights
 
-## Tencent
-[PaxosStore](https://github.com/Tencent/paxosstore) is a distributed database supporting WeChat. It uses RocksDB as its storage engine.
-
 ## Baidu
 [Apache Doris](http://doris.apache.org/master/en/) is a MPP analytical database engine released by Baidu. It [uses RocksDB](http://doris.apache.org/master/en/administrator-guide/operation/tablet-meta-tool.html) to manage its tablet's metadata.
 
@@ -104,18 +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.
 
-## TiDB
-[TiDB](https://github.com/pingcap/tidb) uses the TiKV distributed key-value database, so it uses RocksDB.
-
-## PingCAP
-[PingCAP](https://www.pingcap.com/) is the company behind TiDB, its cloud database service uses RocksDB.
-
-## Apache Spark
-[Spark Structured Streaming](https://docs.databricks.com/structured-streaming/rocksdb-state-store.html) uses RocksDB as the local state store.
-
-## Databricks
-[Databricks](https://www.databricks.com/) [replaces AWS RDS with TiDB](https://www.pingcap.com/case-study/how-databricks-tackles-the-scalability-limit-with-a-mysql-alternative/) for scalability, so it uses RocksDB.
-
 ## 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.
 
@@ -152,21 +115,12 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed
 ## ArangoDB
 [ArangoDB](https://www.arangodb.com/) is a native multi-model database with flexible data models for documents, graphs, and key-values, for building high performance applications using a convenient SQL-like query language or JavaScript extensions. It uses RocksDB as its storage engine.
 
-## Qdrant
-[Qdrant](https://qdrant.tech/) is an open source vector database, it [uses](https://qdrant.tech/documentation/concepts/storage/) RocksDB as its persistent storage.
-
 ## Milvus
 [Milvus](https://milvus.io/) is an open source vector database for unstructured data. It uses RocksDB not only as one of the supported kv storage engines, but also as a message queue.
 
 ## Kafka
 [Kafka](https://kafka.apache.org/) is an open-source distributed event streaming platform, it uses RocksDB to store state in Kafka Streams: https://www.confluent.io/blog/how-to-tune-rocksdb-kafka-streams-state-stores-performance/.
 
-## 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.
-
-## Apache Kvrocks
-
-[Apache Kvrocks](https://github.com/apache/kvrocks) is an open-source distributed key-value NoSQL database built on top of RocksDB. It serves as a cost-saving and capacity-increasing alternative drop-in replacement for Redis.
-
 ## 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,136 +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",
-        [],
-        deps=[
-            ":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=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"]
-    )
-    # cache_bench binary
-    TARGETS.add_binary(
-        "cache_bench", ["cache/cache_bench.cc"], [":rocksdb_cache_bench_tools_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)
 
@@ -280,30 +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.export_file("tools/db_crashtest.py")
+                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))
@@ -316,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
 
@@ -333,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,156 +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:
+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,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    compiler_flags = ROCKSDB_COMPILER_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    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 export_file(self, name):
-        with open(self.path, "a") as targets_file:
-            targets_file.write(
-                targets_cfg.export_file_template.format(name=name)
-            )
+    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,43 +1,220 @@
 # 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.
-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,
+    os_deps = ROCKSDB_OS_DEPS,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    deps = [{deps}],
+    external_deps = ROCKSDB_EXTERNAL_DEPS{extra_external_deps},
+    link_whole = {link_whole},
+)
 """
 
 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,
+    os_deps = ROCKSDB_OS_DEPS,
+    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+    include_paths = ROCKSDB_INCLUDE_PATHS,
+    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})
+# [test_name, test_src, test_type, extra_deps, extra_compiler_flags]
+ROCKS_TESTS = [
+{tests}]
 
-"""
-
-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})
-
-"""
-
-export_file_template = """
-export_file(name = "{name}")
+# 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,
+        os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
+        compiler_flags = ROCKSDB_COMPILER_FLAGS + extra_compiler_flags,
+        preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
+        include_paths = ROCKSDB_INCLUDE_PATHS,
+        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:
-    """Generate colorful strings on terminal"""
-
-    HEADER = "\033[95m"
-    BLUE = "\033[94m"
-    GREEN = "\033[92m"
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
+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'
 
     @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:
 
 
 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,12 +58,20 @@ 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
+    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
+      source "$PWD/build_tools/fbcode_config_platform009.sh"
     fi
-    source "$PWD/build_tools/fbcode_config_platform010.sh"
 fi
 
 # Delete existing output, if it exists
@@ -148,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
@@ -163,6 +171,24 @@ case "$TARGET_OS" in
             PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
         fi
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt -ldl"
+        if test -z "$ROCKSDB_USE_IO_URING"; then
+            ROCKSDB_USE_IO_URING=1
+        fi
+        if test "$ROCKSDB_USE_IO_URING" -ne 0; then
+            # check for liburing
+            $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o /dev/null 2>/dev/null  <<EOF
+              #include <liburing.h>
+              int main() {
+                struct io_uring ring;
+                io_uring_queue_init(1, &ring, 0);
+                return 0;
+              }
+EOF
+            if [ "$?" = 0 ]; then
+                PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring"
+                COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
+            fi
+        fi
         # PORT_FILES=port/linux/linux_specific.cc
         ;;
     SunOS)
@@ -245,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.
@@ -253,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() {
@@ -275,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
@@ -290,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() {}
@@ -299,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() {}
@@ -308,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() {}
@@ -321,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
@@ -334,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
@@ -347,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() {}
@@ -374,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() {}
@@ -388,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
@@ -401,7 +426,7 @@ EOF
 
     if ! test $ROCKSDB_DISABLE_JEMALLOC; then
         # Test whether jemalloc is available
-        if echo 'int main() {}' | $CXX $PLATFORM_CXXFLAGS $LDFLAGS -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
@@ -410,26 +435,19 @@ EOF
             WITH_JEMALLOC_FLAG=1
             # check for JEMALLOC installed with HomeBrew
             if [ "$PLATFORM" == "OS_MACOSX" ]; then
-                if [ "$TARGET_ARCHITECTURE" = "arm64" ]; then
-                    # on M1 Macs, homebrew installs here instead of /usr/local
-                    JEMALLOC_PREFIX="/opt/homebrew"
-                else
-                    JEMALLOC_PREFIX="/usr/local"
-                fi
                 if hash brew 2>/dev/null && brew ls --versions jemalloc > /dev/null; then
                     JEMALLOC_VER=$(brew ls --versions jemalloc | tail -n 1 | cut -f 2 -d ' ')
-                    JEMALLOC_INCLUDE="-I${JEMALLOC_PREFIX}/Cellar/jemalloc/${JEMALLOC_VER}/include"
-                    JEMALLOC_LIB="${JEMALLOC_PREFIX}/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a"
-                    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -L${JEMALLOC_PREFIX}/lib $JEMALLOC_LIB"
-                    JAVA_LDFLAGS="$JAVA_LDFLAGS -L${JEMALLOC_PREFIX}/lib $JEMALLOC_LIB"
-                    JAVA_STATIC_LDFLAGS="$JAVA_STATIC_LDFLAGS -L${JEMALLOC_PREFIX}/lib $JEMALLOC_LIB"
+                    JEMALLOC_INCLUDE="-I/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/include"
+                    JEMALLOC_LIB="/usr/local/Cellar/jemalloc/${JEMALLOC_VER}/lib/libjemalloc_pic.a"
+                    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $JEMALLOC_LIB"
+                    JAVA_STATIC_LDFLAGS="$JAVA_STATIC_LDFLAGS $JEMALLOC_LIB"
                 fi
             fi
         fi
     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"
@@ -438,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);
@@ -453,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);
@@ -469,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;
@@ -484,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];
@@ -496,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];
@@ -513,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;
           }
@@ -525,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);
@@ -539,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();
@@ -553,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);
@@ -567,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
@@ -577,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
@@ -585,42 +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
-
-    if test -z "$ROCKSDB_USE_IO_URING"; then
-        ROCKSDB_USE_IO_URING=1
-    fi
-    if [ "$ROCKSDB_USE_IO_URING" -ne 0 -a "$PLATFORM" = OS_LINUX ]; then
-        # check for liburing
-        $CXX $PLATFORM_CXXFLAGS -x c++ - -luring -o test.o 2>/dev/null  <<EOF
-          #include <liburing.h>
-          int main() {
-            struct io_uring ring;
-            io_uring_queue_init(1, &ring, 0);
-            return 0;
-          }
-EOF
-        if [ "$?" = 0 ]; then
-            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -luring"
-            COMMON_FLAGS="$COMMON_FLAGS -DROCKSDB_IOURING_PRESENT"
-        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 -o "$TARGET_OS" = OpenBSD ] && [ "$TARGET_ARCHITECTURE" = arm64 -o "$TARGET_ARCHITECTURE" = i386 ]; }; then
+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
@@ -628,60 +617,57 @@ EOF
   fi
 fi
 
-if [ "$PORTABLE" == "" ] || [ "$PORTABLE" == 0 ]; then
+# 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
     POWER=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+`
     COMMON_FLAGS="$COMMON_FLAGS -mcpu=$POWER -mtune=$POWER "
+  elif test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
+    COMMON_FLAGS="$COMMON_FLAGS -march=z10 "
   elif test -n "`echo $TARGET_ARCHITECTURE | grep -e^arm -e^aarch64`"; then
     # TODO: Handle this with approprite options.
     COMMON_FLAGS="$COMMON_FLAGS"
   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^aarch64`"; 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
-      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 -E '^isa\s*:' | head -1 | cut --delimiter=: -f 2 | cut -b 2-)
-    if [ -n "${RISCV_ISA}" ]; then
-      COMMON_FLAGS="$COMMON_FLAGS -march=${RISC_ISA}"
-    fi
   elif [ "$TARGET_OS" == "IOS" ]; then
     COMMON_FLAGS="$COMMON_FLAGS"
+  elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then
+    # TODO: Not sure why we don't use -march=native on these OSes
+    if test "$USE_SSE"; then
+      TRY_SSE_ETC="1"
+    fi
   else
     COMMON_FLAGS="$COMMON_FLAGS -march=native "
   fi
 else
-  # PORTABLE specified
-  if [ "$PORTABLE" == 1 ]; then
-    if test -n "`echo $TARGET_ARCHITECTURE | grep ^s390x`"; then
-      COMMON_FLAGS="$COMMON_FLAGS -march=z196 "
-    elif test -n "`echo $TARGET_ARCHITECTURE | grep ^riscv64`"; then
-      COMMON_FLAGS="$COMMON_FLAGS -march=rv64gc"
-    elif test "$USE_SSE"; then
-      # USE_SSE is DEPRECATED
-      # This is a rough approximation of the old USE_SSE behavior
-      COMMON_FLAGS="$COMMON_FLAGS -march=haswell"
-    fi
-    # Other than those cases, not setting -march= here.
-  else
-    # Assume PORTABLE is a minimum assumed cpu type, e.g. PORTABLE=haswell
-    COMMON_FLAGS="$COMMON_FLAGS -march=${PORTABLE}"
+  # PORTABLE=1
+  if test "$USE_SSE"; then
+    TRY_SSE_ETC="1"
   fi
 
   if [[ "${PLATFORM}" == "OS_MACOSX" ]]; then
-    # For portability compile for macOS 10.14 (2018) or newer
-    COMMON_FLAGS="$COMMON_FLAGS -mmacosx-version-min=10.14"
-    PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -mmacosx-version-min=10.14"
-    # -mmacosx-version-min must come first here.
-    PLATFORM_SHARED_LDFLAGS="-mmacosx-version-min=10.14 $PLATFORM_SHARED_LDFLAGS"
-    PLATFORM_CMAKE_FLAGS="-DCMAKE_OSX_DEPLOYMENT_TARGET=10.14"
-    JAVA_STATIC_DEPS_COMMON_FLAGS="-mmacosx-version-min=10.14"
+    # 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"
@@ -705,7 +691,102 @@ EOF
   fi
 fi
 
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o test.o 2>/dev/null <<EOF
+if test "$TRY_SSE_ETC"; then
+  # The USE_SSE flag now means "attempt to compile with widely-available
+  # Intel architecture extensions utilized by specific optimizations in the
+  # source code." It's a qualifier on PORTABLE=1 that means "mostly portable."
+  # It doesn't even really check that your current CPU is compatible.
+  #
+  # SSE4.2 available since nehalem, ca. 2008-2010
+  # Includes POPCNT for BitsSetToOne, BitParity
+  TRY_SSE42="-msse4.2"
+  # PCLMUL available since westmere, ca. 2010-2011
+  TRY_PCLMUL="-mpclmul"
+  # AVX2 available since haswell, ca. 2013-2015
+  TRY_AVX2="-mavx2"
+  # BMI available since haswell, ca. 2013-2015
+  # Primarily for TZCNT for CountTrailingZeroBits
+  TRY_BMI="-mbmi"
+  # LZCNT available since haswell, ca. 2013-2015
+  # For FloorLog2
+  TRY_LZCNT="-mlzcnt"
+fi
+
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  #include <nmmintrin.h>
+  int main() {
+    volatile uint32_t x = _mm_crc32_u32(0, 0);
+    (void)x;
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42"
+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 /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  #include <wmmintrin.h>
+  int main() {
+    const auto a = _mm_set_epi64x(0, 0);
+    const auto b = _mm_set_epi64x(0, 0);
+    const auto c = _mm_clmulepi64_si128(a, b, 0x00);
+    auto d = _mm_cvtsi128_si64(c);
+    (void)d;
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL"
+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 /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  #include <immintrin.h>
+  int main() {
+    const auto a = _mm256_setr_epi32(0, 1, 2, 3, 4, 7, 6, 5);
+    const auto b = _mm256_permutevar8x32_epi32(a, a);
+    (void)b;
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS $TRY_AVX2 -DHAVE_AVX2"
+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 /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  #include <immintrin.h>
+  int main(int argc, char *argv[]) {
+    (void)argv;
+    return (int)_tzcnt_u64((uint64_t)argc);
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS $TRY_BMI -DHAVE_BMI"
+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 /dev/null 2>/dev/null <<EOF
+  #include <cstdint>
+  #include <immintrin.h>
+  int main(int argc, char *argv[]) {
+    (void)argv;
+    return (int)_lzcnt_u64((uint64_t)argc);
+  }
+EOF
+if [ "$?" = 0 ]; then
+  COMMON_FLAGS="$COMMON_FLAGS $TRY_LZCNT -DHAVE_LZCNT"
+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 /dev/null 2>/dev/null <<EOF
   #include <cstdint>
   int main() {
     uint64_t a = 0xffffFFFFffffFFFF;
@@ -718,12 +799,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
@@ -731,27 +831,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"
 
@@ -791,8 +870,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"
@@ -804,8 +881,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

@@ -0,0 +1,21 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+GCC_BASE=/mnt/gvfs/third-party2/gcc/1795efe5f06778c15a92c8f9a2aba5dc496d9d4d/9.x/centos7-native/3bed279
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/7318eaac22659b6ff2fe43918e4b69fd0772a8a7/9.0.0/platform009/651ee30
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/4959b39cfbe5965a37c861c4c327fa7c5c759b87/9.x/platform009/9202ce7
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/45ce3375cdc77ecb2520bbf8f0ecddd3f98efd7a/2.30/platform009/f259413
+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/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/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
+LIBURING_BASE=/mnt/gvfs/third-party2/liburing/70dbd9cfee63a25611417d09433a86d7711b3990/20200729/platform009/7f3b187
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/32b8a2407b634df3f8f948ba373fc4acc6a18296/fb/platform009/da39a3e
+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/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/62de5a92e5f23c661c3d4b9f322e04eb14e7a5bd/11.x/centos8-native/886b5eb
-CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/1f6edd1ff15c99c861afc8f3cd69054cd974dd64/15/platform010/72a2ff8
-LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/d1129753c8361ac8e9453c0f4291337a4507ebe6/11.x/platform010/5684a5a
-GLIBC_BASE=/mnt/gvfs/third-party2/glibc/fed6e93d87571fb162734c86636119d45a398963/2.34/platform010/f259413
-SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/31a346126a1f3b64812c362511cb04cc1bd40855/1.1.8/platform010/76ebdda
-ZLIB_BASE=/mnt/gvfs/third-party2/zlib/0c65c05468b5a38cef1a106a1f526463e120c8dd/1.2.8/platform010/76ebdda
-BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/09703139cfc376bd8a82642385a0e97726b28287/1.0.6/platform010/76ebdda
-LZ4_BASE=/mnt/gvfs/third-party2/lz4/ff23d17b932725cc1734a14896a8b67c518ba169/1.9.4/platform010/76ebdda
-ZSTD_BASE=/mnt/gvfs/third-party2/zstd/576397d8b1d9cea7306ad1e454d5e55caaa2ff1c/1.4.x/platform010/64091f4
-GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/fecac07861cb829f5e60dbeff0503d3272db73c0/2.2.0/platform010/76ebdda
-JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/0bb3f5756788ce26e2e16a1cb2f2af2c59b51abe/master/platform010/f57cc4a
-NUMA_BASE=/mnt/gvfs/third-party2/numa/5b602edd46fda54cdd7ea45f77dbe4061206e174/2.0.11/platform010/76ebdda
-LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/97cac22a149c2e202917e05d44e87e516b68216f/1.4/platform010/5074a48
-TBB_BASE=/mnt/gvfs/third-party2/tbb/53953ebc4e3eda85ad6fc3e429ba146035e97b90/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/624a2f8f6c93c3c1df8aa4a6255d8202631a6c80/fb/platform010/da39a3e
-BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/39579e8603b48b3540f8b0633f43adf29acccb8b/2.37/centos8-native/da39a3e
-VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/cd9cc656d49ecb53797ce4d055e49fde29fd57ff/3.19.0/platform010/76ebdda
-LUA_BASE=/mnt/gvfs/third-party2/lua/363787fa5cac2a8aa20638909210443278fa138e/5.3.4/platform010/9079c97

build_tools/error_filter.py

@@ -3,38 +3,40 @@
 #  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
 
 
-class ErrorParserBase:
+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/"
@@ -113,7 +103,7 @@ CLANG_LIB="$CLANG_BASE/lib"
 CLANG_SRC="$CLANG_BASE/../../src"
 
 CLANG_ANALYZER="$CLANG_BIN/clang++"
-CLANG_SCAN_BUILD="$CLANG_BIN/scan-build
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build"
 
 if [ -z "$USE_CLANG" ]; then
   # gcc
@@ -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"
+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

@@ -9,87 +9,97 @@
 
 
 BASEDIR=`dirname $BASH_SOURCE`
-source "$BASEDIR/dependencies_platform010.sh"
+source "$BASEDIR/dependencies_platform009.sh"
 
-# Disallow using libraries from default locations as they might not be compatible with platform010 libraries.
-CFLAGS=" --sysroot=/DOES/NOT/EXIST"
+CFLAGS=""
 
 # libgcc
-LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/trunk"
-LIBGCC_LIBS=" -L $LIBGCC_BASE/lib -B$LIBGCC_BASE/lib/gcc/x86_64-facebook-linux/trunk/"
+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"
-GLIBC_LIBS+=" -B$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
-  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"
+  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"
+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
@@ -110,7 +120,7 @@ CLANG_LIB="$CLANG_BASE/lib"
 CLANG_SRC="$CLANG_BASE/../../src"
 
 CLANG_ANALYZER="$CLANG_BIN/clang++"
-CLANG_SCAN_BUILD="$CLANG_BIN/scan-build"
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/clang/tools/scan-build/bin/scan-build"
 
 if [ -z "$USE_CLANG" ]; then
   # gcc
@@ -118,19 +128,9 @@ if [ -z "$USE_CLANG" ]; then
   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+=" -B$BINUTILS"
   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
@@ -139,28 +139,28 @@ else
   CXX="$CLANG_BIN/clang++"
   AR="$CLANG_BIN/llvm-ar"
 
+  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
+
   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 $LIBGCC_BASE/include/c++/9.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/9.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
 
-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 -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"
-EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform010/lib/ld.so"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform009/lib/ld.so"
 EXEC_LDFLAGS+=" $LIBUNWIND"
-EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform010/lib"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform009/lib"
 EXEC_LDFLAGS+=" -Wl,-rpath=$GCC_BASE/lib64"
 # required by libtbb
 EXEC_LDFLAGS+=" -ldl"
@@ -172,4 +172,8 @@ EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $BZIP_LIBS $LZ4_LIBS $ZSTD_LIBS $GF
 
 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 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

@@ -127,21 +127,21 @@ uncommitted_code=`git diff HEAD`
 if [ -z "$uncommitted_code" ]
 then
   # Attempt to get name of facebook/rocksdb.git remote.
-  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(LC_ALL=POSIX LANG=POSIX git remote -v | grep 'facebook/rocksdb.git' | head -n 1 | cut -f 1)"
+  [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE="$(git remote -v | grep 'facebook/rocksdb.git' | head -n 1 | cut -f 1)"
   # Fall back on 'origin' if that fails
   [ "$FORMAT_REMOTE" ] || FORMAT_REMOTE=origin
   # Use main branch from that remote
-  [ "$FORMAT_UPSTREAM" ] || FORMAT_UPSTREAM="$FORMAT_REMOTE/$(LC_ALL=POSIX LANG=POSIX git remote show $FORMAT_REMOTE | sed -n '/HEAD branch/s/.*: //p')"
+  [ "$FORMAT_UPSTREAM" ] || FORMAT_UPSTREAM="$FORMAT_REMOTE/$(git remote show $FORMAT_REMOTE | sed -n '/HEAD branch/s/.*: //p')"
   # Get the common ancestor with that remote branch. Everything after that
   # common ancestor would be considered the contents of a pull request, so
   # should be relevant for formatting fixes.
   FORMAT_UPSTREAM_MERGE_BASE="$(git merge-base "$FORMAT_UPSTREAM" HEAD)"
   # Get the differences
-  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -p 1) || true
+  diffs=$(git diff -U0 "$FORMAT_UPSTREAM_MERGE_BASE" | $CLANG_FORMAT_DIFF -p 1)
   echo "Checking format of changes not yet in $FORMAT_UPSTREAM..."
 else
   # Check the format of uncommitted lines,
-  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1) || true
+  diffs=$(git diff -U0 HEAD | $CLANG_FORMAT_DIFF -p 1)
   echo "Checking format of uncommitted changes..."
 fi
 
@@ -149,9 +149,6 @@ if [ -z "$diffs" ]
 then
   echo "Nothing needs to be reformatted!"
   exit 0
-elif [ $? -ne 1 ]; then
-  # CLANG_FORMAT_DIFF will exit on 1 while there is suggested changes.
-  exit $?
 elif [ $CHECK_ONLY ]
 then
   echo "Your change has unformatted code. Please run make format!"
@@ -173,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{'GITHUB_ACTIONS'}  && !$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 \
@@ -360,7 +361,7 @@ function send_to_ods {
     echo >&2 "ERROR: Key $key doesn't have a value."
     return
   fi
-  curl --silent "https://www.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=$key&value=$value" \
+  curl --silent "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=$key&value=$value" \
     --connect-timeout 60
 }
 

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,32 +72,111 @@ touch "$OUTPUT"
 echo "Writing dependencies to $OUTPUT"
 
 # Compilers locations
-GCC_BASE=`readlink -f $TP2_LATEST/gcc/11.x/centos8-native/*/`
-CLANG_BASE=`readlink -f $TP2_LATEST/llvm-fb/15/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       1.2.8   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 binutils   LATEST centos8-native
-get_lib_base valgrind   LATEST platform010
-get_lib_base lua        5.3.4  platform010
+get_lib_base kernel-headers fb platform007
+get_lib_base binutils   LATEST centos7-native
+get_lib_base valgrind   LATEST platform007
+get_lib_base lua        5.3.4  platform007
+
+git diff $OUTPUT
+
+###########################################################
+#                   5.x dependencies                      #
+###########################################################
+
+OUTPUT="$BASEDIR/dependencies.sh"
+
+rm -f "$OUTPUT"
+touch "$OUTPUT"
+
+echo "Writing dependencies to $OUTPUT"
+
+# Compilers locations
+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     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 4.0.9-36_fbk5_2933_gd092e3f gcc-5-glibc-2.23
+get_lib_base binutils   LATEST centos7-native
+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,8 +16,7 @@
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
-const Cache::CacheItemHelper kNoopCacheItemHelper{};
-
+#ifndef ROCKSDB_LITE
 static std::unordered_map<std::string, OptionTypeInfo>
     lru_cache_options_type_info = {
         {"capacity",
@@ -34,98 +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}},
-};
-
-namespace {
-static void NoopDelete(Cache::ObjectPtr /*obj*/,
-                       MemoryAllocator* /*allocator*/) {
-  assert(false);
-}
-
-static size_t SliceSize(Cache::ObjectPtr obj) {
-  return static_cast<Slice*>(obj)->size();
-}
-
-static 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();
-}
-
-static Status NoopCreate(const Slice& /*data*/, CompressionType /*type*/,
-                         CacheTier /*source*/, Cache::CreateContext* /*ctx*/,
-                         MemoryAllocator* /*allocator*/,
-                         Cache::ObjectPtr* /*out_obj*/,
-                         size_t* /*out_charge*/) {
-  assert(false);
-  return Status::NotSupported();
-}
-
-static Cache::CacheItemHelper kBasicCacheItemHelper(CacheEntryRole::kMisc,
-                                                    &NoopDelete);
-}  // namespace
-
-const Cache::CacheItemHelper kSliceCacheItemHelper{
-    CacheEntryRole::kMisc, &NoopDelete, &SliceSize,
-    &SliceSaveTo,          &NoopCreate, &kBasicCacheItemHelper,
 };
+#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, result);
-  }
+  return LoadSharedObject<SecondaryCache>(config_options, value, nullptr,
+                                          result);
 }
 
 Status Cache::CreateFromString(const ConfigOptions& config_options,
@@ -136,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, "",
@@ -143,51 +59,14 @@ 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);
   }
   return status;
 }
-
-bool Cache::AsyncLookupHandle::IsReady() {
-  return pending_handle == nullptr || pending_handle->IsReady();
-}
-
-bool Cache::AsyncLookupHandle::IsPending() { return pending_handle != nullptr; }
-
-Cache::Handle* Cache::AsyncLookupHandle::Result() {
-  assert(!IsPending());
-  return result_handle;
-}
-
-void Cache::StartAsyncLookup(AsyncLookupHandle& async_handle) {
-  async_handle.found_dummy_entry = false;  // in case re-used
-  assert(!async_handle.IsPending());
-  async_handle.result_handle =
-      Lookup(async_handle.key, async_handle.helper, async_handle.create_context,
-             async_handle.priority, async_handle.stats);
-}
-
-Cache::Handle* Cache::Wait(AsyncLookupHandle& async_handle) {
-  WaitAll(&async_handle, 1);
-  return async_handle.Result();
-}
-
-void Cache::WaitAll(AsyncLookupHandle* async_handles, size_t count) {
-  for (size_t i = 0; i < count; ++i) {
-    if (async_handles[i].IsPending()) {
-      // If a pending handle gets here, it should be marked at "to be handled
-      // by a caller" by that caller erasing the pending_cache on it.
-      assert(async_handles[i].pending_cache == nullptr);
-    }
-  }
-}
-
-void Cache::SetEvictionCallback(EvictionCallback&& fn) {
-  // Overwriting non-empty with non-empty could indicate a bug
-  assert(!eviction_callback_ || !fn);
-  eviction_callback_ = std::move(fn);
-}
-
 }  // namespace ROCKSDB_NAMESPACE

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.GetBasicHelper());
+    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,41 +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, CompressionType::kNoCompression,
-                                CacheTier::kVolatileTier, 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

@@ -7,7 +7,7 @@
 
 #include <cassert>
 
-#include "rocksdb/advanced_cache.h"
+#include "rocksdb/cache.h"
 #include "rocksdb/rocksdb_namespace.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -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/advanced_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::GetHelper();
-}
-
-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,199 +68,31 @@ 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;
-
-  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();
+  // entry insertions succeed. Otherwise, it returns the first non-ok status;
+  // On releasing dummy entries, it always returns Status::OK().
+  // On keeping dummy entries the same, it always returns Status::OK().
+  Status UpdateCacheReservation(std::size_t new_memory_used);
+  std::size_t GetTotalReservedCacheSize();
 
  private:
   static constexpr std::size_t kSizeDummyEntry = 256 * 1024;
+  // The key will be longer than keys for blocks in SST files so they won't
+  // conflict.
+  static const std::size_t kCacheKeyPrefixSize =
+      BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
 
   Slice GetNextCacheKey();
-
-  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_;
+  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];
 };
-
-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) {
-      s = cache_res_mgr_->UpdateCacheReservation(
-          (total_mem_used > memory_used_delta)
-              ? (total_mem_used - memory_used_delta)
-              : 0);
-    } 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_;
-};
-}  // namespace ROCKSDB_NAMESPACE
+}  // namespace ROCKSDB_NAMESPACE

cache/cache_reservation_manager_test.cc

@@ -15,48 +15,57 @@
 #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 = 256 * 1024;
+  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 +74,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 +96,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 +104,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 +123,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,46 +141,46 @@ TEST_F(CacheReservationManagerTest,
 
 TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
      IncreaseCacheReservationOnFullCache) {
-  constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kSmallCacheCapacity = 4 * kSizeDummyEntry;
-  constexpr std::size_t kBigCacheCapacity = 4096 * kSizeDummyEntry;
+  constexpr std::size_t kOneMegabyte = 1024 * 1024;
+  constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
+  constexpr std::size_t kSizeDummyEntry = 256 * 1024;
   constexpr std::size_t kMetaDataChargeOverhead = 10000;
 
   LRUCacheOptions lo;
-  lo.capacity = 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";
@@ -176,8 +188,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 "
@@ -189,34 +199,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";
@@ -224,8 +235,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";
@@ -238,24 +247,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(),
@@ -266,24 +277,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(),
@@ -293,56 +306,58 @@ TEST_F(CacheReservationManagerTest,
 
 TEST(CacheReservationManagerWithDelayedDecreaseTest,
      DecreaseCacheReservationWithDelayedDecrease) {
-  constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
+  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 = 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";
@@ -350,8 +365,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 "
@@ -365,21 +378,22 @@ TEST(CacheReservationManagerWithDelayedDecreaseTest,
 
 TEST(CacheReservationManagerDestructorTest,
      ReleaseRemainingDummyEntriesOnDestruction) {
-  constexpr std::size_t kSizeDummyEntry =
-      CacheReservationManagerImpl<CacheEntryRole::kMisc>::GetDummyEntrySize();
-  constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
+  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 = 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(),
@@ -389,80 +403,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,111 +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)
-    : CacheWrapper(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,
-                            const Slice& compressed_val, CompressionType type) {
-  Status s = target_->Insert(key, obj, helper, charge, handle, priority,
-                             compressed_val, type);
-  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(target_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Cache::Handle* ChargedCache::Lookup(const Slice& key,
-                                    const CacheItemHelper* helper,
-                                    CreateContext* create_context,
-                                    Priority priority, Statistics* stats) {
-  auto handle = target_->Lookup(key, helper, create_context, priority, 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(target_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return handle;
-}
-
-void ChargedCache::WaitAll(AsyncLookupHandle* async_handles, size_t count) {
-  target_->WaitAll(async_handles, count);
-  // In case of any promotions. Although some could finish by return of
-  // StartAsyncLookup, Wait/WaitAll will generally be used, so simpler to
-  // update here.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-bool ChargedCache::Release(Cache::Handle* handle, bool useful,
-                           bool erase_if_last_ref) {
-  size_t memory_used_delta = target_->GetUsage(handle);
-  bool erased = target_->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 = target_->GetUsage(handle);
-  bool erased = target_->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) {
-  target_->Erase(key);
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::EraseUnRefEntries() {
-  target_->EraseUnRefEntries();
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-void ChargedCache::SetCapacity(size_t capacity) {
-  target_->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(target_->GetUsage())
-      .PermitUncheckedError();
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/charged_cache.h

@@ -1,61 +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/advanced_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 CacheWrapper {
- public:
-  ChargedCache(std::shared_ptr<Cache> cache,
-               std::shared_ptr<Cache> block_cache);
-
-  Status Insert(
-      const Slice& key, ObjectPtr obj, const CacheItemHelper* helper,
-      size_t charge, Handle** handle = nullptr,
-      Priority priority = Priority::LOW, const Slice& compressed_val = Slice(),
-      CompressionType type = CompressionType::kNoCompression) override;
-
-  Cache::Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                        CreateContext* create_context,
-                        Priority priority = Priority::LOW,
-                        Statistics* stats = nullptr) override;
-
-  void WaitAll(AsyncLookupHandle* async_handles, size_t count) 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(); }
-
-  void SetCapacity(size_t capacity) override;
-
-  inline Cache* GetCache() const { return target_.get(); }
-
-  inline ConcurrentCacheReservationManager* TEST_GetCacheReservationManager()
-      const {
-    return cache_res_mgr_.get();
-  }
-
- private:
-  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.cc

@@ -1,414 +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_impl.h"
-#include "monitoring/perf_context_imp.h"
-#include "util/coding.h"
-#include "util/compression.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-CompressedSecondaryCache::CompressedSecondaryCache(
-    const CompressedSecondaryCacheOptions& opts)
-    : cache_(opts.LRUCacheOptions::MakeSharedCache()),
-      cache_options_(opts),
-      cache_res_mgr_(std::make_shared<ConcurrentCacheReservationManager>(
-          std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-              cache_))),
-      disable_cache_(opts.capacity == 0) {}
-
-CompressedSecondaryCache::~CompressedSecondaryCache() = default;
-
-std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
-    const Slice& key, const Cache::CacheItemHelper* helper,
-    Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
-    Statistics* stats, bool& kept_in_sec_cache) {
-  assert(helper);
-  // This is a minor optimization. Its ok to skip it in TSAN in order to
-  // avoid a false positive.
-#ifndef __SANITIZE_THREAD__
-  if (disable_cache_) {
-    return nullptr;
-  }
-#endif
-
-  std::unique_ptr<SecondaryCacheResultHandle> handle;
-  kept_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);
-    RecordTick(stats, COMPRESSED_SECONDARY_CACHE_DUMMY_HITS);
-    return nullptr;
-  }
-
-  CacheAllocationPtr* ptr{nullptr};
-  CacheAllocationPtr merged_value;
-  size_t handle_value_charge{0};
-  const char* data_ptr = nullptr;
-  CacheTier source = CacheTier::kVolatileCompressedTier;
-  CompressionType type = cache_options_.compression_type;
-  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;
-    data_ptr = ptr->get();
-  } else {
-    uint32_t type_32 = static_cast<uint32_t>(type);
-    uint32_t source_32 = static_cast<uint32_t>(source);
-    ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
-    handle_value_charge = cache_->GetCharge(lru_handle);
-    data_ptr = ptr->get();
-    data_ptr = GetVarint32Ptr(data_ptr, data_ptr + 1,
-                              static_cast<uint32_t*>(&type_32));
-    type = static_cast<CompressionType>(type_32);
-    data_ptr = GetVarint32Ptr(data_ptr, data_ptr + 1,
-                              static_cast<uint32_t*>(&source_32));
-    source = static_cast<CacheTier>(source_32);
-    handle_value_charge -= (data_ptr - ptr->get());
-  }
-  MemoryAllocator* allocator = cache_options_.memory_allocator.get();
-
-  Status s;
-  Cache::ObjectPtr value{nullptr};
-  size_t charge{0};
-  if (source == CacheTier::kVolatileCompressedTier) {
-    if (cache_options_.compression_type == kNoCompression ||
-        cache_options_.do_not_compress_roles.Contains(helper->role)) {
-      s = helper->create_cb(Slice(data_ptr, handle_value_charge),
-                            kNoCompression, CacheTier::kVolatileTier,
-                            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*)data_ptr,
-                         handle_value_charge, &uncompressed_size,
-                         cache_options_.compress_format_version, allocator);
-
-      if (!uncompressed) {
-        cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
-        return nullptr;
-      }
-      s = helper->create_cb(Slice(uncompressed.get(), uncompressed_size),
-                            kNoCompression, CacheTier::kVolatileTier,
-                            create_context, allocator, &value, &charge);
-    }
-  } else {
-    // The item was not compressed by us. Let the helper create_cb
-    // uncompress it
-    s = helper->create_cb(Slice(data_ptr, handle_value_charge), type, source,
-                          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 {
-    kept_in_sec_cache = true;
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
-  handle.reset(new CompressedSecondaryCacheResultHandle(value, charge));
-  RecordTick(stats, COMPRESSED_SECONDARY_CACHE_HITS);
-  return handle;
-}
-
-bool CompressedSecondaryCache::MaybeInsertDummy(const Slice& key) {
-  auto internal_helper = GetHelper(cache_options_.enable_custom_split_merge);
-  Cache::Handle* lru_handle = cache_->Lookup(key);
-  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.
-    cache_->Insert(key, /*obj=*/nullptr, internal_helper, /*charge=*/0)
-        .PermitUncheckedError();
-    return true;
-  } else {
-    cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
-  }
-
-  return false;
-}
-
-Status CompressedSecondaryCache::InsertInternal(
-    const Slice& key, Cache::ObjectPtr value,
-    const Cache::CacheItemHelper* helper, CompressionType type,
-    CacheTier source) {
-  if (source != CacheTier::kVolatileCompressedTier &&
-      cache_options_.enable_custom_split_merge) {
-    // We don't support custom split/merge for the tiered case
-    return Status::OK();
-  }
-
-  auto internal_helper = GetHelper(cache_options_.enable_custom_split_merge);
-  char header[10];
-  char* payload = header;
-  payload = EncodeVarint32(payload, static_cast<uint32_t>(type));
-  payload = EncodeVarint32(payload, static_cast<uint32_t>(source));
-
-  size_t header_size = payload - header;
-  size_t data_size = (*helper->size_cb)(value);
-  size_t total_size = data_size + header_size;
-  CacheAllocationPtr ptr =
-      AllocateBlock(total_size, cache_options_.memory_allocator.get());
-  char* data_ptr = ptr.get() + header_size;
-
-  Status s = (*helper->saveto_cb)(value, 0, data_size, data_ptr);
-  if (!s.ok()) {
-    return s;
-  }
-  Slice val(data_ptr, data_size);
-
-  std::string compressed_val;
-  if (cache_options_.compression_type != kNoCompression &&
-      type == kNoCompression &&
-      !cache_options_.do_not_compress_roles.Contains(helper->role)) {
-    PERF_COUNTER_ADD(compressed_sec_cache_uncompressed_bytes, data_size);
-    CompressionContext compression_context(cache_options_.compression_type,
-                                           cache_options_.compression_opts);
-    uint64_t sample_for_compression{0};
-    CompressionInfo compression_info(
-        cache_options_.compression_opts, compression_context,
-        CompressionDict::GetEmptyDict(), cache_options_.compression_type,
-        sample_for_compression);
-
-    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);
-    data_size = compressed_val.size();
-    total_size = header_size + data_size;
-    PERF_COUNTER_ADD(compressed_sec_cache_compressed_bytes, data_size);
-
-    if (!cache_options_.enable_custom_split_merge) {
-      ptr = AllocateBlock(total_size, cache_options_.memory_allocator.get());
-      data_ptr = ptr.get() + header_size;
-      memcpy(data_ptr, compressed_val.data(), 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 {
-    std::memcpy(ptr.get(), header, header_size);
-    CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    return cache_->Insert(key, buf, internal_helper, total_size);
-  }
-}
-
-Status CompressedSecondaryCache::Insert(const Slice& key,
-                                        Cache::ObjectPtr value,
-                                        const Cache::CacheItemHelper* helper,
-                                        bool force_insert) {
-  if (value == nullptr) {
-    return Status::InvalidArgument();
-  }
-
-  if (!force_insert && MaybeInsertDummy(key)) {
-    return Status::OK();
-  }
-
-  return InsertInternal(key, value, helper, kNoCompression,
-                        CacheTier::kVolatileCompressedTier);
-}
-
-Status CompressedSecondaryCache::InsertSaved(
-    const Slice& key, const Slice& saved, CompressionType type = kNoCompression,
-    CacheTier source = CacheTier::kVolatileTier) {
-  if (type == kNoCompression) {
-    return Status::OK();
-  }
-
-  auto slice_helper = &kSliceCacheItemHelper;
-  if (MaybeInsertDummy(key)) {
-    return Status::OK();
-  }
-
-  return InsertInternal(
-      key, static_cast<Cache::ObjectPtr>(const_cast<Slice*>(&saved)),
-      slice_helper, type, source);
-}
-
-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);
-  disable_cache_ = capacity == 0;
-  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, "    compression_opts : %s\n",
-           CompressionOptionsToString(
-               const_cast<CompressionOptions&>(cache_options_.compression_opts))
-               .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>
-CompressedSecondaryCacheOptions::MakeSharedSecondaryCache() const {
-  return std::make_shared<CompressedSecondaryCache>(*this);
-}
-
-Status CompressedSecondaryCache::Deflate(size_t decrease) {
-  return cache_res_mgr_->UpdateCacheReservation(decrease, /*increase=*/true);
-}
-
-Status CompressedSecondaryCache::Inflate(size_t increase) {
-  return cache_res_mgr_->UpdateCacheReservation(increase, /*increase=*/false);
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/compressed_secondary_cache.h

@@ -1,151 +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/cache_reservation_manager.h"
-#include "cache/lru_cache.h"
-#include "memory/memory_allocator_impl.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:
-  explicit CompressedSecondaryCache(
-      const CompressedSecondaryCacheOptions& opts);
-  ~CompressedSecondaryCache() override;
-
-  const char* Name() const override { return "CompressedSecondaryCache"; }
-
-  Status Insert(const Slice& key, Cache::ObjectPtr value,
-                const Cache::CacheItemHelper* helper,
-                bool force_insert) override;
-
-  Status InsertSaved(const Slice& key, const Slice& saved, CompressionType type,
-                     CacheTier source) override;
-
-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CacheItemHelper* helper,
-      Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
-      Statistics* stats, bool& kept_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;
-
-  Status Deflate(size_t decrease) override;
-
-  Status Inflate(size_t increase) override;
-
-  std::string GetPrintableOptions() const override;
-
-  size_t TEST_GetUsage() { return cache_->GetUsage(); }
-
- private:
-  friend class CompressedSecondaryCacheTestBase;
-  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);
-
-  bool MaybeInsertDummy(const Slice& key);
-
-  Status InsertInternal(const Slice& key, Cache::ObjectPtr value,
-                        const Cache::CacheItemHelper* helper,
-                        CompressionType type, CacheTier source);
-
-  // 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_;
-  std::shared_ptr<ConcurrentCacheReservationManager> cache_res_mgr_;
-  bool disable_cache_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/lru_cache.h

@@ -13,14 +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.
 
@@ -38,63 +36,74 @@ 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 : public Cache::Handle {
-  Cache::ObjectPtr value;
-  const Cache::CacheItemHelper* helper;
-  LRUHandle* next_hash;
+struct LRUHandle {
+  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 {
+    LRUHandle* next_hash;
+    SecondaryCacheResultHandle* sec_handle;
+  };
   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),
-    // Marks result handles that should not be inserted into cache
-    IM_IS_STANDALONE = (1 << 2),
-  };
+  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++; }
 
@@ -108,97 +117,110 @@ struct LRUHandle : public Cache::Handle {
   // 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 IsStandalone() const { return im_flags & IM_IS_STANDALONE; }
+  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 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 SetIsStandalone(bool is_standalone) {
-    if (is_standalone) {
-      im_flags |= IM_IS_STANDALONE;
+  void SetPromoted(bool promoted) {
+    if (promoted) {
+      flags |= IS_PROMOTED;
     } else {
-      im_flags &= ~IM_IS_STANDALONE;
+      flags &= ~IS_PROMOTED;
     }
   }
 
-  void Free(MemoryAllocator* allocator) {
+  void Free() {
     assert(refs == 0);
-    assert(helper);
-    if (helper->del_cb) {
-      helper->del_cb(value, allocator);
+#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);
+      }
     }
-
-    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;
   }
 };
 
@@ -209,7 +231,10 @@ struct LRUHandle : public Cache::Handle {
 // 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);
@@ -217,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;
@@ -231,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
@@ -251,111 +272,113 @@ 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:
-  // NOTE: the eviction_callback ptr is saved, as is it assumed to be kept
-  // alive in Cache.
   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,
-                const Cache::EvictionCallback* eviction_callback);
-
- 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, uint32_t seed) {
-    return Lower32of64(GetSliceNPHash64(key, seed));
-  }
+                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* CreateStandalone(const Slice& key, uint32_t hash,
-                              Cache::ObjectPtr obj,
-                              const Cache::CacheItemHelper* helper,
-                              size_t charge, bool allow_uncharged);
-
-  LRUHandle* Lookup(const Slice& key, uint32_t hash,
-                    const Cache::CacheItemHelper* helper,
-                    Cache::CreateContext* create_context,
-                    Cache::Priority priority, Statistics* stats);
-
-  bool Release(LRUHandle* handle, bool useful, bool erase_if_last_ref);
-  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. Frees `item` on
-  // non-OK status.
-  Status InsertItem(LRUHandle* item, LRUHandle** handle);
-
+  // the LRU list. Older items are evicted as necessary. If the cache is full
+  // and free_handle_on_fail is true, the item is deleted and handle is set to.
+  Status InsertItem(LRUHandle* item, Cache::Handle** handle,
+                    bool free_handle_on_fail);
+  Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
+                DeleterFn deleter, const Cache::CacheItemHelper* helper,
+                Cache::Handle** handle, Cache::Priority priority);
+  // Promote an item looked up from the secondary cache to the LRU cache. The
+  // item is only inserted into the hash table and not the LRU list, and only
+  // if the cache is not at full capacity, as is the case during Insert.  The
+  // caller should hold a reference on the LRUHandle. When the caller releases
+  // the last reference, the item is added to the LRU list.
+  // The item is promoted to the high pri or low pri pool as specified by the
+  // caller in Lookup.
+  void Promote(LRUHandle* e);
   void LRU_Remove(LRUHandle* e);
   void LRU_Insert(LRUHandle* e);
 
@@ -366,24 +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);
 
-  void NotifyEvicted(const autovector<LRUHandle*>& evicted_handles);
-
-  LRUHandle* CreateHandle(const Slice& key, uint32_t hash,
-                          Cache::ObjectPtr value,
-                          const Cache::CacheItemHelper* helper, size_t charge);
-
   // 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_;
 
@@ -394,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
@@ -409,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
   // ------------------------------------
@@ -425,43 +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_;
 
-  // A reference to Cache::eviction_callback_
-  const Cache::EvictionCallback& eviction_callback_;
+  std::shared_ptr<SecondaryCache> secondary_cache_;
 };
 
 class LRUCache
 #ifdef NDEBUG
     final
 #endif
-    : public ShardedCache<LRUCacheShard> {
+    : public ShardedCache {
  public:
-  explicit LRUCache(const LRUCacheOptions& opts);
-  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;
+  LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
+           double high_pri_pool_ratio,
+           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
+           bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
+           CacheMetadataChargePolicy metadata_charge_policy =
+               kDontChargeCacheMetadata,
+           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();
+
+ 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_adapter.cc

@@ -1,743 +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/secondary_cache_adapter.h"
-
-#include <atomic>
-
-#include "cache/tiered_secondary_cache.h"
-#include "monitoring/perf_context_imp.h"
-#include "test_util/sync_point.h"
-#include "util/cast_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace {
-// A distinct pointer value for marking "dummy" cache entries
-struct Dummy {
-  char val[7] = "kDummy";
-};
-const Dummy kDummy{};
-Cache::ObjectPtr const kDummyObj = const_cast<Dummy*>(&kDummy);
-const char* kTieredCacheName = "TieredCache";
-}  // namespace
-
-// When CacheWithSecondaryAdapter is constructed with the distribute_cache_res
-// parameter set to true, it manages the entire memory budget across the
-// primary and secondary cache. The secondary cache is assumed to be in
-// memory, such as the CompressedSecondaryCache. When a placeholder entry
-// is inserted by a CacheReservationManager instance to reserve memory,
-// the CacheWithSecondaryAdapter ensures that the reservation is distributed
-// proportionally across the primary/secondary caches.
-//
-// The primary block cache is initially sized to the sum of the primary cache
-// budget + teh secondary cache budget, as follows -
-//   |---------    Primary Cache Configured Capacity  -----------|
-//   |---Secondary Cache Budget----|----Primary Cache Budget-----|
-//
-// A ConcurrentCacheReservationManager member in the CacheWithSecondaryAdapter,
-// pri_cache_res_,
-// is used to help with tracking the distribution of memory reservations.
-// Initially, it accounts for the entire secondary cache budget as a
-// reservation against the primary cache. This shrinks the usable capacity of
-// the primary cache to the budget that the user originally desired.
-//
-//   |--Reservation for Sec Cache--|-Pri Cache Usable Capacity---|
-//
-// When a reservation placeholder is inserted into the adapter, it is inserted
-// directly into the primary cache. This means the entire charge of the
-// placeholder is counted against the primary cache. To compensate and count
-// a portion of it against the secondary cache, the secondary cache Deflate()
-// method is called to shrink it. Since the Deflate() causes the secondary
-// actual usage to shrink, it is refelcted here by releasing an equal amount
-// from the pri_cache_res_ reservation. The Deflate() in the secondary cache
-// can be, but is not required to be, implemented using its own cache
-// reservation manager.
-//
-// For example, if the pri/sec ratio is 70/30, and the combined capacity is
-// 100MB, the intermediate and final  state after inserting a reservation
-// placeholder for 10MB would be as follows -
-//
-//   |-Reservation for Sec Cache-|-Pri Cache Usable Capacity-|---R---|
-// 1. After inserting the placeholder in primary
-//   |-------  30MB -------------|------- 60MB -------------|-10MB--|
-// 2. After deflating the secondary and adjusting the reservation for
-//    secondary against the primary
-//   |-------  27MB -------------|------- 63MB -------------|-10MB--|
-//
-// Likewise, when the user inserted placeholder is released, the secondary
-// cache Inflate() method is called to grow it, and the pri_cache_res_
-// reservation is increased by an equal amount.
-//
-// Another way of implementing this would have been to simply split the user
-// reservation into primary and seconary components. However, this would
-// require allocating a structure to track the associated secondary cache
-// reservation, which adds some complexity and overhead.
-//
-CacheWithSecondaryAdapter::CacheWithSecondaryAdapter(
-    std::shared_ptr<Cache> target,
-    std::shared_ptr<SecondaryCache> secondary_cache,
-    TieredAdmissionPolicy adm_policy, bool distribute_cache_res)
-    : CacheWrapper(std::move(target)),
-      secondary_cache_(std::move(secondary_cache)),
-      adm_policy_(adm_policy),
-      distribute_cache_res_(distribute_cache_res),
-      placeholder_usage_(0),
-      reserved_usage_(0),
-      sec_reserved_(0) {
-  target_->SetEvictionCallback(
-      [this](const Slice& key, Handle* handle, bool was_hit) {
-        return EvictionHandler(key, handle, was_hit);
-      });
-  if (distribute_cache_res_) {
-    size_t sec_capacity = 0;
-    pri_cache_res_ = std::make_shared<ConcurrentCacheReservationManager>(
-        std::make_shared<CacheReservationManagerImpl<CacheEntryRole::kMisc>>(
-            target_));
-    Status s = secondary_cache_->GetCapacity(sec_capacity);
-    assert(s.ok());
-    // Initially, the primary cache is sized to uncompressed cache budget plsu
-    // compressed secondary cache budget. The secondary cache budget is then
-    // taken away from the primary cache through cache reservations. Later,
-    // when a placeholder entry is inserted by the caller, its inserted
-    // into the primary cache and the portion that should be assigned to the
-    // secondary cache is freed from the reservation.
-    s = pri_cache_res_->UpdateCacheReservation(sec_capacity);
-    assert(s.ok());
-    sec_cache_res_ratio_ = (double)sec_capacity / target_->GetCapacity();
-  }
-}
-
-CacheWithSecondaryAdapter::~CacheWithSecondaryAdapter() {
-  // `*this` will be destroyed before `*target_`, so we have to prevent
-  // use after free
-  target_->SetEvictionCallback({});
-#ifndef NDEBUG
-  if (distribute_cache_res_) {
-    size_t sec_capacity = 0;
-    Status s = secondary_cache_->GetCapacity(sec_capacity);
-    assert(s.ok());
-    assert(placeholder_usage_ == 0);
-    assert(reserved_usage_ == 0);
-    assert(pri_cache_res_->GetTotalMemoryUsed() == sec_capacity);
-  }
-#endif  // NDEBUG
-}
-
-bool CacheWithSecondaryAdapter::EvictionHandler(const Slice& key,
-                                                Handle* handle, bool was_hit) {
-  auto helper = GetCacheItemHelper(handle);
-  if (helper->IsSecondaryCacheCompatible() &&
-      adm_policy_ != TieredAdmissionPolicy::kAdmPolicyThreeQueue) {
-    auto obj = target_->Value(handle);
-    // Ignore dummy entry
-    if (obj != kDummyObj) {
-      bool force = false;
-      if (adm_policy_ == TieredAdmissionPolicy::kAdmPolicyAllowCacheHits) {
-        force = was_hit;
-      } else if (adm_policy_ == TieredAdmissionPolicy::kAdmPolicyAllowAll) {
-        force = true;
-      }
-      // Spill into secondary cache.
-      secondary_cache_->Insert(key, obj, helper, force).PermitUncheckedError();
-    }
-  }
-  // Never takes ownership of obj
-  return false;
-}
-
-bool CacheWithSecondaryAdapter::ProcessDummyResult(Cache::Handle** handle,
-                                                   bool erase) {
-  if (*handle && target_->Value(*handle) == kDummyObj) {
-    target_->Release(*handle, erase);
-    *handle = nullptr;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-void CacheWithSecondaryAdapter::CleanupCacheObject(
-    ObjectPtr obj, const CacheItemHelper* helper) {
-  if (helper->del_cb) {
-    helper->del_cb(obj, memory_allocator());
-  }
-}
-
-Cache::Handle* CacheWithSecondaryAdapter::Promote(
-    std::unique_ptr<SecondaryCacheResultHandle>&& secondary_handle,
-    const Slice& key, const CacheItemHelper* helper, Priority priority,
-    Statistics* stats, bool found_dummy_entry, bool kept_in_sec_cache) {
-  assert(secondary_handle->IsReady());
-
-  ObjectPtr obj = secondary_handle->Value();
-  if (!obj) {
-    // Nothing found.
-    return nullptr;
-  }
-  // Found something.
-  switch (helper->role) {
-    case CacheEntryRole::kFilterBlock:
-      RecordTick(stats, SECONDARY_CACHE_FILTER_HITS);
-      break;
-    case CacheEntryRole::kIndexBlock:
-      RecordTick(stats, SECONDARY_CACHE_INDEX_HITS);
-      break;
-    case CacheEntryRole::kDataBlock:
-      RecordTick(stats, SECONDARY_CACHE_DATA_HITS);
-      break;
-    default:
-      break;
-  }
-  PERF_COUNTER_ADD(secondary_cache_hit_count, 1);
-  RecordTick(stats, SECONDARY_CACHE_HITS);
-
-  // Note: SecondaryCache::Size() is really charge (from the CreateCallback)
-  size_t charge = secondary_handle->Size();
-  Handle* result = nullptr;
-  // Insert into primary cache, possibly as a standalone+dummy entries.
-  if (secondary_cache_->SupportForceErase() && !found_dummy_entry) {
-    // Create standalone and insert dummy
-    // Allow standalone to be created even if cache is full, to avoid
-    // reading the entry from storage.
-    result =
-        CreateStandalone(key, obj, helper, charge, /*allow_uncharged*/ true);
-    assert(result);
-    PERF_COUNTER_ADD(block_cache_standalone_handle_count, 1);
-
-    // Insert dummy to record recent use
-    // TODO: try to avoid case where inserting this dummy could overwrite a
-    // regular entry
-    Status s = Insert(key, kDummyObj, &kNoopCacheItemHelper, /*charge=*/0,
-                      /*handle=*/nullptr, priority);
-    s.PermitUncheckedError();
-    // Nothing to do or clean up on dummy insertion failure
-  } else {
-    // Insert regular entry into primary cache.
-    // Don't allow it to spill into secondary cache again if it was kept there.
-    Status s = Insert(
-        key, obj, kept_in_sec_cache ? helper->without_secondary_compat : helper,
-        charge, &result, priority);
-    if (s.ok()) {
-      assert(result);
-      PERF_COUNTER_ADD(block_cache_real_handle_count, 1);
-    } else {
-      // Create standalone result instead, even if cache is full, to avoid
-      // reading the entry from storage.
-      result =
-          CreateStandalone(key, obj, helper, charge, /*allow_uncharged*/ true);
-      assert(result);
-      PERF_COUNTER_ADD(block_cache_standalone_handle_count, 1);
-    }
-  }
-  return result;
-}
-
-Status CacheWithSecondaryAdapter::Insert(const Slice& key, ObjectPtr value,
-                                         const CacheItemHelper* helper,
-                                         size_t charge, Handle** handle,
-                                         Priority priority,
-                                         const Slice& compressed_value,
-                                         CompressionType type) {
-  Status s = target_->Insert(key, value, helper, charge, handle, priority);
-  if (s.ok() && value == nullptr && distribute_cache_res_ && handle) {
-    charge = target_->GetCharge(*handle);
-
-    MutexLock l(&cache_res_mutex_);
-    placeholder_usage_ += charge;
-    // Check if total placeholder reservation is more than the overall
-    // cache capacity. If it is, then we don't try to charge the
-    // secondary cache because we don't want to overcharge it (beyond
-    // its capacity).
-    // In order to make this a bit more lightweight, we also check if
-    // the difference between placeholder_usage_ and reserved_usage_ is
-    // atleast kReservationChunkSize and avoid any adjustments if not.
-    if ((placeholder_usage_ <= target_->GetCapacity()) &&
-        ((placeholder_usage_ - reserved_usage_) >= kReservationChunkSize)) {
-      reserved_usage_ = placeholder_usage_ & ~(kReservationChunkSize - 1);
-      size_t new_sec_reserved =
-          static_cast<size_t>(reserved_usage_ * sec_cache_res_ratio_);
-      size_t sec_charge = new_sec_reserved - sec_reserved_;
-      s = secondary_cache_->Deflate(sec_charge);
-      assert(s.ok());
-      s = pri_cache_res_->UpdateCacheReservation(sec_charge,
-                                                 /*increase=*/false);
-      assert(s.ok());
-      sec_reserved_ += sec_charge;
-    }
-  }
-  // Warm up the secondary cache with the compressed block. The secondary
-  // cache may choose to ignore it based on the admission policy.
-  if (value != nullptr && !compressed_value.empty() &&
-      adm_policy_ == TieredAdmissionPolicy::kAdmPolicyThreeQueue) {
-    Status status = secondary_cache_->InsertSaved(key, compressed_value, type);
-    assert(status.ok() || status.IsNotSupported());
-  }
-
-  return s;
-}
-
-Cache::Handle* CacheWithSecondaryAdapter::Lookup(const Slice& key,
-                                                 const CacheItemHelper* helper,
-                                                 CreateContext* create_context,
-                                                 Priority priority,
-                                                 Statistics* stats) {
-  // NOTE: we could just StartAsyncLookup() and Wait(), but this should be a bit
-  // more efficient
-  Handle* result =
-      target_->Lookup(key, helper, create_context, priority, stats);
-  bool secondary_compatible = helper && helper->IsSecondaryCacheCompatible();
-  bool found_dummy_entry =
-      ProcessDummyResult(&result, /*erase=*/secondary_compatible);
-  if (!result && secondary_compatible) {
-    // Try our secondary cache
-    bool kept_in_sec_cache = false;
-    std::unique_ptr<SecondaryCacheResultHandle> secondary_handle =
-        secondary_cache_->Lookup(key, helper, create_context, /*wait*/ true,
-                                 found_dummy_entry, stats,
-                                 /*out*/ kept_in_sec_cache);
-    if (secondary_handle) {
-      result = Promote(std::move(secondary_handle), key, helper, priority,
-                       stats, found_dummy_entry, kept_in_sec_cache);
-    }
-  }
-  return result;
-}
-
-bool CacheWithSecondaryAdapter::Release(Handle* handle,
-                                        bool erase_if_last_ref) {
-  if (erase_if_last_ref) {
-    ObjectPtr v = target_->Value(handle);
-    if (v == nullptr && distribute_cache_res_) {
-      size_t charge = target_->GetCharge(handle);
-
-      MutexLock l(&cache_res_mutex_);
-      placeholder_usage_ -= charge;
-      // Check if total placeholder reservation is more than the overall
-      // cache capacity. If it is, then we do nothing as reserved_usage_ must
-      // be already maxed out
-      if ((placeholder_usage_ <= target_->GetCapacity()) &&
-          (placeholder_usage_ < reserved_usage_)) {
-        // Adjust reserved_usage_ in chunks of kReservationChunkSize, so
-        // we don't hit this slow path too often.
-        reserved_usage_ = placeholder_usage_ & ~(kReservationChunkSize - 1);
-        size_t new_sec_reserved =
-            static_cast<size_t>(reserved_usage_ * sec_cache_res_ratio_);
-        size_t sec_charge = sec_reserved_ - new_sec_reserved;
-        Status s = secondary_cache_->Inflate(sec_charge);
-        assert(s.ok());
-        s = pri_cache_res_->UpdateCacheReservation(sec_charge,
-                                                   /*increase=*/true);
-        assert(s.ok());
-        sec_reserved_ -= sec_charge;
-      }
-    }
-  }
-  return target_->Release(handle, erase_if_last_ref);
-}
-
-Cache::ObjectPtr CacheWithSecondaryAdapter::Value(Handle* handle) {
-  ObjectPtr v = target_->Value(handle);
-  // TODO with stacked secondaries: might fail in EvictionHandler
-  assert(v != kDummyObj);
-  return v;
-}
-
-void CacheWithSecondaryAdapter::StartAsyncLookupOnMySecondary(
-    AsyncLookupHandle& async_handle) {
-  assert(!async_handle.IsPending());
-  assert(async_handle.result_handle == nullptr);
-
-  std::unique_ptr<SecondaryCacheResultHandle> secondary_handle =
-      secondary_cache_->Lookup(
-          async_handle.key, async_handle.helper, async_handle.create_context,
-          /*wait*/ false, async_handle.found_dummy_entry, async_handle.stats,
-          /*out*/ async_handle.kept_in_sec_cache);
-  if (secondary_handle) {
-    // TODO with stacked secondaries: Check & process if already ready?
-    async_handle.pending_handle = secondary_handle.release();
-    async_handle.pending_cache = secondary_cache_.get();
-  }
-}
-
-void CacheWithSecondaryAdapter::StartAsyncLookup(
-    AsyncLookupHandle& async_handle) {
-  target_->StartAsyncLookup(async_handle);
-  if (!async_handle.IsPending()) {
-    bool secondary_compatible =
-        async_handle.helper &&
-        async_handle.helper->IsSecondaryCacheCompatible();
-    async_handle.found_dummy_entry |= ProcessDummyResult(
-        &async_handle.result_handle, /*erase=*/secondary_compatible);
-
-    if (async_handle.Result() == nullptr && secondary_compatible) {
-      // Not found and not pending on another secondary cache
-      StartAsyncLookupOnMySecondary(async_handle);
-    }
-  }
-}
-
-void CacheWithSecondaryAdapter::WaitAll(AsyncLookupHandle* async_handles,
-                                        size_t count) {
-  if (count == 0) {
-    // Nothing to do
-    return;
-  }
-  // Requests that are pending on *my* secondary cache, at the start of this
-  // function
-  std::vector<AsyncLookupHandle*> my_pending;
-  // Requests that are pending on an "inner" secondary cache (managed somewhere
-  // under target_), as of the start of this function
-  std::vector<AsyncLookupHandle*> inner_pending;
-
-  // Initial accounting of pending handles, excluding those already handled
-  // by "outer" secondary caches. (See cur->pending_cache = nullptr.)
-  for (size_t i = 0; i < count; ++i) {
-    AsyncLookupHandle* cur = async_handles + i;
-    if (cur->pending_cache) {
-      assert(cur->IsPending());
-      assert(cur->helper);
-      assert(cur->helper->IsSecondaryCacheCompatible());
-      if (cur->pending_cache == secondary_cache_.get()) {
-        my_pending.push_back(cur);
-        // Mark as "to be handled by this caller"
-        cur->pending_cache = nullptr;
-      } else {
-        // Remember as potentially needing a lookup in my secondary
-        inner_pending.push_back(cur);
-      }
-    }
-  }
-
-  // Wait on inner-most cache lookups first
-  // TODO with stacked secondaries: because we are not using proper
-  // async/await constructs here yet, there is a false synchronization point
-  // here where all the results at one level are needed before initiating
-  // any lookups at the next level. Probably not a big deal, but worth noting.
-  if (!inner_pending.empty()) {
-    target_->WaitAll(async_handles, count);
-  }
-
-  // For those that failed to find something, convert to lookup in my
-  // secondary cache.
-  for (AsyncLookupHandle* cur : inner_pending) {
-    if (cur->Result() == nullptr) {
-      // Not found, try my secondary
-      StartAsyncLookupOnMySecondary(*cur);
-      if (cur->IsPending()) {
-        assert(cur->pending_cache == secondary_cache_.get());
-        my_pending.push_back(cur);
-        // Mark as "to be handled by this caller"
-        cur->pending_cache = nullptr;
-      }
-    }
-  }
-
-  // Wait on all lookups on my secondary cache
-  {
-    std::vector<SecondaryCacheResultHandle*> my_secondary_handles;
-    for (AsyncLookupHandle* cur : my_pending) {
-      my_secondary_handles.push_back(cur->pending_handle);
-    }
-    secondary_cache_->WaitAll(std::move(my_secondary_handles));
-  }
-
-  // Process results
-  for (AsyncLookupHandle* cur : my_pending) {
-    std::unique_ptr<SecondaryCacheResultHandle> secondary_handle(
-        cur->pending_handle);
-    cur->pending_handle = nullptr;
-    cur->result_handle = Promote(
-        std::move(secondary_handle), cur->key, cur->helper, cur->priority,
-        cur->stats, cur->found_dummy_entry, cur->kept_in_sec_cache);
-    assert(cur->pending_cache == nullptr);
-  }
-}
-
-std::string CacheWithSecondaryAdapter::GetPrintableOptions() const {
-  std::string str = target_->GetPrintableOptions();
-  str.append("  secondary_cache:\n");
-  str.append(secondary_cache_->GetPrintableOptions());
-  return str;
-}
-
-const char* CacheWithSecondaryAdapter::Name() const {
-  if (distribute_cache_res_) {
-    return kTieredCacheName;
-  } else {
-    // To the user, at least for now, configure the underlying cache with
-    // a secondary cache. So we pretend to be that cache
-    return target_->Name();
-  }
-}
-
-// Update the total cache capacity. If we're distributing cache reservations
-// to both primary and secondary, then update the pri_cache_res_reservation
-// as well. At the moment, we don't have a good way of handling the case
-// where the new capacity < total cache reservations.
-void CacheWithSecondaryAdapter::SetCapacity(size_t capacity) {
-  size_t sec_capacity = static_cast<size_t>(
-      capacity * (distribute_cache_res_ ? sec_cache_res_ratio_ : 0.0));
-  size_t old_sec_capacity = 0;
-
-  if (distribute_cache_res_) {
-    MutexLock m(&cache_res_mutex_);
-
-    Status s = secondary_cache_->GetCapacity(old_sec_capacity);
-    if (!s.ok()) {
-      return;
-    }
-    if (old_sec_capacity > sec_capacity) {
-      // We're shrinking the cache. We do things in the following order to
-      // avoid a temporary spike in usage over the configured capacity -
-      // 1. Lower the secondary cache capacity
-      // 2. Credit an equal amount (by decreasing pri_cache_res_) to the
-      //    primary cache
-      // 3. Decrease the primary cache capacity to the total budget
-      s = secondary_cache_->SetCapacity(sec_capacity);
-      if (s.ok()) {
-        if (placeholder_usage_ > capacity) {
-          // Adjust reserved_usage_ down
-          reserved_usage_ = capacity & ~(kReservationChunkSize - 1);
-        }
-        size_t new_sec_reserved =
-            static_cast<size_t>(reserved_usage_ * sec_cache_res_ratio_);
-        s = pri_cache_res_->UpdateCacheReservation(
-            (old_sec_capacity - sec_capacity) -
-                (sec_reserved_ - new_sec_reserved),
-            /*increase=*/false);
-        sec_reserved_ = new_sec_reserved;
-        assert(s.ok());
-        target_->SetCapacity(capacity);
-      }
-    } else {
-      // We're expanding the cache. Do it in the following order to avoid
-      // unnecessary evictions -
-      // 1. Increase the primary cache capacity to total budget
-      // 2. Reserve additional memory in primary on behalf of secondary (by
-      //    increasing pri_cache_res_ reservation)
-      // 3. Increase secondary cache capacity
-      target_->SetCapacity(capacity);
-      s = pri_cache_res_->UpdateCacheReservation(
-          sec_capacity - old_sec_capacity,
-          /*increase=*/true);
-      assert(s.ok());
-      s = secondary_cache_->SetCapacity(sec_capacity);
-      assert(s.ok());
-    }
-  } else {
-    // No cache reservation distribution. Just set the primary cache capacity.
-    target_->SetCapacity(capacity);
-  }
-}
-
-Status CacheWithSecondaryAdapter::GetSecondaryCacheCapacity(
-    size_t& size) const {
-  return secondary_cache_->GetCapacity(size);
-}
-
-Status CacheWithSecondaryAdapter::GetSecondaryCachePinnedUsage(
-    size_t& size) const {
-  Status s;
-  if (distribute_cache_res_) {
-    MutexLock m(&cache_res_mutex_);
-    size_t capacity = 0;
-    s = secondary_cache_->GetCapacity(capacity);
-    if (s.ok()) {
-      size = capacity - pri_cache_res_->GetTotalMemoryUsed();
-    } else {
-      size = 0;
-    }
-  } else {
-    size = 0;
-  }
-  return s;
-}
-
-// Update the secondary/primary allocation ratio (remember, the primary
-// capacity is the total memory budget when distribute_cache_res_ is true).
-// When the ratio changes, we may accumulate some error in the calculations
-// for secondary cache inflate/deflate and pri_cache_res_ reservations.
-// This is due to the rounding of the reservation amount.
-//
-// We rely on the current pri_cache_res_ total memory used to estimate the
-// new secondary cache reservation after the ratio change. For this reason,
-// once the ratio is lowered to 0.0 (effectively disabling the secondary
-// cache and pri_cache_res_ total mem used going down to 0), we cannot
-// increase the ratio and re-enable it, We might remove this limitation
-// in the future.
-Status CacheWithSecondaryAdapter::UpdateCacheReservationRatio(
-    double compressed_secondary_ratio) {
-  if (!distribute_cache_res_) {
-    return Status::NotSupported();
-  }
-
-  MutexLock m(&cache_res_mutex_);
-  size_t pri_capacity = target_->GetCapacity();
-  size_t sec_capacity =
-      static_cast<size_t>(pri_capacity * compressed_secondary_ratio);
-  size_t old_sec_capacity;
-  Status s = secondary_cache_->GetCapacity(old_sec_capacity);
-  if (!s.ok()) {
-    return s;
-  }
-
-  // Calculate the new secondary cache reservation
-  // reserved_usage_ will never be > the cache capacity, so we don't
-  // have to worry about adjusting it here.
-  sec_cache_res_ratio_ = compressed_secondary_ratio;
-  size_t new_sec_reserved =
-      static_cast<size_t>(reserved_usage_ * sec_cache_res_ratio_);
-  if (sec_capacity > old_sec_capacity) {
-    // We're increasing the ratio, thus ending up with a larger secondary
-    // cache and a smaller usable primary cache capacity. Similar to
-    // SetCapacity(), we try to avoid a temporary increase in total usage
-    // beyond the configured capacity -
-    // 1. A higher secondary cache ratio means it gets a higher share of
-    //    cache reservations. So first account for that by deflating the
-    //    secondary cache
-    // 2. Increase pri_cache_res_ reservation to reflect the new secondary
-    //    cache utilization (increase in capacity - increase in share of cache
-    //    reservation)
-    // 3. Increase secondary cache capacity
-    s = secondary_cache_->Deflate(new_sec_reserved - sec_reserved_);
-    assert(s.ok());
-    s = pri_cache_res_->UpdateCacheReservation(
-        (sec_capacity - old_sec_capacity) - (new_sec_reserved - sec_reserved_),
-        /*increase=*/true);
-    assert(s.ok());
-    sec_reserved_ = new_sec_reserved;
-    s = secondary_cache_->SetCapacity(sec_capacity);
-    assert(s.ok());
-  } else {
-    // We're shrinking the ratio. Try to avoid unnecessary evictions -
-    // 1. Lower the secondary cache capacity
-    // 2. Decrease pri_cache_res_ reservation to relect lower secondary
-    //    cache utilization (decrease in capacity - decrease in share of cache
-    //    reservations)
-    // 3. Inflate the secondary cache to give it back the reduction in its
-    //    share of cache reservations
-    s = secondary_cache_->SetCapacity(sec_capacity);
-    if (s.ok()) {
-      s = pri_cache_res_->UpdateCacheReservation(
-          (old_sec_capacity - sec_capacity) -
-              (sec_reserved_ - new_sec_reserved),
-          /*increase=*/false);
-      assert(s.ok());
-      s = secondary_cache_->Inflate(sec_reserved_ - new_sec_reserved);
-      assert(s.ok());
-      sec_reserved_ = new_sec_reserved;
-    }
-  }
-
-  return s;
-}
-
-Status CacheWithSecondaryAdapter::UpdateAdmissionPolicy(
-    TieredAdmissionPolicy adm_policy) {
-  adm_policy_ = adm_policy;
-  return Status::OK();
-}
-
-std::shared_ptr<Cache> NewTieredCache(const TieredCacheOptions& _opts) {
-  if (!_opts.cache_opts) {
-    return nullptr;
-  }
-
-  TieredCacheOptions opts = _opts;
-  {
-    bool valid_adm_policy = true;
-
-    switch (_opts.adm_policy) {
-      case TieredAdmissionPolicy::kAdmPolicyAuto:
-        // Select an appropriate default policy
-        if (opts.adm_policy == TieredAdmissionPolicy::kAdmPolicyAuto) {
-          if (opts.nvm_sec_cache) {
-            opts.adm_policy = TieredAdmissionPolicy::kAdmPolicyThreeQueue;
-          } else {
-            opts.adm_policy = TieredAdmissionPolicy::kAdmPolicyPlaceholder;
-          }
-        }
-        break;
-      case TieredAdmissionPolicy::kAdmPolicyPlaceholder:
-      case TieredAdmissionPolicy::kAdmPolicyAllowCacheHits:
-      case TieredAdmissionPolicy::kAdmPolicyAllowAll:
-        if (opts.nvm_sec_cache) {
-          valid_adm_policy = false;
-        }
-        break;
-      case TieredAdmissionPolicy::kAdmPolicyThreeQueue:
-        if (!opts.nvm_sec_cache) {
-          valid_adm_policy = false;
-        }
-        break;
-      default:
-        valid_adm_policy = false;
-    }
-    if (!valid_adm_policy) {
-      return nullptr;
-    }
-  }
-
-  std::shared_ptr<Cache> cache;
-  if (opts.cache_type == PrimaryCacheType::kCacheTypeLRU) {
-    LRUCacheOptions cache_opts =
-        *(static_cast_with_check<LRUCacheOptions, ShardedCacheOptions>(
-            opts.cache_opts));
-    cache_opts.capacity = opts.total_capacity;
-    cache_opts.secondary_cache = nullptr;
-    cache = cache_opts.MakeSharedCache();
-  } else if (opts.cache_type == PrimaryCacheType::kCacheTypeHCC) {
-    HyperClockCacheOptions cache_opts =
-        *(static_cast_with_check<HyperClockCacheOptions, ShardedCacheOptions>(
-            opts.cache_opts));
-    cache_opts.capacity = opts.total_capacity;
-    cache_opts.secondary_cache = nullptr;
-    cache = cache_opts.MakeSharedCache();
-  } else {
-    return nullptr;
-  }
-  std::shared_ptr<SecondaryCache> sec_cache;
-  opts.comp_cache_opts.capacity = static_cast<size_t>(
-      opts.total_capacity * opts.compressed_secondary_ratio);
-  sec_cache = NewCompressedSecondaryCache(opts.comp_cache_opts);
-
-  if (opts.nvm_sec_cache) {
-    if (opts.adm_policy == TieredAdmissionPolicy::kAdmPolicyThreeQueue) {
-      sec_cache = std::make_shared<TieredSecondaryCache>(
-          sec_cache, opts.nvm_sec_cache,
-          TieredAdmissionPolicy::kAdmPolicyThreeQueue);
-    } else {
-      return nullptr;
-    }
-  }
-
-  return std::make_shared<CacheWithSecondaryAdapter>(
-      cache, sec_cache, opts.adm_policy, /*distribute_cache_res=*/true);
-}
-
-Status UpdateTieredCache(const std::shared_ptr<Cache>& cache,
-                         int64_t total_capacity,
-                         double compressed_secondary_ratio,
-                         TieredAdmissionPolicy adm_policy) {
-  if (!cache || strcmp(cache->Name(), kTieredCacheName)) {
-    return Status::InvalidArgument();
-  }
-  CacheWithSecondaryAdapter* tiered_cache =
-      static_cast<CacheWithSecondaryAdapter*>(cache.get());
-
-  Status s;
-  if (total_capacity > 0) {
-    tiered_cache->SetCapacity(total_capacity);
-  }
-  if (compressed_secondary_ratio >= 0.0 && compressed_secondary_ratio <= 1.0) {
-    s = tiered_cache->UpdateCacheReservationRatio(compressed_secondary_ratio);
-  }
-  if (adm_policy < TieredAdmissionPolicy::kAdmPolicyMax) {
-    s = tiered_cache->UpdateAdmissionPolicy(adm_policy);
-  }
-  return s;
-}
-}  // namespace ROCKSDB_NAMESPACE

cache/secondary_cache_adapter.h

@@ -1,103 +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 "cache/cache_reservation_manager.h"
-#include "rocksdb/secondary_cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class CacheWithSecondaryAdapter : public CacheWrapper {
- public:
-  explicit CacheWithSecondaryAdapter(
-      std::shared_ptr<Cache> target,
-      std::shared_ptr<SecondaryCache> secondary_cache,
-      TieredAdmissionPolicy adm_policy = TieredAdmissionPolicy::kAdmPolicyAuto,
-      bool distribute_cache_res = false);
-
-  ~CacheWithSecondaryAdapter() override;
-
-  Status Insert(
-      const Slice& key, ObjectPtr value, const CacheItemHelper* helper,
-      size_t charge, Handle** handle = nullptr,
-      Priority priority = Priority::LOW,
-      const Slice& compressed_value = Slice(),
-      CompressionType type = CompressionType::kNoCompression) override;
-
-  Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                 CreateContext* create_context,
-                 Priority priority = Priority::LOW,
-                 Statistics* stats = nullptr) override;
-
-  using Cache::Release;
-  bool Release(Handle* handle, bool erase_if_last_ref = false) override;
-
-  ObjectPtr Value(Handle* handle) override;
-
-  void StartAsyncLookup(AsyncLookupHandle& async_handle) override;
-
-  void WaitAll(AsyncLookupHandle* async_handles, size_t count) override;
-
-  std::string GetPrintableOptions() const override;
-
-  const char* Name() const override;
-
-  void SetCapacity(size_t capacity) override;
-
-  Status GetSecondaryCacheCapacity(size_t& size) const override;
-
-  Status GetSecondaryCachePinnedUsage(size_t& size) const override;
-
-  Status UpdateCacheReservationRatio(double ratio);
-
-  Status UpdateAdmissionPolicy(TieredAdmissionPolicy adm_policy);
-
-  Cache* TEST_GetCache() { return target_.get(); }
-
-  SecondaryCache* TEST_GetSecondaryCache() { return secondary_cache_.get(); }
-
- private:
-  static constexpr size_t kReservationChunkSize = 1 << 20;
-
-  bool EvictionHandler(const Slice& key, Handle* handle, bool was_hit);
-
-  void StartAsyncLookupOnMySecondary(AsyncLookupHandle& async_handle);
-
-  Handle* Promote(
-      std::unique_ptr<SecondaryCacheResultHandle>&& secondary_handle,
-      const Slice& key, const CacheItemHelper* helper, Priority priority,
-      Statistics* stats, bool found_dummy_entry, bool kept_in_sec_cache);
-
-  bool ProcessDummyResult(Cache::Handle** handle, bool erase);
-
-  void CleanupCacheObject(ObjectPtr obj, const CacheItemHelper* helper);
-
-  std::shared_ptr<SecondaryCache> secondary_cache_;
-  TieredAdmissionPolicy adm_policy_;
-  // Whether to proportionally distribute cache memory reservations, i.e
-  // placeholder entries with null value and a non-zero charge, across
-  // the primary and secondary caches.
-  bool distribute_cache_res_;
-  // A cache reservation manager to keep track of secondary cache memory
-  // usage by reserving equivalent capacity against the primary cache
-  std::shared_ptr<ConcurrentCacheReservationManager> pri_cache_res_;
-  // Fraction of a cache memory reservation to be assigned to the secondary
-  // cache
-  double sec_cache_res_ratio_;
-  // Mutex for use when managing cache memory reservations. Should not be used
-  // for other purposes, as it may risk causing deadlocks.
-  mutable port::Mutex cache_res_mutex_;
-  // Total memory reserved by placeholder entriesin the cache
-  size_t placeholder_usage_;
-  // Total placeholoder memory charged to both the primary and secondary
-  // caches. Will be <= placeholder_usage_.
-  size_t reserved_usage_;
-  // Amount of memory reserved in the secondary cache. This should be
-  // reserved_usage_ * sec_cache_res_ratio_ in steady state.
-  size_t sec_reserved_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/sharded_cache.cc

@@ -13,102 +13,189 @@
 #include <cstdint>
 #include <memory>
 
-#include "env/unique_id_gen.h"
-#include "rocksdb/env.h"
 #include "util/hash.h"
 #include "util/math.h"
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
+
 namespace {
-// The generated seeds must fit in 31 bits so that
-// ShardedCacheOptions::hash_seed can be set to it explicitly, for
-// diagnostic/debugging purposes.
-constexpr uint32_t kSeedMask = 0x7fffffff;
-uint32_t DetermineSeed(int32_t hash_seed_option) {
-  if (hash_seed_option >= 0) {
-    // User-specified exact seed
-    return static_cast<uint32_t>(hash_seed_option);
-  }
-  static SemiStructuredUniqueIdGen gen;
-  if (hash_seed_option == ShardedCacheOptions::kHostHashSeed) {
-    std::string hostname;
-    Status s = Env::Default()->GetHostNameString(&hostname);
-    if (s.ok()) {
-      return GetSliceHash(hostname) & kSeedMask;
-    } else {
-      // Fall back on something stable within the process.
-      return BitwiseAnd(gen.GetBaseUpper(), kSeedMask);
-    }
-  } else {
-    // for kQuasiRandomHashSeed and fallback
-    uint32_t val = gen.GenerateNext<uint32_t>() & kSeedMask;
-    // Perform some 31-bit bijective transformations so that we get
-    // quasirandom, not just incrementing. (An incrementing seed from a
-    // random starting point would be fine, but hard to describe in a name.)
-    // See https://en.wikipedia.org/wiki/Quasirandom and using a murmur-like
-    // transformation here for our bijection in the lower 31 bits.
-    // See https://en.wikipedia.org/wiki/MurmurHash
-    val *= /*31-bit prime*/ 1150630961;
-    val ^= (val & kSeedMask) >> 17;
-    val *= /*31-bit prime*/ 1320603883;
-    return val & kSeedMask;
-  }
+
+inline uint32_t HashSlice(const Slice& s) {
+  return Lower32of64(GetSliceNPHash64(s));
 }
+
 }  // namespace
 
-ShardedCacheBase::ShardedCacheBase(const ShardedCacheOptions& opts)
-    : Cache(opts.memory_allocator),
-      last_id_(1),
-      shard_mask_((uint32_t{1} << opts.num_shard_bits) - 1),
-      hash_seed_(DetermineSeed(opts.hash_seed)),
-      strict_capacity_limit_(opts.strict_capacity_limit),
-      capacity_(opts.capacity) {}
+ShardedCache::ShardedCache(size_t capacity, int num_shard_bits,
+                           bool strict_capacity_limit,
+                           std::shared_ptr<MemoryAllocator> allocator)
+    : Cache(std::move(allocator)),
+      shard_mask_((uint32_t{1} << num_shard_bits) - 1),
+      capacity_(capacity),
+      strict_capacity_limit_(strict_capacity_limit),
+      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_;
 }
 
-Status ShardedCacheBase::GetSecondaryCacheCapacity(size_t& size) const {
-  size = 0;
-  return Status::OK();
-}
-
-Status ShardedCacheBase::GetSecondaryCachePinnedUsage(size_t& size) const {
-  size = 0;
-  return Status::OK();
-}
-
-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);
@@ -122,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) {
@@ -138,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,313 +10,123 @@
 #pragma once
 
 #include <atomic>
-#include <cstdint>
 #include <string>
 
-#include "port/lang.h"
 #include "port/port.h"
-#include "rocksdb/advanced_cache.h"
-#include "util/hash.h"
-#include "util/mutexlock.h"
+#include "rocksdb/cache.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, uint32_t seed) {
-    return GetSliceNPHash64(key, seed);
-  }
-  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,
-                bool standalone) = 0;
-  Handle* CreateStandalone(const Slice& key, HashCref hash, ObjectPtr obj,
-                           const CacheItemHelper* helper,
-                           size_t charge, bool allow_uncharged) = 0;
-  HandleImpl* Lookup(const Slice& key, HashCref hash,
-                        const Cache::CacheItemHelper* helper,
-                        Cache::CreateContext* create_context,
-                        Cache::Priority priority,
-                        Statistics* stats) = 0;
-  bool Release(HandleImpl* handle, bool useful, bool erase_if_last_ref) = 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:
-  explicit ShardedCacheBase(const ShardedCacheOptions& opts);
-  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;
-  Status GetSecondaryCacheCapacity(size_t& size) const override;
-  Status GetSecondaryCachePinnedUsage(size_t& size) const override;
-
-  using Cache::GetUsage;
-  size_t GetUsage(Handle* handle) const override;
-  std::string GetPrintableOptions() const override;
-
-  uint32_t GetHashSeed() const override { return hash_seed_; }
-
- 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_;
-  const uint32_t hash_seed_;
-
-  // 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;
-
-  explicit ShardedCache(const ShardedCacheOptions& opts)
-      : ShardedCacheBase(opts),
-        shards_(static_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 obj, const CacheItemHelper* helper,
-      size_t charge, Handle** handle = nullptr,
-      Priority priority = Priority::LOW,
-      const Slice& /*compressed_value*/ = Slice(),
-      CompressionType /*type*/ = CompressionType::kNoCompression) override {
-    assert(helper);
-    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
-    auto h_out = reinterpret_cast<HandleImpl**>(handle);
-    return GetShard(hash).Insert(key, hash, obj, helper, charge, h_out,
-                                 priority);
-  }
-
-  Handle* CreateStandalone(const Slice& key, ObjectPtr obj,
-                           const CacheItemHelper* helper, size_t charge,
-                           bool allow_uncharged) override {
-    assert(helper);
-    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
-    HandleImpl* result = GetShard(hash).CreateStandalone(
-        key, hash, obj, helper, charge, allow_uncharged);
-    return static_cast<Handle*>(result);
-  }
-
-  Handle* Lookup(const Slice& key, const CacheItemHelper* helper = nullptr,
-                 CreateContext* create_context = nullptr,
-                 Priority priority = Priority::LOW,
-                 Statistics* stats = nullptr) override {
-    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
-    HandleImpl* result = GetShard(hash).Lookup(key, hash, helper,
-                                               create_context, priority, stats);
-    return static_cast<Handle*>(result);
-  }
-
-  void Erase(const Slice& key) override {
-    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
-    GetShard(hash).Erase(key, hash);
-  }
-
-  bool Release(Handle* handle, bool useful,
-               bool erase_if_last_ref = false) override {
-    auto h = static_cast<HandleImpl*>(handle);
-    return GetShard(h->GetHash()).Release(h, useful, erase_if_last_ref);
-  }
-  bool Ref(Handle* handle) override {
-    auto h = static_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::GetOccupancyCount);
-  }
-  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);
-  }
-
-  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 void ForEachShard(
-      const std::function<void(const CacheShard*)>& fn) const {
-    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/tiered_secondary_cache.cc

@@ -1,125 +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/tiered_secondary_cache.h"
-
-#include "monitoring/statistics_impl.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Creation callback for use in the lookup path. It calls the upper layer
-// create_cb to create the object, and optionally calls the compressed
-// secondary cache InsertSaved to save the compressed block. If
-// advise_erase is set, it means the primary cache wants the block to be
-// erased in the secondary cache, so we skip calling InsertSaved.
-//
-// For the time being, we assume that all blocks in the nvm tier belong to
-// the primary block cache (i.e CacheTier::kVolatileTier). That can be changed
-// if we implement demotion from the compressed secondary cache to the nvm
-// cache in the future.
-Status TieredSecondaryCache::MaybeInsertAndCreate(
-    const Slice& data, CompressionType type, CacheTier source,
-    Cache::CreateContext* ctx, MemoryAllocator* allocator,
-    Cache::ObjectPtr* out_obj, size_t* out_charge) {
-  TieredSecondaryCache::CreateContext* context =
-      static_cast<TieredSecondaryCache::CreateContext*>(ctx);
-  assert(source == CacheTier::kVolatileTier);
-  if (!context->advise_erase && type != kNoCompression) {
-    // Attempt to insert into compressed secondary cache
-    // TODO: Don't hardcode the source
-    context->comp_sec_cache->InsertSaved(*context->key, data, type, source)
-        .PermitUncheckedError();
-    RecordTick(context->stats, COMPRESSED_SECONDARY_CACHE_PROMOTIONS);
-  } else {
-    RecordTick(context->stats, COMPRESSED_SECONDARY_CACHE_PROMOTION_SKIPS);
-  }
-  // Primary cache will accept the object, so call its helper to create
-  // the object
-  return context->helper->create_cb(data, type, source, context->inner_ctx,
-                                    allocator, out_obj, out_charge);
-}
-
-// The lookup first looks up in the compressed secondary cache. If its a miss,
-// then the nvm cache lookup is called. The cache item helper and create
-// context are wrapped in order to intercept the creation callback to make
-// the decision on promoting to the compressed secondary cache.
-std::unique_ptr<SecondaryCacheResultHandle> TieredSecondaryCache::Lookup(
-    const Slice& key, const Cache::CacheItemHelper* helper,
-    Cache::CreateContext* create_context, bool wait, bool advise_erase,
-    Statistics* stats, bool& kept_in_sec_cache) {
-  bool dummy = false;
-  std::unique_ptr<SecondaryCacheResultHandle> result =
-      target()->Lookup(key, helper, create_context, wait, advise_erase, stats,
-                       /*kept_in_sec_cache=*/dummy);
-  // We never want the item to spill back into the secondary cache
-  kept_in_sec_cache = true;
-  if (result) {
-    assert(result->IsReady());
-    return result;
-  }
-
-  // If wait is true, then we can be a bit more efficient and avoid a memory
-  // allocation for the CReateContext.
-  const Cache::CacheItemHelper* outer_helper =
-      TieredSecondaryCache::GetHelper();
-  if (wait) {
-    TieredSecondaryCache::CreateContext ctx;
-    ctx.key = &key;
-    ctx.advise_erase = advise_erase;
-    ctx.helper = helper;
-    ctx.inner_ctx = create_context;
-    ctx.comp_sec_cache = target();
-    ctx.stats = stats;
-
-    return nvm_sec_cache_->Lookup(key, outer_helper, &ctx, wait, advise_erase,
-                                  stats, kept_in_sec_cache);
-  }
-
-  // If wait is false, i.e its an async lookup, we have to allocate a result
-  // handle for tracking purposes. Embed the CreateContext inside the handle
-  // so we need only allocate memory once instead of twice.
-  std::unique_ptr<ResultHandle> handle(new ResultHandle());
-  handle->ctx()->key = &key;
-  handle->ctx()->advise_erase = advise_erase;
-  handle->ctx()->helper = helper;
-  handle->ctx()->inner_ctx = create_context;
-  handle->ctx()->comp_sec_cache = target();
-  handle->ctx()->stats = stats;
-  handle->SetInnerHandle(
-      nvm_sec_cache_->Lookup(key, outer_helper, handle->ctx(), wait,
-                             advise_erase, stats, kept_in_sec_cache));
-  if (!handle->inner_handle()) {
-    handle.reset();
-  } else {
-    result.reset(handle.release());
-  }
-
-  return result;
-}
-
-// Call the nvm cache WaitAll to complete the lookups
-void TieredSecondaryCache::WaitAll(
-    std::vector<SecondaryCacheResultHandle*> handles) {
-  std::vector<SecondaryCacheResultHandle*> nvm_handles;
-  std::vector<ResultHandle*> my_handles;
-  nvm_handles.reserve(handles.size());
-  for (auto handle : handles) {
-    // The handle could belong to the compressed secondary cache. Skip if
-    // that's the case.
-    if (handle->IsReady()) {
-      continue;
-    }
-    ResultHandle* hdl = static_cast<ResultHandle*>(handle);
-    nvm_handles.push_back(hdl->inner_handle());
-    my_handles.push_back(hdl);
-  }
-  nvm_sec_cache_->WaitAll(nvm_handles);
-  for (auto handle : my_handles) {
-    assert(handle->inner_handle()->IsReady());
-    handle->Complete();
-  }
-}
-
-}  // namespace ROCKSDB_NAMESPACE

cache/tiered_secondary_cache.h

@@ -1,158 +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 "rocksdb/cache.h"
-#include "rocksdb/secondary_cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A SecondaryCache that implements stacking of a compressed secondary cache
-// and a non-volatile (local flash) cache. It implements an admission
-// policy of warming the bottommost tier (local flash) with compressed
-// blocks from the SST on misses, and on hits in the bottommost tier,
-// promoting to the compressed and/or primary block cache. The admission
-// policies of the primary block cache and compressed secondary cache remain
-// unchanged - promote on second access. There is no demotion ofablocks
-// evicted from a tier. They are just discarded.
-//
-// In order to properly handle compressed blocks directly read from SSTs, and
-// to allow writeback of blocks compressed by the compressed secondary
-// cache in the future, we make use of the compression type and source
-// cache tier arguments in InsertSaved.
-class TieredSecondaryCache : public SecondaryCacheWrapper {
- public:
-  TieredSecondaryCache(std::shared_ptr<SecondaryCache> comp_sec_cache,
-                       std::shared_ptr<SecondaryCache> nvm_sec_cache,
-                       TieredAdmissionPolicy adm_policy)
-      : SecondaryCacheWrapper(comp_sec_cache), nvm_sec_cache_(nvm_sec_cache) {
-#ifndef NDEBUG
-    assert(adm_policy == TieredAdmissionPolicy::kAdmPolicyThreeQueue);
-#else
-    (void)adm_policy;
-#endif
-  }
-
-  ~TieredSecondaryCache() override {}
-
-  const char* Name() const override { return "TieredSecondaryCache"; }
-
-  // This is a no-op as we currently don't allow demotion (i.e
-  // insertion by the upper layer) of evicted blocks.
-  Status Insert(const Slice& /*key*/, Cache::ObjectPtr /*obj*/,
-                const Cache::CacheItemHelper* /*helper*/,
-                bool /*force_insert*/) override {
-    return Status::OK();
-  }
-
-  // Warm up the nvm tier directly
-  Status InsertSaved(const Slice& key, const Slice& saved,
-                     CompressionType type = CompressionType::kNoCompression,
-                     CacheTier source = CacheTier::kVolatileTier) override {
-    return nvm_sec_cache_->InsertSaved(key, saved, type, source);
-  }
-
-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CacheItemHelper* helper,
-      Cache::CreateContext* create_context, bool wait, bool advise_erase,
-      Statistics* stats, bool& kept_in_sec_cache) override;
-
-  void WaitAll(std::vector<SecondaryCacheResultHandle*> handles) override;
-
- private:
-  struct CreateContext : public Cache::CreateContext {
-    const Slice* key;
-    bool advise_erase;
-    const Cache::CacheItemHelper* helper;
-    Cache::CreateContext* inner_ctx;
-    std::shared_ptr<SecondaryCacheResultHandle> inner_handle;
-    SecondaryCache* comp_sec_cache;
-    Statistics* stats;
-  };
-
-  class ResultHandle : public SecondaryCacheResultHandle {
-   public:
-    ~ResultHandle() override {}
-
-    bool IsReady() override {
-      if (inner_handle_ && inner_handle_->IsReady()) {
-        Complete();
-      }
-      return ready_;
-    }
-
-    void Wait() override {
-      inner_handle_->Wait();
-      Complete();
-    }
-
-    size_t Size() override { return size_; }
-
-    Cache::ObjectPtr Value() override { return value_; }
-
-    void Complete() {
-      size_ = inner_handle_->Size();
-      value_ = inner_handle_->Value();
-      inner_handle_.reset();
-      ready_ = true;
-    }
-
-    void SetInnerHandle(std::unique_ptr<SecondaryCacheResultHandle>&& handle) {
-      inner_handle_ = std::move(handle);
-    }
-
-    void SetSize(size_t size) { size_ = size; }
-
-    void SetValue(Cache::ObjectPtr val) { value_ = val; }
-
-    CreateContext* ctx() { return &ctx_; }
-
-    SecondaryCacheResultHandle* inner_handle() { return inner_handle_.get(); }
-
-   private:
-    std::unique_ptr<SecondaryCacheResultHandle> inner_handle_;
-    CreateContext ctx_;
-    size_t size_;
-    Cache::ObjectPtr value_;
-    bool ready_ = false;
-  };
-
-  static void NoopDelete(Cache::ObjectPtr /*obj*/,
-                         MemoryAllocator* /*allocator*/) {
-    assert(false);
-  }
-  static size_t ZeroSize(Cache::ObjectPtr /*obj*/) {
-    assert(false);
-    return 0;
-  }
-  static Status NoopSaveTo(Cache::ObjectPtr /*from_obj*/,
-                           size_t /*from_offset*/, size_t /*length*/,
-                           char* /*out_buf*/) {
-    assert(false);
-    return Status::OK();
-  }
-  static Status MaybeInsertAndCreate(const Slice& data, CompressionType type,
-                                     CacheTier source,
-                                     Cache::CreateContext* ctx,
-                                     MemoryAllocator* allocator,
-                                     Cache::ObjectPtr* out_obj,
-                                     size_t* out_charge);
-
-  static const Cache::CacheItemHelper* GetHelper() {
-    const static Cache::CacheItemHelper basic_helper(CacheEntryRole::kMisc,
-                                                     &NoopDelete);
-    const static Cache::CacheItemHelper maybe_insert_and_create_helper{
-        CacheEntryRole::kMisc, &NoopDelete,           &ZeroSize,
-        &NoopSaveTo,           &MaybeInsertAndCreate, &basic_helper,
-    };
-    return &maybe_insert_and_create_helper;
-  }
-
-  std::shared_ptr<SecondaryCache> comp_sec_cache_;
-  std::shared_ptr<SecondaryCache> nvm_sec_cache_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

cache/tiered_secondary_cache_test.cc

@@ -1,994 +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/compressed_secondary_cache.h"
-#include "cache/secondary_cache_adapter.h"
-#include "db/db_test_util.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/secondary_cache.h"
-#include "typed_cache.h"
-#include "util/random.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class TestSecondaryCache : public SecondaryCache {
- public:
-  explicit TestSecondaryCache(size_t capacity, bool ready_before_wait)
-      : cache_(NewLRUCache(capacity, 0, false, 0.5 /* high_pri_pool_ratio */,
-                           nullptr, kDefaultToAdaptiveMutex,
-                           kDontChargeCacheMetadata)),
-        ready_before_wait_(ready_before_wait),
-        num_insert_saved_(0),
-        num_hits_(0),
-        num_misses_(0) {}
-
-  const char* Name() const override { return "TestSecondaryCache"; }
-
-  Status Insert(const Slice& /*key*/, Cache::ObjectPtr /*value*/,
-                const Cache::CacheItemHelper* /*helper*/,
-                bool /*force_insert*/) override {
-    assert(false);
-    return Status::NotSupported();
-  }
-
-  Status InsertSaved(const Slice& key, const Slice& saved,
-                     CompressionType type = kNoCompression,
-                     CacheTier source = CacheTier::kVolatileTier) override {
-    CheckCacheKeyCommonPrefix(key);
-    size_t size;
-    char* buf;
-    Status s;
-
-    num_insert_saved_++;
-    size = saved.size();
-    buf = new char[size + sizeof(uint64_t) + 2 * sizeof(uint16_t)];
-    EncodeFixed64(buf, size);
-    buf += sizeof(uint64_t);
-    EncodeFixed16(buf, type);
-    buf += sizeof(uint16_t);
-    EncodeFixed16(buf, (uint16_t)source);
-    buf += sizeof(uint16_t);
-    memcpy(buf, saved.data(), size);
-    buf -= sizeof(uint64_t) + 2 * sizeof(uint16_t);
-    if (!s.ok()) {
-      delete[] buf;
-      return s;
-    }
-    return cache_.Insert(key, buf, size);
-  }
-
-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CacheItemHelper* helper,
-      Cache::CreateContext* create_context, bool wait, bool /*advise_erase*/,
-      Statistics* /*stats*/, bool& kept_in_sec_cache) override {
-    std::string key_str = key.ToString();
-    TEST_SYNC_POINT_CALLBACK("TestSecondaryCache::Lookup", &key_str);
-
-    std::unique_ptr<SecondaryCacheResultHandle> secondary_handle;
-    kept_in_sec_cache = false;
-
-    TypedHandle* handle = cache_.Lookup(key);
-    if (handle) {
-      num_hits_++;
-      Cache::ObjectPtr value = nullptr;
-      size_t charge = 0;
-      Status s;
-      char* ptr = cache_.Value(handle);
-      CompressionType type;
-      CacheTier source;
-      size_t size = DecodeFixed64(ptr);
-      ptr += sizeof(uint64_t);
-      type = static_cast<CompressionType>(DecodeFixed16(ptr));
-      ptr += sizeof(uint16_t);
-      source = static_cast<CacheTier>(DecodeFixed16(ptr));
-      assert(source == CacheTier::kVolatileTier);
-      ptr += sizeof(uint16_t);
-      s = helper->create_cb(Slice(ptr, size), type, source, create_context,
-                            /*alloc*/ nullptr, &value, &charge);
-      if (s.ok()) {
-        secondary_handle.reset(new TestSecondaryCacheResultHandle(
-            cache_.get(), handle, value, charge,
-            /*ready=*/wait || ready_before_wait_));
-        kept_in_sec_cache = true;
-      } else {
-        cache_.Release(handle);
-      }
-    } else {
-      num_misses_++;
-    }
-    return secondary_handle;
-  }
-
-  bool SupportForceErase() const override { return false; }
-
-  void Erase(const Slice& /*key*/) override {}
-
-  void WaitAll(std::vector<SecondaryCacheResultHandle*> handles) override {
-    for (SecondaryCacheResultHandle* handle : handles) {
-      TestSecondaryCacheResultHandle* sec_handle =
-          static_cast<TestSecondaryCacheResultHandle*>(handle);
-      EXPECT_FALSE(sec_handle->IsReady());
-      sec_handle->SetReady();
-    }
-  }
-
-  std::string GetPrintableOptions() const override { return ""; }
-
-  uint32_t num_insert_saved() { return num_insert_saved_; }
-
-  uint32_t num_hits() { return num_hits_; }
-
-  uint32_t num_misses() { return num_misses_; }
-
-  void CheckCacheKeyCommonPrefix(const Slice& key) {
-    Slice current_prefix(key.data(), OffsetableCacheKey::kCommonPrefixSize);
-    if (ckey_prefix_.empty()) {
-      ckey_prefix_ = current_prefix.ToString();
-    } else {
-      EXPECT_EQ(ckey_prefix_, current_prefix.ToString());
-    }
-  }
-
- private:
-  class TestSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
-   public:
-    TestSecondaryCacheResultHandle(Cache* cache, Cache::Handle* handle,
-                                   Cache::ObjectPtr value, size_t size,
-                                   bool ready)
-        : cache_(cache),
-          handle_(handle),
-          value_(value),
-          size_(size),
-          is_ready_(ready) {}
-
-    ~TestSecondaryCacheResultHandle() override { cache_->Release(handle_); }
-
-    bool IsReady() override { return is_ready_; }
-
-    void Wait() override {}
-
-    Cache::ObjectPtr Value() override {
-      assert(is_ready_);
-      return value_;
-    }
-
-    size_t Size() override { return Value() ? size_ : 0; }
-
-    void SetReady() { is_ready_ = true; }
-
-   private:
-    Cache* cache_;
-    Cache::Handle* handle_;
-    Cache::ObjectPtr value_;
-    size_t size_;
-    bool is_ready_;
-  };
-
-  using SharedCache =
-      BasicTypedSharedCacheInterface<char[], CacheEntryRole::kMisc>;
-  using TypedHandle = SharedCache::TypedHandle;
-  SharedCache cache_;
-  bool ready_before_wait_;
-  uint32_t num_insert_saved_;
-  uint32_t num_hits_;
-  uint32_t num_misses_;
-  std::string ckey_prefix_;
-};
-
-class DBTieredSecondaryCacheTest : public DBTestBase {
- public:
-  DBTieredSecondaryCacheTest()
-      : DBTestBase("db_tiered_secondary_cache_test", /*env_do_fsync=*/true) {}
-
-  std::shared_ptr<Cache> NewCache(
-      size_t pri_capacity, size_t compressed_capacity, size_t nvm_capacity,
-      TieredAdmissionPolicy adm_policy = TieredAdmissionPolicy::kAdmPolicyAuto,
-      bool ready_before_wait = false) {
-    LRUCacheOptions lru_opts;
-    TieredCacheOptions opts;
-    lru_opts.capacity = 0;
-    lru_opts.num_shard_bits = 0;
-    lru_opts.high_pri_pool_ratio = 0;
-    opts.cache_opts = &lru_opts;
-    opts.cache_type = PrimaryCacheType::kCacheTypeLRU;
-    opts.comp_cache_opts.capacity = 0;
-    opts.comp_cache_opts.num_shard_bits = 0;
-    opts.total_capacity = pri_capacity + compressed_capacity;
-    opts.compressed_secondary_ratio = compressed_secondary_ratio_ =
-        (double)compressed_capacity / opts.total_capacity;
-    if (nvm_capacity > 0) {
-      nvm_sec_cache_.reset(
-          new TestSecondaryCache(nvm_capacity, ready_before_wait));
-      opts.nvm_sec_cache = nvm_sec_cache_;
-    }
-    opts.adm_policy = adm_policy;
-    cache_ = NewTieredCache(opts);
-    assert(cache_ != nullptr);
-
-    return cache_;
-  }
-
-  void ClearPrimaryCache() {
-    ASSERT_EQ(UpdateTieredCache(cache_, -1, 1.0), Status::OK());
-    ASSERT_EQ(UpdateTieredCache(cache_, -1, compressed_secondary_ratio_),
-              Status::OK());
-  }
-
-  TestSecondaryCache* nvm_sec_cache() { return nvm_sec_cache_.get(); }
-
-  CompressedSecondaryCache* compressed_secondary_cache() {
-    return static_cast<CompressedSecondaryCache*>(
-        static_cast<CacheWithSecondaryAdapter*>(cache_.get())
-            ->TEST_GetSecondaryCache());
-  }
-
- private:
-  std::shared_ptr<Cache> cache_;
-  std::shared_ptr<TestSecondaryCache> nvm_sec_cache_;
-  double compressed_secondary_ratio_;
-};
-
-// In this test, the block size is set to 4096. Each value is 1007 bytes, so
-// each data block contains exactly 4 KV pairs. Metadata blocks are not
-// cached, so we can accurately estimate the cache usage.
-TEST_F(DBTieredSecondaryCacheTest, BasicTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  // We want a block cache of size 5KB, and a compressed secondary cache of
-  // size 5KB. However, we specify a block cache size of 256KB here in order
-  // to take into account the cache reservation in the block cache on
-  // behalf of the compressed cache. The unit of cache reservation is 256KB.
-  // The effective block cache capacity will be calculated as 256 + 5 = 261KB,
-  // and 256KB will be reserved for the compressed cache, leaving 5KB for
-  // the primary block cache. We only have to worry about this here because
-  // the cache size is so small.
-  table_options.block_cache = NewCache(256 * 1024, 5 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  // Disable paranoid_file_checks so that flush will not read back the newly
-  // written file
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  // The first 2 Gets, for keys 0 and 5, will load the corresponding data
-  // blocks as they will be cache misses. The nvm secondary cache will be
-  // warmed up with the compressed blocks
-  std::string v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 1u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 1u);
-
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-
-  // At this point, the nvm cache is warmed up with the data blocks for 0
-  // and 5. The next Get will lookup the block in nvm and will be a hit.
-  // It will be created as a standalone entry in memory, and a placeholder
-  // will be inserted in the primary and compressed caches.
-  v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 1u);
-
-  // For this Get, the primary and compressed only have placeholders for
-  // the required data block. So we will lookup the nvm cache and find the
-  // block there. This time, the block will be promoted to the primary
-  // block cache. No promotion to the compressed secondary cache happens,
-  // and it will retain the placeholder.
-  v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 2u);
-
-  // This Get will find the data block in the primary cache.
-  v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 2u);
-
-  // We repeat the sequence for key 5. This will end up evicting the block
-  // for 0 from the in-memory cache.
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 3u);
-
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 4u);
-
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 4u);
-
-  // This Get for key 0 will find the data block in nvm. Since the compressed
-  // cache still has the placeholder, the block (compressed) will be
-  // admitted. It is theh inserted into the primary as a standalone entry.
-  v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 5u);
-
-  // This Get for key 0 will find the data block in the compressed secondary
-  // cache.
-  v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 2u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 5u);
-
-  Destroy(options);
-}
-
-// This test is very similar to BasicTest, except it calls MultiGet rather
-// than Get, in order to exercise the async lookup and WaitAll path.
-TEST_F(DBTieredSecondaryCacheTest, BasicMultiGetTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(260 * 1024, 10 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 3u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 6u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 6u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 9u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 12u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 12u);
-
-  Destroy(options);
-}
-
-TEST_F(DBTieredSecondaryCacheTest, WaitAllTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(250 * 1024, 20 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  // Insert placeholders for 4 in primary and compressed
-  std::string val = Get(Key(4));
-
-  // Force placeholder 4 out of primary
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(24));
-  keys.push_back(Key(28));
-  keys.push_back(Key(32));
-  keys.push_back(Key(36));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 10u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 10u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 1u);
-
-  // Now read 4 again. This will create a placeholder in primary, and insert
-  // in compressed secondary since it already has a placeholder
-  val = Get(Key(4));
-
-  // Now read 0, 4 and 8. While 4 is already in the compressed secondary
-  // cache, 0 and 8 will be read asynchronously from the nvm tier. The
-  // WaitAll will be called for all 3 blocks.
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 10u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 10u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 4u);
-
-  Destroy(options);
-}
-
-TEST_F(DBTieredSecondaryCacheTest, ReadyBeforeWaitAllTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(250 * 1024, 20 * 1024, 256 * 1024,
-                                       TieredAdmissionPolicy::kAdmPolicyAuto,
-                                       /*ready_before_wait=*/true);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.statistics = CreateDBStatistics();
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 3u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(12));
-  keys.push_back(Key(16));
-  keys.push_back(Key(20));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 6u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 6u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 3u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 6u);
-
-  ClearPrimaryCache();
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(32));
-  keys.push_back(Key(36));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 4u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 8u);
-
-  keys.clear();
-  values.clear();
-  keys.push_back(Key(0));
-  keys.push_back(Key(32));
-  keys.push_back(Key(36));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 4u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 8u);
-
-  Destroy(options);
-}
-
-// This test is for iteration. It iterates through a set of keys in two
-// passes. First pass loads the compressed blocks into the nvm tier, and
-// the second pass should hit all of those blocks.
-TEST_F(DBTieredSecondaryCacheTest, IterateTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(250 * 1024, 10 * 1024, 256 * 1024);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  ReadOptions ro;
-  ro.readahead_size = 256 * 1024;
-  auto iter = dbfull()->NewIterator(ro);
-  iter->SeekToFirst();
-  for (int i = 0; i < 31; ++i) {
-    ASSERT_EQ(Key(i), iter->key().ToString());
-    ASSERT_EQ(1007, iter->value().size());
-    iter->Next();
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-  delete iter;
-
-  iter = dbfull()->NewIterator(ro);
-  iter->SeekToFirst();
-  for (int i = 0; i < 31; ++i) {
-    ASSERT_EQ(Key(i), iter->key().ToString());
-    ASSERT_EQ(1007, iter->value().size());
-    iter->Next();
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 8u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 8u);
-  delete iter;
-
-  Destroy(options);
-}
-
-class DBTieredAdmPolicyTest
-    : public DBTieredSecondaryCacheTest,
-      public testing::WithParamInterface<TieredAdmissionPolicy> {};
-
-TEST_P(DBTieredAdmPolicyTest, CompressedOnlyTest) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  // We want a block cache of size 10KB, and a compressed secondary cache of
-  // size 10KB. However, we specify a block cache size of 256KB here in order
-  // to take into account the cache reservation in the block cache on
-  // behalf of the compressed cache. The unit of cache reservation is 256KB.
-  // The effective block cache capacity will be calculated as 256 + 10 = 266KB,
-  // and 256KB will be reserved for the compressed cache, leaving 10KB for
-  // the primary block cache. We only have to worry about this here because
-  // the cache size is so small.
-  table_options.block_cache = NewCache(256 * 1024, 10 * 1024, 0, GetParam());
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
-  // Disable paranoid_file_checks so that flush will not read back the newly
-  // written file
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  // The first 2 Gets, for keys 0 and 5, will load the corresponding data
-  // blocks as they will be cache misses. Since this is a 2-tier cache (
-  // primary and compressed), no warm-up should happen with the compressed
-  // blocks.
-  std::string v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-
-  ASSERT_EQ(compressed_secondary_cache()->TEST_GetUsage(), comp_cache_usage);
-
-  Destroy(options);
-}
-
-TEST_P(DBTieredAdmPolicyTest, CompressedCacheAdmission) {
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  BlockBasedTableOptions table_options;
-  // We want a block cache of size 5KB, and a compressed secondary cache of
-  // size 5KB. However, we specify a block cache size of 256KB here in order
-  // to take into account the cache reservation in the block cache on
-  // behalf of the compressed cache. The unit of cache reservation is 256KB.
-  // The effective block cache capacity will be calculated as 256 + 5 = 261KB,
-  // and 256KB will be reserved for the compressed cache, leaving 10KB for
-  // the primary block cache. We only have to worry about this here because
-  // the cache size is so small.
-  table_options.block_cache = NewCache(256 * 1024, 5 * 1024, 0, GetParam());
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  size_t comp_cache_usage = compressed_secondary_cache()->TEST_GetUsage();
-  // Disable paranoid_file_checks so that flush will not read back the newly
-  // written file
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  // The second Get (for 5) will evict the data block loaded by the first
-  // Get, which will be admitted into the compressed secondary cache only
-  // for the kAdmPolicyAllowAll policy
-  std::string v = Get(Key(0));
-  ASSERT_EQ(1007, v.size());
-
-  v = Get(Key(5));
-  ASSERT_EQ(1007, v.size());
-
-  if (GetParam() == TieredAdmissionPolicy::kAdmPolicyAllowAll) {
-    ASSERT_GT(compressed_secondary_cache()->TEST_GetUsage(),
-              comp_cache_usage + 128);
-  } else {
-    ASSERT_LT(compressed_secondary_cache()->TEST_GetUsage(),
-              comp_cache_usage + 128);
-  }
-
-  Destroy(options);
-}
-
-TEST_F(DBTieredSecondaryCacheTest, FSBufferTest) {
-  class WrapFS : public FileSystemWrapper {
-   public:
-    explicit WrapFS(const std::shared_ptr<FileSystem>& _target)
-        : FileSystemWrapper(_target) {}
-    ~WrapFS() override {}
-    const char* Name() const override { return "WrapFS"; }
-
-    IOStatus NewRandomAccessFile(const std::string& fname,
-                                 const FileOptions& opts,
-                                 std::unique_ptr<FSRandomAccessFile>* result,
-                                 IODebugContext* dbg) override {
-      class WrappedRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
-       public:
-        explicit WrappedRandomAccessFile(
-            std::unique_ptr<FSRandomAccessFile>& file)
-            : FSRandomAccessFileOwnerWrapper(std::move(file)) {}
-
-        IOStatus MultiRead(FSReadRequest* reqs, size_t num_reqs,
-                           const IOOptions& options,
-                           IODebugContext* dbg) override {
-          for (size_t i = 0; i < num_reqs; ++i) {
-            FSReadRequest& req = reqs[i];
-            FSAllocationPtr buffer(new char[req.len], [](void* ptr) {
-              delete[] static_cast<char*>(ptr);
-            });
-            req.fs_scratch = std::move(buffer);
-            req.status = Read(req.offset, req.len, options, &req.result,
-                              static_cast<char*>(req.fs_scratch.get()), dbg);
-          }
-          return IOStatus::OK();
-        }
-      };
-
-      std::unique_ptr<FSRandomAccessFile> file;
-      IOStatus s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
-      EXPECT_OK(s);
-      result->reset(new WrappedRandomAccessFile(file));
-
-      return s;
-    }
-
-    void SupportedOps(int64_t& supported_ops) override {
-      supported_ops = 1 << FSSupportedOps::kAsyncIO;
-      supported_ops |= 1 << FSSupportedOps::kFSBuffer;
-    }
-  };
-
-  if (!LZ4_Supported()) {
-    ROCKSDB_GTEST_SKIP("This test requires LZ4 support.");
-    return;
-  }
-
-  std::shared_ptr<WrapFS> wrap_fs =
-      std::make_shared<WrapFS>(env_->GetFileSystem());
-  std::unique_ptr<Env> wrap_env(new CompositeEnvWrapper(env_, wrap_fs));
-  BlockBasedTableOptions table_options;
-  table_options.block_cache = NewCache(250 * 1024, 20 * 1024, 256 * 1024,
-                                       TieredAdmissionPolicy::kAdmPolicyAuto,
-                                       /*ready_before_wait=*/true);
-  table_options.block_size = 4 * 1024;
-  table_options.cache_index_and_filter_blocks = false;
-  Options options = GetDefaultOptions();
-  options.create_if_missing = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.statistics = CreateDBStatistics();
-  options.env = wrap_env.get();
-
-  options.paranoid_file_checks = false;
-  DestroyAndReopen(options);
-  Random rnd(301);
-  const int N = 256;
-  for (int i = 0; i < N; i++) {
-    std::string p_v;
-    test::CompressibleString(&rnd, 0.5, 1007, &p_v);
-    ASSERT_OK(Put(Key(i), p_v));
-  }
-
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys;
-  std::vector<std::string> values;
-
-  keys.push_back(Key(0));
-  keys.push_back(Key(4));
-  keys.push_back(Key(8));
-  values = MultiGet(keys, /*snapshot=*/nullptr, /*async=*/true);
-  ASSERT_EQ(values.size(), keys.size());
-  for (const auto& value : values) {
-    ASSERT_EQ(1007, value.size());
-  }
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 3u);
-  ASSERT_EQ(nvm_sec_cache()->num_hits(), 0u);
-
-  std::string v = Get(Key(12));
-  ASSERT_EQ(1007, v.size());
-  ASSERT_EQ(nvm_sec_cache()->num_insert_saved(), 4u);
-  ASSERT_EQ(nvm_sec_cache()->num_misses(), 4u);
-  ASSERT_EQ(options.statistics->getTickerCount(BLOCK_CACHE_MISS), 4u);
-
-  Close();
-  Destroy(options);
-}
-
-INSTANTIATE_TEST_CASE_P(
-    DBTieredAdmPolicyTest, DBTieredAdmPolicyTest,
-    ::testing::Values(TieredAdmissionPolicy::kAdmPolicyAuto,
-                      TieredAdmissionPolicy::kAdmPolicyPlaceholder,
-                      TieredAdmissionPolicy::kAdmPolicyAllowCacheHits,
-                      TieredAdmissionPolicy::kAdmPolicyAllowAll));
-
-}  // namespace ROCKSDB_NAMESPACE
-
-int main(int argc, char** argv) {
-  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

cache/typed_cache.h

@@ -1,380 +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_cache.h"
-#include "rocksdb/advanced_options.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, GetHelper(), charge,
-                                handle);
-  }
-
-  static const Cache::CacheItemHelper* GetHelper() {
-    static const Cache::CacheItemHelper kHelper{kRole};
-    return &kHelper;
-  }
-};
-
-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 const Cache::CacheItemHelper* GetBasicHelper() {
-    static const Cache::CacheItemHelper kHelper{kRole,
-                                                &BasicTypedCacheHelper::Delete};
-    return &kHelper;
-  }
-};
-
-// 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>::GetBasicHelper;
-  // ctor
-  using BaseCacheInterface<CachePtr>::BaseCacheInterface;
-  struct TypedAsyncLookupHandle : public Cache::AsyncLookupHandle {
-    TypedHandle* Result() {
-      return static_cast<TypedHandle*>(Cache::AsyncLookupHandle::Result());
-    }
-  };
-
-  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),
-        GetBasicHelper(), charge, untyped_handle, priority);
-  }
-
-  inline TypedHandle* Lookup(const Slice& key, Statistics* stats = nullptr) {
-    return static_cast<TypedHandle*>(this->cache_->BasicLookup(key, stats));
-  }
-
-  inline void StartAsyncLookup(TypedAsyncLookupHandle& async_handle) {
-    assert(async_handle.helper == nullptr);
-    this->cache_->StartAsyncLookup(async_handle);
-  }
-
-  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, CompressionType type,
-                       CacheTier source, CreateContext* context,
-                       MemoryAllocator* allocator, ObjectPtr* out_obj,
-                       size_t* out_charge) {
-    std::unique_ptr<TValue> value = nullptr;
-    if (source != CacheTier::kVolatileTier) {
-      return Status::InvalidArgument();
-    }
-    if constexpr (sizeof(TCreateContext) > 0) {
-      TCreateContext* tcontext = static_cast<TCreateContext*>(context);
-      tcontext->Create(&value, out_charge, data, type, allocator);
-    } else {
-      TCreateContext::Create(&value, out_charge, data, type, 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 const Cache::CacheItemHelper* GetFullHelper() {
-    static const Cache::CacheItemHelper kHelper{
-        kRole,
-        &FullTypedCacheHelper::Delete,
-        &FullTypedCacheHelper::Size,
-        &FullTypedCacheHelper::SaveTo,
-        &FullTypedCacheHelper::Create,
-        BasicTypedCacheHelper<TValue, kRole>::GetBasicHelper()};
-    return &kHelper;
-  }
-};
-
-// 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 BasicTypedCacheInterface<TValue, kRole,
-                                          CachePtr>::TypedAsyncLookupHandle;
-  using typename BasicTypedCacheHelperFns<TValue>::TValuePtr;
-  using BasicTypedCacheHelper<TValue, kRole>::GetBasicHelper;
-  using FullTypedCacheHelper<TValue, TCreateContext, kRole>::GetFullHelper;
-  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,
-      const Slice& compressed = Slice(),
-      CompressionType type = CompressionType::kNoCompression) {
-    auto untyped_handle = reinterpret_cast<Handle**>(handle);
-    auto helper = lowest_used_cache_tier > CacheTier::kVolatileTier
-                      ? GetFullHelper()
-                      : GetBasicHelper();
-    return this->cache_->Insert(key, UpCastValue(value), helper, charge,
-                                untyped_handle, priority, compressed, type);
-  }
-
-  // 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 = GetFullHelper()->create_cb(
-        data, kNoCompression, CacheTier::kVolatileTier, 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 {
-      GetFullHelper()->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, Statistics* stats = nullptr,
-      CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier) {
-    if (lowest_used_cache_tier > CacheTier::kVolatileTier) {
-      return static_cast<TypedHandle*>(this->cache_->Lookup(
-          key, GetFullHelper(), create_context, priority, stats));
-    } else {
-      return BasicTypedCacheInterface<TValue, kRole, CachePtr>::Lookup(key,
-                                                                       stats);
-    }
-  }
-
-  inline void StartAsyncLookupFull(
-      TypedAsyncLookupHandle& async_handle,
-      CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier) {
-    if (lowest_used_cache_tier > CacheTier::kVolatileTier) {
-      async_handle.helper = GetFullHelper();
-      this->cache_->StartAsyncLookup(async_handle);
-    } else {
-      BasicTypedCacheInterface<TValue, kRole, CachePtr>::StartAsyncLookup(
-          async_handle);
-    }
-  }
-};
-
-// 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()