Improvements

This change introduces two key optimizations:
* Mutex scope reduction: Limits the lock to individual partitions within `TaggedCache`, reducing contention.
* Decoupling: Removes the tight coupling between `LedgerHistory` and `TaggedCache`, improving modularity and testability.

Lock contention analysis based on eBPF showed significant improvements as a result of this change.

.github/actions/dependencies/action.yml

@@ -6,36 +6,17 @@ inputs:
 runs:
   using: composite
   steps:
-    - name: unlock Conan
-      shell: bash
-      run: conan remove --locks
-    - name: export custom recipes
+    - name: add Conan remote
+      if: env.CONAN_URL != ''
       shell: bash
       run: |
-        conan config set general.revisions_enabled=1
-        conan export external/snappy snappy/1.1.10@
-        conan export external/rocksdb rocksdb/9.7.3@
-        conan export external/soci soci/4.0.3@
-        conan export external/nudb nudb/2.0.8@
-    - name: add Ripple Conan remote
-      shell: bash
-      run: |
-        conan remote list
-        conan remote remove ripple || true
-        # Do not quote the URL. An empty string will be accepted (with
-        # a non-fatal warning), but a missing argument will not.
-        conan remote add ripple ${{ env.CONAN_URL }} --insert 0
-    - name: try to authenticate to Ripple Conan remote
-      id: remote
-      shell: bash
-      run: |
-        # `conan user` implicitly uses the environment variables
-        # CONAN_LOGIN_USERNAME_<REMOTE> and CONAN_PASSWORD_<REMOTE>.
-        # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
-        # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
-        # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
-        echo outcome=$(conan user --remote ripple --password >&2 \
-          && echo success || echo failure) | tee ${GITHUB_OUTPUT}
+        if conan remote list | grep -q 'xrplf'; then
+          conan remote update --index 0 --url ${CONAN_URL} xrplf
+          echo "Updated Conan remote 'xrplf' to ${CONAN_URL}."
+        else
+          conan remote add --index 0 xrplf ${CONAN_URL}
+          echo "Added new Conan remote 'xrplf' at ${CONAN_URL}."
+        fi
     - name: list missing binaries
       id: binaries
       shell: bash
@@ -51,7 +32,15 @@ runs:
         conan install \
           --output-folder . \
           --build missing \
-          --options tests=True \
-          --options xrpld=True \
-          --settings build_type=${{ inputs.configuration }} \
+          --options:host "&:tests=True" \
+          --options:host "&:xrpld=True" \
+          --settings:all build_type=${{ inputs.configuration }} \
           ..
+    - name: upload dependencies
+      if: ${{ env.CONAN_URL != '' && env.CONAN_LOGIN_USERNAME_XRPLF != '' && env.CONAN_PASSWORD_XRPLF != '' && github.ref_type == 'branch' && github.ref_name == github.event.repository.default_branch }}
+      shell: bash
+      run: |
+        echo "Logging into Conan remote 'xrplf' at ${CONAN_URL}."
+        conan remote login xrplf "${{ env.CONAN_LOGIN_USERNAME_XRPLF }}" --password "${{ env.CONAN_PASSWORD_XRPLF }}"
+        echo "Uploading dependencies for configuration '${{ inputs.configuration }}'."
+        conan upload --all --confirm --remote xrplf . --settings build_type=${{ inputs.configuration }}

.github/workflows/clang-format.yml

@@ -9,24 +9,25 @@ jobs:
   check:
     if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-24.04
-    env:
-      CLANG_VERSION: 18
+    container: ghcr.io/xrplf/ci/tools-rippled-clang-format
     steps:
+      # For jobs running in containers, $GITHUB_WORKSPACE and ${{ github.workspace }} might not be the
+      # same directory. The actions/checkout step is *supposed* to checkout into $GITHUB_WORKSPACE and
+      # then add it to safe.directory (see instructions at https://github.com/actions/checkout)
+      # but that's apparently not happening for some container images. We can't be sure what is actually
+      # happening, so let's pre-emptively add both directories to safe.directory. There's a
+      # Github issue opened in 2022 and not resolved in 2025 https://github.com/actions/runner/issues/2058 ¯\_(ツ)_/¯
+      - run: |
+          git config --global --add safe.directory $GITHUB_WORKSPACE
+          git config --global --add safe.directory ${{ github.workspace }}
       - uses: actions/checkout@v4
-      - name: Install clang-format
-        run: |
-          codename=$( lsb_release --codename --short )
-          sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
-          deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          EOF
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
-          sudo apt-get update
-          sudo apt-get install clang-format-${CLANG_VERSION}
       - name: Format first-party sources
-        run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
+        run: |
+          clang-format --version
+          find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format -i {} +
       - name: Check for differences
         id: assert
+        shell: bash
         run: |
           set -o pipefail
           git diff --exit-code | tee "clang-format.patch"
@@ -58,6 +59,6 @@ jobs:
                in your repo, commit, and push.
         run: |
           echo "${PREAMBLE}"
-          clang-format-${CLANG_VERSION} --version
+          clang-format --version
           echo "${SUGGESTION}"
           exit 1

.github/workflows/libxrpl.yml

@@ -1,8 +1,8 @@
 name: Check libXRPL compatibility with Clio
 env:
-  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
-  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+  CONAN_URL: https://conan.ripplex.io
+  CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_XRPLF: ${{ secrets.CONAN_TOKEN }}
 on:
   pull_request:
     paths:
@@ -43,20 +43,20 @@ jobs:
         shell: bash
         run: |
           conan export . ${{ steps.channel.outputs.channel }}
-      - name: Add Ripple Conan remote
+      - name: Add Conan remote
         shell: bash
         run: |
           conan remote list
-          conan remote remove ripple || true
+          conan remote remove xrplf || true
           # Do not quote the URL. An empty string will be accepted (with a non-fatal warning), but a missing argument will not.
-          conan remote add ripple ${{ env.CONAN_URL }} --insert 0
+          conan remote add xrplf ${{ env.CONAN_URL }} --insert 0
       - name: Parse new version
         id: version
         shell: bash
         run: |
           echo version="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" \
             | awk -F '"' '{print $2}')" | tee ${GITHUB_OUTPUT}
-      - name: Try to authenticate to Ripple Conan remote
+      - name: Try to authenticate to Conan remote
         id: remote
         shell: bash
         run: |
@@ -64,7 +64,7 @@ jobs:
           # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
           # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
           # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
-          echo outcome=$(conan user --remote ripple --password >&2 \
+          echo outcome=$(conan user --remote xrplf --password >&2 \
             && echo success || echo failure) | tee ${GITHUB_OUTPUT}
       - name: Upload new package
         id: upload

.github/workflows/macos.yml

@@ -15,6 +15,18 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  CONAN_URL: https://conan.ripplex.io
+  CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_XRPLF: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{os.cpu_count()}}
+    core.upload:parallel={{os.cpu_count()}}
+    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
 
 jobs:
 
@@ -28,23 +40,22 @@ jobs:
           - Ninja
         configuration:
           - Release
-    runs-on: [self-hosted, macOS]
+    runs-on: [self-hosted, macOS, mac-runner-m1]
     env:
       # The `build` action requires these variables.
       build_dir: .build
       NUM_PROCESSORS: 12
     steps:
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: install Conan
         run: |
-          brew install conan@1
-          echo '/opt/homebrew/opt/conan@1/bin' >> $GITHUB_PATH
+          brew install conan
       - name: install Ninja
         if: matrix.generator == 'Ninja'
         run: brew install ninja
       - name: install python
-        run: | 
+        run: |
           if which python > /dev/null 2>&1; then
               echo "Python executable exists"
           else
@@ -76,14 +87,11 @@ jobs:
           clang --version
       - name: configure Conan
         run : |
-          conan profile new default --detect || true
-          conan profile update settings.compiler.cppstd=20 default
+          echo "${CONAN_GLOBAL_CONF}" > $(conan config home)/global.conf
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
+          conan profile show
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -96,4 +104,7 @@ jobs:
         run: |
           n=$(nproc)
           echo "Using $n test jobs"
-          ${build_dir}/rippled --unittest --unittest-jobs $n
+
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $n
+          ctest -j $n --output-on-failure

.github/workflows/nix.yml

@@ -16,6 +16,19 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  CONAN_URL: https://conan.ripplex.io
+  CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_XRPLF: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{ os.cpu_count() }}
+    core.upload:parallel={{ os.cpu_count() }}
+    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
+
 # This workflow has multiple job matrixes.
 # They can be considered phases because most of the matrices ("test",
 # "coverage", "conan", ) depend on the first ("dependencies").
@@ -54,59 +67,45 @@ jobs:
           - Release
         include:
           - compiler: gcc
-            profile:
-              version: 11
-              cc: /usr/bin/gcc
-              cxx: /usr/bin/g++
+            compiler_version: 12
+            distro: ubuntu
+            codename: jammy
           - compiler: clang
-            profile:
-              version: 14
-              cc: /usr/bin/clang-14
-              cxx: /usr/bin/clang++-14
+            compiler_version: 16
+            distro: debian
+            codename: bookworm
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
           lsb_release -a || true
-          ${{ matrix.profile.cc }} --version
+          ${{ matrix.compiler }}-${{ matrix.compiler_version }} --version
           conan --version
           cmake --version
           env | sort
       - name: configure Conan
         run: |
-          conan profile new default --detect
-          conan profile update settings.compiler.cppstd=20 default
-          conan profile update settings.compiler=${{ matrix.compiler }} default
-          conan profile update settings.compiler.version=${{ matrix.profile.version }} default
-          conan profile update settings.compiler.libcxx=libstdc++11 default
-          conan profile update env.CC=${{ matrix.profile.cc }} default
-          conan profile update env.CXX=${{ matrix.profile.cxx }} default
-          conan profile update conf.tools.build:compiler_executables='{"c": "${{ matrix.profile.cc }}", "cpp": "${{ matrix.profile.cxx }}"}' default
+          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
+          conan profile show
       - name: archive profile
         # Create this archive before dependencies are added to the local cache.
-        run: tar -czf conan.tar -C ~/.conan .
+        run: tar -czf conan.tar.gz -C ${CONAN_HOME} .
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: upload archive
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
-          path: conan.tar
+          path: conan.tar.gz
           if-no-files-found: error
 
   test:
@@ -121,26 +120,32 @@ jobs:
         configuration:
           - Debug
           - Release
+        include:
+          - compiler: gcc
+            compiler_version: 12
+            distro: ubuntu
+            codename: jammy
+          - compiler: clang
+            compiler_version: 16
+            distro: debian
+            codename: bookworm
         cmake-args:
           -
           - "-Dunity=ON"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
-          tar -xzf conan.tar -C ~/.conan
+          mkdir -p ${CONAN_HOME}
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           env | sort
@@ -148,11 +153,9 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -161,9 +164,21 @@ jobs:
           generator: Ninja
           configuration: ${{ matrix.configuration }}
           cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
+      - name: check linking
+        run: |
+          cd ${build_dir}
+          ldd ./rippled
+          if [ "$(ldd ./rippled | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
+            echo 'The binary is statically linked.'
+          else
+            echo 'The binary is dynamically linked.'
+            exit 1
+          fi
       - name: test
         run: |
-          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure
 
   reference-fee-test:
     strategy:
@@ -180,21 +195,18 @@ jobs:
           - "-DUNIT_TEST_REFERENCE_FEE=1000"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
-          tar -xzf conan.tar -C ~/.conan
+          mkdir -p ${CONAN_HOME}
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           env | sort
@@ -202,11 +214,9 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -217,7 +227,9 @@ jobs:
           cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
       - name: test
         run: |
-          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure
 
   coverage:
     strategy:
@@ -231,23 +243,18 @@ jobs:
           - Debug
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
-          tar -xzf conan.tar -C ~/.conan
-      - name: install gcovr
-        run: pip install "gcovr>=7,<9"
+          mkdir -p ${CONAN_HOME}
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
@@ -255,13 +262,11 @@ jobs:
           cmake --version
           gcovr --version
           env | sort
-          ls ~/.conan
+          ls ${CONAN_HOME}
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -283,7 +288,7 @@ jobs:
         run: |
           mv "${build_dir}/coverage.xml" ./
       - name: archive coverage report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: coverage.xml
           path: coverage.xml
@@ -305,22 +310,23 @@ jobs:
   conan:
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
+    container:
+      image: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
       build_dir: .build
+      platform: linux
+      compiler: gcc
+      compiler_version: 12
       configuration: Release
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
-          name: linux-gcc-${{ env.configuration }}
+          name: ${{ env.platform }}-${{ env.compiler }}-${{ env.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
-          tar -xzf conan.tar -C ~/.conan
+          mkdir -p ${CONAN_HOME}
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           env | sort
@@ -328,95 +334,66 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ env.configuration }}
       - name: export
         run: |
-          version=$(conan inspect --raw version .)
-          reference="xrpl/${version}@local/test"
-          conan remove -f ${reference} || true
-          conan export . local/test
-          echo "reference=${reference}" >> "${GITHUB_ENV}"
+          conan export . --version head
       - name: build
         run: |
           cd tests/conan
-          mkdir ${build_dir}
-          cd ${build_dir}
-          conan install .. --output-folder . \
-            --require-override ${reference} --build missing
+          mkdir ${build_dir} && cd ${build_dir}
+          conan install .. \
+            --settings:all build_type=${configuration} \
+            --output-folder . \
+            --build missing
           cmake .. \
             -DCMAKE_TOOLCHAIN_FILE:FILEPATH=./build/${configuration}/generators/conan_toolchain.cmake \
             -DCMAKE_BUILD_TYPE=${configuration}
           cmake --build .
           ./example | grep '^[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]\+'
 
-  # NOTE we are not using dependencies built above because it lags with
-  # compiler versions. Instrumentation requires clang version 16 or
-  # later
-
   instrumentation-build:
-    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
-    env:
-      CLANG_RELEASE: 16
-    strategy:
-      fail-fast: false
+    needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: debian:bookworm
+    container: ghcr.io/xrplf/ci/debian-bookworm:clang-16
+    env:
+      build_dir: .build
     steps:
-        - name: install prerequisites
-          env:
-            DEBIAN_FRONTEND: noninteractive
+        - name: download cache
+          uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+          with:
+            name: linux-clang-Debug
+
+        - name: extract cache
           run: |
-            apt-get update
-            apt-get install --yes --no-install-recommends \
-              clang-${CLANG_RELEASE} clang++-${CLANG_RELEASE} \
-              python3-pip python-is-python3 make cmake git wget
-            apt-get clean
-            update-alternatives --install \
-              /usr/bin/clang clang /usr/bin/clang-${CLANG_RELEASE} 100 \
-              --slave /usr/bin/clang++ clang++ /usr/bin/clang++-${CLANG_RELEASE}
-            update-alternatives --auto clang
-            pip install --no-cache --break-system-packages "conan<2"
+            mkdir -p ${CONAN_HOME}
+            tar -xzf conan.tar.gz -C ${CONAN_HOME}
+
+        - name: check environment
+          run: |
+            echo ${PATH} | tr ':' '\n'
+            conan --version
+            cmake --version
+            env | sort
+            ls ${CONAN_HOME}
 
         - name: checkout
-          uses: actions/checkout@v4
+          uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+
+        - name: dependencies
+          uses: ./.github/actions/dependencies
+          with:
+            configuration: Debug
 
         - name: prepare environment
           run: |
-            mkdir ${GITHUB_WORKSPACE}/.build
-            echo "SOURCE_DIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
-            echo "BUILD_DIR=$GITHUB_WORKSPACE/.build" >> $GITHUB_ENV
-            echo "CC=/usr/bin/clang" >> $GITHUB_ENV
-            echo "CXX=/usr/bin/clang++" >> $GITHUB_ENV
-
-        - name: configure Conan
-          run: |
-            conan profile new --detect default
-            conan profile update settings.compiler=clang default
-            conan profile update settings.compiler.version=${CLANG_RELEASE} default
-            conan profile update settings.compiler.libcxx=libstdc++11 default
-            conan profile update settings.compiler.cppstd=20 default
-            conan profile update options.rocksdb=False default
-            conan profile update \
-              'conf.tools.build:compiler_executables={"c": "/usr/bin/clang", "cpp": "/usr/bin/clang++"}' default
-            conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
-            conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
-            conan export external/snappy snappy/1.1.10@
-            conan export external/soci soci/4.0.3@
-
-        - name: build dependencies
-          run: |
-            cd ${BUILD_DIR}
-            conan install ${SOURCE_DIR} \
-              --output-folder ${BUILD_DIR} \
-              --install-folder ${BUILD_DIR} \
-              --build missing \
-              --settings build_type=Debug
+            mkdir -p ${build_dir}
+            echo "SOURCE_DIR=$(pwd)" >> $GITHUB_ENV
+            echo "BUILD_DIR=$(pwd)/${build_dir}" >> $GITHUB_ENV
 
         - name: build with instrumentation
           run: |
@@ -441,3 +418,4 @@ jobs:
           run: |
             cd ${BUILD_DIR}
             ./rippled -u --unittest-jobs $(( $(nproc)/4 ))
+            ctest -j $(nproc) --output-on-failure

.github/workflows/windows.yml

@@ -18,6 +18,18 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  CONAN_URL: https://conan.ripplex.io
+  CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_XRPLF: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{os.cpu_count()}}
+    core.upload:parallel={{os.cpu_count()}}
+    tools.build:jobs=24
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
 
 jobs:
 
@@ -42,11 +54,11 @@ jobs:
       build_dir: .build
     steps:
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: choose Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
         with:
-          python-version: 3.9
+          python-version: 3.13
       - name: learn Python cache directory
         id: pip-cache
         shell: bash
@@ -54,12 +66,12 @@ jobs:
           python -m pip install --upgrade pip
           echo "dir=$(pip cache dir)" | tee ${GITHUB_OUTPUT}
       - name: restore Python cache directory
-        uses: actions/cache@v4
+        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684
         with:
             path: ${{ steps.pip-cache.outputs.dir }}
             key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
       - name: install Conan
-        run: pip install wheel 'conan<2'
+        run: pip install wheel conan
       - name: check environment
         run: |
           dir env:
@@ -70,17 +82,11 @@ jobs:
       - name: configure Conan
         shell: bash
         run: |
-          conan profile new default --detect
-          conan profile update settings.compiler.cppstd=20 default
-          conan profile update \
-            settings.compiler.runtime=MT${{ matrix.configuration.runtime }} \
-            default
+          echo "${CONAN_GLOBAL_CONF}" > $(conan config home)/global.conf
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
+          conan profile show
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration.type }}
       - name: build
@@ -95,5 +101,6 @@ jobs:
         shell: bash
         if: ${{ matrix.configuration.tests }}
         run: |
-          ${build_dir}/${{ matrix.configuration.type }}/rippled --unittest \
-              --unittest-jobs $(nproc)
+          cd ${build_dir}/${{ matrix.configuration.type }}
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.3
+  rev: v18.1.8
   hooks:
   - id: clang-format

BUILD.md

@@ -3,29 +3,29 @@
 | These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
 
 > These instructions also assume a basic familiarity with Conan and CMake.
-> If you are unfamiliar with Conan,
-> you can read our [crash course](./docs/build/conan.md)
-> or the official [Getting Started][3] walkthrough.
+> If you are unfamiliar with Conan, you can read our
+> [crash course](./docs/build/conan.md) or the official [Getting Started][3]
+> walkthrough.
 
 ## Branches
 
 For a stable release, choose the `master` branch or one of the [tagged
 releases](https://github.com/ripple/rippled/releases).
 
-```
+```bash
 git checkout master
 ```
 
 For the latest release candidate, choose the `release` branch.
 
-```
+```bash
 git checkout release
 ```
 
 For the latest set of untested features, or to contribute, choose the `develop`
 branch.
 
-```
+```bash
 git checkout develop
 ```
 
@@ -33,176 +33,295 @@ git checkout develop
 
 See [System Requirements](https://xrpl.org/system-requirements.html).
 
-Building rippled generally requires git, Python, Conan, CMake, and a C++ compiler. Some guidance on setting up such a [C++ development environment can be found here](./docs/build/environment.md).
+Building rippled generally requires git, Python, Conan, CMake, and a C++
+compiler. Some guidance on setting up such a [C++ development environment can be
+found here](./docs/build/environment.md).
 
-- [Python 3.7](https://www.python.org/downloads/)
-- [Conan 1.60](https://conan.io/downloads.html)[^1]
-- [CMake 3.16](https://cmake.org/download/)
+- [Python 3.11](https://www.python.org/downloads/), or higher
+- [Conan 2.17](https://conan.io/downloads.html)[^1], or higher
+- [CMake 3.22](https://cmake.org/download/)[^2], or higher
 
-[^1]: It is possible to build with Conan 2.x,
-but the instructions are significantly different,
-which is why we are not recommending it yet.
-Notably, the `conan profile update` command is removed in 2.x.
-Profiles must be edited by hand.
+[^1]: It is possible to build with Conan 1.60+, but the instructions are
+significantly different, which is why we are not recommending it.
+
+[^2]: CMake 4 is not yet supported by all dependencies required by this project.
+If you are affected by this issue, follow [conan workaround for cmake
+4](#workaround-for-cmake-4)
 
 `rippled` is written in the C++20 dialect and includes the `<concepts>` header.
 The [minimum compiler versions][2] required are:
 
 | Compiler    | Version |
-|-------------|---------|
-| GCC         | 11      |
-| Clang       | 13      |
-| Apple Clang | 13.1.6  |
-| MSVC        | 19.23   |
+|-------------|-----|
+| GCC         | 12  |
+| Clang       | 16  |
+| Apple Clang | 16  |
+| MSVC        | 19.44[^3] |
 
 ### Linux
 
-The Ubuntu operating system has received the highest level of
-quality assurance, testing, and support.
+The Ubuntu Linux distribution has received the highest level of quality
+assurance, testing, and support. We also support Red Hat and use Debian
+internally.
 
-Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
+Here are [sample instructions for setting up a C++ development environment on
+Linux](./docs/build/environment.md#linux).
 
 ### Mac
 
 Many rippled engineers use macOS for development.
 
-Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
+Here are [sample instructions for setting up a C++ development environment on
+macOS](./docs/build/environment.md#macos).
 
 ### Windows
 
-Windows is not recommended for production use at this time.
+Windows is used by some engineers for development only.
 
-- Additionally, 32-bit Windows development is not supported.
-
-[Boost]: https://www.boost.org/
+[^3]: Windows is not recommended for production use.
 
 ## Steps
 
 ### Set Up Conan
 
-After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python, Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
+After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python,
+Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
 
-These instructions assume a basic familiarity with Conan and CMake.
+These instructions assume a basic familiarity with Conan and CMake. If you are
+unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official
+[Getting Started][3] walkthrough.
 
-If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
+#### Default profile
+We recommend that you import the provided `conan/profiles/default` profile:
 
-You'll need at least one Conan profile:
-
-   ```
-   conan profile new default --detect
-   ```
-
-Update the compiler settings:
-
-   ```
-   conan profile update settings.compiler.cppstd=20 default
-   ```
-
-Configure Conan (1.x only) to use recipe revisions:
-
-   ```
-   conan config set general.revisions_enabled=1
-   ```
-
-**Linux** developers will commonly have a default Conan [profile][] that compiles
-with GCC and links with libstdc++.
-If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
-then you will need to choose the `libstdc++11` ABI:
-
-   ```
-   conan profile update settings.compiler.libcxx=libstdc++11 default
-   ```
-
-
-Ensure inter-operability between `boost::string_view` and `std::string_view` types:
-
-```
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_BEAST_USE_STD_STRING_VIEW"]' default
-conan profile update 'env.CXXFLAGS="-DBOOST_BEAST_USE_STD_STRING_VIEW"' default
+```bash
+conan config install conan/profiles/ -tf $(conan config home)/profiles/
 ```
 
-If you have other flags in the `conf.tools.build` or `env.CXXFLAGS` sections, make sure to retain the existing flags and append the new ones. You can check them with:
-```
-conan profile show default
+You can check your Conan profile by running:
+
+```bash
+conan profile show
 ```
 
+#### Custom profile
 
-**Windows** developers may need to use the x64 native build tools.
-An easy way to do that is to run the shortcut "x64 Native Tools Command
-Prompt" for the version of Visual Studio that you have installed.
+If the default profile does not work for you and you do not yet have a Conan
+profile, you can create one by running:
 
-   Windows developers must also build `rippled` and its dependencies for the x64
-   architecture:
-
-   ```
-   conan profile update settings.arch=x86_64 default
-   ```
-
-### Multiple compilers
-
-When `/usr/bin/g++` exists on a platform, it is the default cpp compiler. This
-default works for some users.
-
-However, if this compiler cannot build rippled or its dependencies, then you can
-install another compiler and set Conan and CMake to use it.
-Update the `conf.tools.build:compiler_executables` setting in order to set the correct variables (`CMAKE_<LANG>_COMPILER`) in the
-generated CMake toolchain file.
-For example, on Ubuntu 20, you may have gcc at `/usr/bin/gcc` and g++ at `/usr/bin/g++`; if that is the case, you can select those compilers with:
-```
-conan profile update 'conf.tools.build:compiler_executables={"c": "/usr/bin/gcc", "cpp": "/usr/bin/g++"}' default
+```bash
+conan profile detect
 ```
 
-Replace `/usr/bin/gcc` and `/usr/bin/g++` with paths to the desired compilers.
+You may need to make changes to the profile to suit your environment. You can
+refer to the provided `conan/profiles/default` profile for inspiration, and you
+may also need to apply the required [tweaks](#conan-profile-tweaks) to this
+default profile.
 
-It should choose the compiler for dependencies as well,
-but not all of them have a Conan recipe that respects this setting (yet).
-For the rest, you can set these environment variables.
-Replace `<path>` with paths to the desired compilers:
+### Patched recipes
 
-- `conan profile update env.CC=<path> default`
-- `conan profile update env.CXX=<path> default`
+The recipes in Conan Center occasionally need to be patched for compatibility
+with the latest version of `rippled`. We maintain a fork of the Conan Center
+[here](https://github.com/XRPLF/conan-center-index/) containing the patches.
 
-Export our [Conan recipe for Snappy](./external/snappy).
-It does not explicitly link the C++ standard library,
-which allows you to statically link it with GCC, if you want.
+To ensure our patched recipes are used, you must add our Conan remote at a
+higher index than the default Conan Center remote, so it is consulted first. You
+can do this by running:
 
-   ```
-   # Conan 1.x
-   conan export external/snappy snappy/1.1.10@
-   # Conan 2.x
-   conan export --version 1.1.10 external/snappy
+```bash
+conan remote add --index 0 xrplf "https://conan.ripplex.io"
+```
+
+Alternatively, you can pull the patched recipes into the repository and use them
+locally:
+
+```bash
+cd external
+git init
+git remote add origin git@github.com:XRPLF/conan-center-index.git
+git sparse-checkout init
+git sparse-checkout set recipes/snappy
+git sparse-checkout add recipes/soci
+git fetch origin master
+git checkout master
+conan export --version 1.1.10 external/recipes/snappy
+conan export --version 4.0.3 external/recipes/soci
+```
+
+In the case we switch to a newer version of a dependency that still requires a
+patch, it will be necessary for you to pull in the changes and re-export the
+updated dependencies with the newer version. However, if we switch to a newer
+version that no longer requires a patch, no action is required on your part, as
+the new recipe will be automatically pulled from the official Conan Center.
+
+### Conan profile tweaks
+
+#### Missing compiler version
+
+If you see an error similar to the following after running `conan profile show`:
+
+```bash
+ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
+Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
+'9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
+'15.0', '16', '16.0']
+Read "http://docs.conan.io/2/knowledge/faq.html#error-invalid-setting"
+```
+
+you need to amend the list of compiler versions in
+`$(conan config home)/settings.yml`, by appending the required version number(s)
+to the `version` array specific for your compiler. For example:
+
+```yaml
+   apple-clang:
+      version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.3", "8.0", "8.1", "9.0",
+                "9.1", "10.0", "11.0", "12.0", "13", "13.0", "13.1", "14",
+                "14.0", "15", "15.0", "16", "16.0", "17", "17.0"]
+```
+
+#### Multiple compilers
+
+If you have multiple compilers installed, make sure to select the one to use in
+your default Conan configuration **before** running `conan profile detect`, by
+setting the `CC` and `CXX` environment variables.
+
+For example, if you are running MacOS and have [homebrew
+LLVM@18](https://formulae.brew.sh/formula/llvm@18), and want to use it as a
+compiler in the new Conan profile:
+
+   ```bash
+   export CC=$(brew --prefix llvm@18)/bin/clang
+   export CXX=$(brew --prefix llvm@18)/bin/clang++
+   conan profile detect
    ```
 
-Export our [Conan recipe for RocksDB](./external/rocksdb).
-It does not override paths to dependencies when building with Visual Studio.
+You should also explicitly set the path to the compiler in the profile file,
+which helps to avoid errors when `CC` and/or `CXX` are set and disagree with the
+selected Conan profile. For example:
 
-   ```
-   # Conan 1.x
-   conan export external/rocksdb rocksdb/9.7.3@
-   # Conan 2.x
-   conan export --version 9.7.3 external/rocksdb
-   ```
+```text
+[conf]
+tools.build:compiler_executables={'c':'/usr/bin/gcc','cpp':'/usr/bin/g++'}
+```
 
-Export our [Conan recipe for SOCI](./external/soci).
-It patches their CMake to correctly import its dependencies.
+#### Multiple profiles
 
-   ```
-   # Conan 1.x
-   conan export external/soci soci/4.0.3@
-   # Conan 2.x
-   conan export --version 4.0.3 external/soci
-   ```
+You can manage multiple Conan profiles in the directory
+`$(conan config home)/profiles`, for example renaming `default` to a different
+name and then creating a new `default` profile for a different compiler.
 
-Export our [Conan recipe for NuDB](./external/nudb).
-It fixes some source files to add missing `#include`s.
+#### Select language
 
+The default profile created by Conan will typically select different C++ dialect
+than C++20 used by this project. You should set `20` in the profile line
+starting with `compiler.cppstd=`. For example:
 
-   ```
-   # Conan 1.x
-   conan export external/nudb nudb/2.0.8@
-   # Conan 2.x
-   conan export --version 2.0.8 external/nudb
-   ```
+```bash
+sed -i.bak -e 's|^compiler\.cppstd=.*$|compiler.cppstd=20|' $(conan config home)/profiles/default
+```
+
+#### Select standard library in Linux
+
+**Linux** developers will commonly have a default Conan [profile][] that
+compiles with GCC and links with libstdc++. If you are linking with libstdc++
+(see profile setting `compiler.libcxx`), then you will need to choose the
+`libstdc++11` ABI:
+
+```bash
+sed -i.bak -e 's|^compiler\.libcxx=.*$|compiler.libcxx=libstdc++11|' $(conan config home)/profiles/default
+```
+
+#### Select architecture and runtime in Windows
+
+**Windows** developers may need to use the x64 native build tools. An easy way
+to do that is to run the shortcut "x64 Native Tools Command Prompt" for the
+version of Visual Studio that you have installed.
+
+Windows developers must also build `rippled` and its dependencies for the x64
+architecture:
+
+```bash
+sed -i.bak -e 's|^arch=.*$|arch=x86_64|' $(conan config home)/profiles/default
+```
+
+**Windows** developers also must select static runtime:
+
+```bash
+sed -i.bak -e 's|^compiler\.runtime=.*$|compiler.runtime=static|' $(conan config home)/profiles/default
+```
+
+#### Workaround for CMake 4
+
+If your system CMake is version 4 rather than 3, you may have to configure Conan
+profile to use CMake version 3 for dependencies, by adding the following two
+lines to your profile:
+
+```text
+[tool_requires]
+!cmake/*: cmake/[>=3 <4]
+```
+
+This will force Conan to download and use a locally cached CMake 3 version, and
+is needed because some of the dependencies used by this project do not support
+CMake 4.
+
+#### Clang workaround for grpc
+
+If your compiler is clang, version 19 or later, or apple-clang, version 17 or
+later, you may encounter a compilation error while building the `grpc`
+dependency:
+
+```text
+In file included from .../lib/promise/try_seq.h:26:
+.../lib/promise/detail/basic_seq.h:499:38: error: a template argument list is expected after a name prefixed by the template keyword [-Wmissing-template-arg-list-after-template-kw]
+  499 |                     Traits::template CallSeqFactory(f_, *cur_, std::move(arg)));
+      |                                      ^
+```
+
+The workaround for this error is to add two lines to profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
+```
+
+#### Workaround for gcc 12
+
+If your compiler is gcc, version 12, and you have enabled `werr` option, you may
+encounter a compilation error such as:
+
+```text
+/usr/include/c++/12/bits/char_traits.h:435:56: error: 'void* __builtin_memcpy(void*, const void*, long unsigned int)' accessing 9223372036854775810 or more bytes at offsets [2, 9223372036854775807] and 1 may overlap up to 9223372036854775813 bytes at offset -3 [-Werror=restrict]
+  435 |         return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      |                                        ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
+cc1plus: all warnings being treated as errors
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-restrict']
+```
+
+#### Workaround for clang 16
+
+If your compiler is clang, version 16, you may encounter compilation error such
+as:
+
+```text
+In file included from .../boost/beast/websocket/stream.hpp:2857:
+.../boost/beast/websocket/impl/read.hpp:695:17: error: call to 'async_teardown' is ambiguous
+                async_teardown(impl.role, impl.stream(),
+                ^~~~~~~~~~~~~~
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-DBOOST_ASIO_DISABLE_CONCEPTS']
+```
 
 ### Build and Test
 
@@ -270,7 +389,6 @@ It fixes some source files to add missing `#include`s.
     cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -Dxrpld=ON -Dtests=ON ..
     ```
 
-
     Multi-config generators:
 
     ```
@@ -282,13 +400,13 @@ It fixes some source files to add missing `#include`s.
 5. Build `rippled`.
 
    For a single-configuration generator, it will build whatever configuration
-   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator,
-   you must pass the option `--config` to select the build configuration. 
+   you passed for `CMAKE_BUILD_TYPE`. For a multi-configuration generator, you
+   must pass the option `--config` to select the build configuration.
 
    Single-config generators:
 
    ```
-   cmake --build . -j $(nproc)
+   cmake --build .
    ```
 
    Multi-config generators:
@@ -303,18 +421,22 @@ It fixes some source files to add missing `#include`s.
    Single-config generators:
 
    ```
-   ./rippled --unittest
+   ./rippled --unittest --unittest-jobs N
    ```
 
    Multi-config generators:
 
    ```
-   ./Release/rippled --unittest
-   ./Debug/rippled --unittest
+   ./Release/rippled --unittest --unittest-jobs N
+   ./Debug/rippled --unittest --unittest-jobs N
    ```
 
-   The location of `rippled` in your build directory depends on your CMake
-   generator. Pass `--help` to see the rest of the command line options.
+   Replace the `--unittest-jobs` parameter N with the desired unit tests
+   concurrency. Recommended setting is half of the number of available CPU
+   cores.
+
+   The location of `rippled` binary in your build directory depends on your
+   CMake generator. Pass `--help` to see the rest of the command line options.
 
 
 ## Coverage report
@@ -372,7 +494,7 @@ cmake --build . --target coverage
 After the `coverage` target is completed, the generated coverage report will be
 stored inside the build directory, as either of:
 
-- file named `coverage.`_extension_ , with a suitable extension for the report format, or
+- file named `coverage.`_extension_, with a suitable extension for the report format, or
 - directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
 
 
@@ -380,12 +502,14 @@ stored inside the build directory, as either of:
 
 | Option | Default Value | Description |
 | --- | ---| ---|
-| `assert` | OFF | Enable assertions.
+| `assert` | OFF | Enable assertions. |
 | `coverage` | OFF | Prepare the coverage report. |
 | `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
 | `tests` | OFF | Build tests. |
-| `unity` | ON | Configure a unity build. |
+| `unity` | OFF | Configure a unity build. |
 | `xrpld` | OFF | Build the xrpld (`rippled`) application, and not just the libxrpl library. |
+| `werr` | OFF | Treat compilation warnings as errors |
+| `wextra` | OFF | Enable additional compilation warnings |
 
 [Unity builds][5] may be faster for the first build
 (at the cost of much more memory) since they concatenate sources into fewer
@@ -395,22 +519,33 @@ and can be helpful for detecting `#include` omissions.
 
 ## Troubleshooting
 
-
 ### Conan
 
 After any updates or changes to dependencies, you may need to do the following:
 
 1. Remove your build directory.
-2. Remove the Conan cache:
+2. Remove individual libraries from the Conan cache, e.g.
+
+   ```bash
+   conan remove 'grpc/*'
    ```
-   rm -rf ~/.conan/data
+
+   **or**
+
+   Remove all libraries from Conan cache:
+
+   ```bash
+   conan remove '*'
    ```
+
+3. Re-run [conan export](#patched-recipes) if needed.
 4. Re-run [conan install](#build-and-test).
 
+### `protobuf/port_def.inc` file not found
 
-### 'protobuf/port_def.inc' file not found
-
-If `cmake --build .` results in an error due to a missing a protobuf file, then you might have generated CMake files for a different `build_type` than the `CMAKE_BUILD_TYPE` you passed to conan.
+If `cmake --build .` results in an error due to a missing a protobuf file, then
+you might have generated CMake files for a different `build_type` than the
+`CMAKE_BUILD_TYPE` you passed to Conan.
 
 ```
 /rippled/.build/pb-xrpl.libpb/xrpl/proto/ripple.pb.h:10:10: fatal error: 'google/protobuf/port_def.inc' file not found
@@ -424,54 +559,6 @@ For example, if you want to build Debug:
 1. For conan install, pass `--settings build_type=Debug`
 2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
 
-
-### no std::result_of
-
-If your compiler version is recent enough to have removed `std::result_of` as
-part of C++20, e.g. Apple Clang 15.0, then you might need to add a preprocessor
-definition to your build.
-
-```
-conan profile update 'options.boost:extra_b2_flags="define=BOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'env.CFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"' default
-conan profile update 'conf.tools.build:cflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_HAS_STD_INVOKE_RESULT"]' default
-```
-
-
-### call to 'async_teardown' is ambiguous
-
-If you are compiling with an early version of Clang 16, then you might hit
-a [regression][6] when compiling C++20 that manifests as an [error in a Boost
-header][7]. You can workaround it by adding this preprocessor definition:
-
-```
-conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
-```
-
-
-### recompile with -fPIC
-
-If you get a linker error suggesting that you recompile Boost with
-position-independent code, such as:
-
-```
-/usr/bin/ld.gold: error: /home/username/.conan/data/boost/1.77.0/_/_/package/.../lib/libboost_container.a(alloc_lib.o):
-  requires unsupported dynamic reloc 11; recompile with -fPIC
-```
-
-Conan most likely downloaded a bad binary distribution of the dependency.
-This seems to be a [bug][1] in Conan just for Boost 1.77.0 compiled with GCC
-for Linux. The solution is to build the dependency locally by passing
-`--build boost` when calling `conan install`.
-
-```
-conan install --build boost ...
-```
-
-
 ## Add a Dependency
 
 If you want to experiment with a new package, follow these steps:

Builds/levelization/results/ordering.txt

@@ -132,6 +132,7 @@ test.shamap > xrpl.protocol
 test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
+tests.libxrpl > xrpl.basics
 xrpl.json > xrpl.basics
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json

CMakeLists.txt

@@ -90,11 +90,15 @@ set_target_properties(OpenSSL::SSL PROPERTIES
   INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
 )
 set(SECP256K1_INSTALL TRUE)
+set(SECP256K1_BUILD_BENCHMARK FALSE)
+set(SECP256K1_BUILD_TESTS FALSE)
+set(SECP256K1_BUILD_EXHAUSTIVE_TESTS FALSE)
+set(SECP256K1_BUILD_CTIME_TESTS FALSE)
+set(SECP256K1_BUILD_EXAMPLES FALSE)
 add_subdirectory(external/secp256k1)
 add_library(secp256k1::secp256k1 ALIAS secp256k1)
 add_subdirectory(external/ed25519-donna)
 add_subdirectory(external/antithesis-sdk)
-add_subdirectory(external/blake3)
 find_package(gRPC REQUIRED)
 find_package(lz4 REQUIRED)
 # Target names with :: are not allowed in a generator expression.
@@ -125,7 +129,6 @@ target_link_libraries(ripple_libs INTERFACE
   secp256k1::secp256k1
   soci::soci
   SQLite::SQLite3
-  blake3
 )
 
 # Work around changes to Conan recipe for now.
@@ -146,3 +149,8 @@ set(PROJECT_EXPORT_SET RippleExports)
 include(RippledCore)
 include(RippledInstall)
 include(RippledValidatorKeys)
+
+if(tests)
+  include(CTest)
+  add_subdirectory(src/tests/libxrpl)
+endif()

cmake/RippledCompiler.cmake

@@ -90,28 +90,15 @@ if (MSVC)
       -errorreport:none
       -machine:X64)
 else ()
-  # HACK : because these need to come first, before any warning demotion
-  string (APPEND CMAKE_CXX_FLAGS " -Wall -Wdeprecated")
-  if (wextra)
-    string (APPEND CMAKE_CXX_FLAGS " -Wextra -Wno-unused-parameter")
-  endif ()
-  # not MSVC
   target_compile_options (common
     INTERFACE
+      -Wall
+      -Wdeprecated
+      $<$<BOOL:${wextra}>:-Wextra -Wno-unused-parameter>
       $<$<BOOL:${werr}>:-Werror>
-      $<$<COMPILE_LANGUAGE:CXX>:
-        -frtti
-        -Wnon-virtual-dtor
-      >
-      -Wno-sign-compare
-      -Wno-char-subscripts
-      -Wno-format
-      -Wno-unused-local-typedefs
       -fstack-protector
-      $<$<BOOL:${is_gcc}>:
-        -Wno-unused-but-set-variable
-        -Wno-deprecated
-      >
+      -Wno-sign-compare
+      -Wno-unused-but-set-variable
       $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
       # tweak gcc optimization for debug
       $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>

cmake/RippledCore.cmake

@@ -64,7 +64,6 @@ target_link_libraries(xrpl.imports.main
     secp256k1::secp256k1
     xrpl.libpb
     xxHash::xxhash
-    blake3
     $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
 )
 

cmake/RippledSettings.cmake

@@ -18,7 +18,7 @@ if(tests)
   endif()
 endif()
 
-option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
+option(unity "Creates a build using UNITY support in cmake." OFF)
 if(unity)
   if(NOT is_ci)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")

cmake/deps/Boost.cmake

@@ -2,7 +2,6 @@ find_package(Boost 1.82 REQUIRED
   COMPONENTS
     chrono
     container
-    context
     coroutine
     date_time
     filesystem
@@ -24,7 +23,7 @@ endif()
 
 target_link_libraries(ripple_boost
   INTERFACE
-    Boost::boost
+    Boost::headers
     Boost::chrono
     Boost::container
     Boost::coroutine

cmake/xrpl_add_test.cmake

@@ -0,0 +1,41 @@
+include(isolate_headers)
+
+function(xrpl_add_test name)
+  set(target ${PROJECT_NAME}.test.${name})
+
+  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+  "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+  )
+  add_executable(${target} EXCLUDE_FROM_ALL ${ARGN} ${sources})
+
+  isolate_headers(
+    ${target}
+    "${CMAKE_SOURCE_DIR}"
+    "${CMAKE_SOURCE_DIR}/tests/${name}"
+    PRIVATE
+  )
+
+  # Make sure the test isn't optimized away in unity builds
+  set_target_properties(${target} PROPERTIES
+    UNITY_BUILD_MODE GROUP
+    UNITY_BUILD_BATCH_SIZE 0)  # Adjust as needed
+
+  add_test(NAME ${target} COMMAND ${target})
+  set_tests_properties(
+    ${target} PROPERTIES
+    FIXTURES_REQUIRED ${target}_fixture
+  )
+
+  add_test(
+    NAME ${target}.build
+    COMMAND
+      ${CMAKE_COMMAND}
+      --build ${CMAKE_BINARY_DIR}
+      --config $<CONFIG>
+      --target ${target}
+  )
+  set_tests_properties(${target}.build PROPERTIES
+    FIXTURES_SETUP ${target}_fixture
+  )
+endfunction()

conan/profiles/default

@@ -0,0 +1,34 @@
+{% set os = detect_api.detect_os() %}
+{% set arch = detect_api.detect_arch() %}
+{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
+{% set compiler_version = version %}
+{% if os == "Linux" %}
+{% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
+{% endif %}
+
+[settings]
+os={{ os }}
+arch={{ arch }}
+build_type=Debug
+compiler={{compiler}}
+compiler.version={{ compiler_version }}
+compiler.cppstd=20
+{% if os == "Windows" %}
+compiler.runtime=static
+{% else %}
+compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
+{% endif %}
+
+[conf]
+{% if compiler == "clang" and compiler_version >= 19 %}
+tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
+{% endif %}
+{% if compiler == "apple-clang" and compiler_version >= 17 %}
+tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
+{% endif %}
+{% if compiler == "gcc" and compiler_version < 13 %}
+tools.build:cxxflags=['-Wno-restrict']
+{% endif %}
+
+[tool_requires]
+!cmake/*: cmake/[>=3 <4]

conanfile.py

@@ -25,15 +25,19 @@ class Xrpl(ConanFile):
 
     requires = [
         'grpc/1.50.1',
-        'libarchive/3.7.6',
-        'nudb/2.0.8',
-        'openssl/1.1.1v',
+        'libarchive/3.8.1',
+        'nudb/2.0.9',
+        'openssl/1.1.1w',
         'soci/4.0.3',
         'zlib/1.3.1',
     ]
 
+    test_requires = [
+        'doctest/2.4.11',
+    ]
+
     tool_requires = [
-        'protobuf/3.21.9',
+        'protobuf/3.21.12',
     ]
 
     default_options = {
@@ -85,12 +89,13 @@ class Xrpl(ConanFile):
     }
 
     def set_version(self):
-        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
-        regex = r'versionString\s?=\s?\"(.*)\"'
-        with open(path, 'r') as file:
-            matches = (re.search(regex, line) for line in file)
-            match = next(m for m in matches if m)
-            self.version = match.group(1)
+        if self.version is None:
+            path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+            regex = r'versionString\s?=\s?\"(.*)\"'
+            with open(path, encoding='utf-8') as file:
+                matches = (re.search(regex, line) for line in file)
+                match = next(m for m in matches if m)
+                self.version = match.group(1)
 
     def configure(self):
         if self.settings.compiler == 'apple-clang':
@@ -99,16 +104,16 @@ class Xrpl(ConanFile):
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
         transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
-        self.requires('boost/1.83.0', force=True, **transitive_headers_opt)
-        self.requires('date/3.0.3', **transitive_headers_opt)
+        self.requires('boost/1.86.0', force=True, **transitive_headers_opt)
+        self.requires('date/3.0.4', **transitive_headers_opt)
         self.requires('lz4/1.10.0', force=True)
-        self.requires('protobuf/3.21.9', force=True)
-        self.requires('sqlite3/3.47.0', force=True)
+        self.requires('protobuf/3.21.12', force=True)
+        self.requires('sqlite3/3.49.1', force=True)
         if self.options.jemalloc:
             self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/9.7.3')
-        self.requires('xxhash/0.8.2', **transitive_headers_opt)
+            self.requires('rocksdb/10.0.1')
+        self.requires('xxhash/0.8.3', **transitive_headers_opt)
 
     exports_sources = (
         'CMakeLists.txt',
@@ -163,7 +168,17 @@ class Xrpl(ConanFile):
         # `include/`, not `include/ripple/proto/`.
         libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            'boost::boost',
+            'boost::headers',
+            'boost::chrono',
+            'boost::container',
+            'boost::coroutine',
+            'boost::date_time',
+            'boost::filesystem',
+            'boost::json',
+            'boost::program_options',
+            'boost::regex',
+            'boost::system',
+            'boost::thread',
             'date::date',
             'grpc::grpc++',
             'libarchive::libarchive',

docs/build/environment.md

@@ -10,37 +10,35 @@ platforms: Linux, macOS, or Windows.
 
 Package ecosystems vary across Linux distributions,
 so there is no one set of instructions that will work for every Linux user.
-These instructions are written for Ubuntu 22.04.
-They are largely copied from the [script][1] used to configure our Docker
-container for continuous integration.
-That script handles many more responsibilities.
-These instructions are just the bare minimum to build one configuration of
-rippled.
-You can check that codebase for other Linux distributions and versions.
-If you cannot find yours there,
-then we hope that these instructions can at least guide you in the right
-direction.
+The instructions below are written for Debian 12 (Bookworm).
 
 ```
-apt update
-apt install --yes curl git libssl-dev pipx python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+export GCC_RELEASE=12
+sudo apt update
+sudo apt install --yes gcc-${GCC_RELEASE} g++-${GCC_RELEASE} python3-pip \
+  python-is-python3 python3-venv python3-dev curl wget ca-certificates \
+  git build-essential cmake ninja-build libc6-dev
+sudo pip install --break-system-packages conan
 
-curl --location --remote-name \
-  "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
-tar -xzf cmake-3.25.1.tar.gz
-rm cmake-3.25.1.tar.gz
-cd cmake-3.25.1
-./bootstrap --parallel=$(nproc)
-make --jobs $(nproc)
-make install
-cd ..
-
-pipx install 'conan<2'
-pipx ensurepath
+sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc-${GCC_RELEASE} 999
+sudo update-alternatives --install \
+  /usr/bin/gcc gcc /usr/bin/gcc-${GCC_RELEASE} 100 \
+  --slave /usr/bin/g++ g++ /usr/bin/g++-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-${GCC_RELEASE} \
+  --slave /usr/bin/gcov gcov /usr/bin/gcov-${GCC_RELEASE} \
+  --slave /usr/bin/gcov-tool gcov-tool /usr/bin/gcov-tool-${GCC_RELEASE} \
+  --slave /usr/bin/gcov-dump gcov-dump /usr/bin/gcov-dump-${GCC_RELEASE} \
+  --slave /usr/bin/lto-dump lto-dump /usr/bin/lto-dump-${GCC_RELEASE}
+sudo update-alternatives --auto cc
+sudo update-alternatives --auto gcc
 ```
 
-[1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh
-
+If you use different Linux distribution, hope the instruction above can guide
+you in the right direction. We try to maintain compatibility with all recent
+compiler releases, so if you use a rolling distribution like e.g. Arch or CentOS
+then there is a chance that everything will "just work".
 
 ## macOS
 
@@ -53,6 +51,34 @@ minimum required (see [BUILD.md][]).
 clang --version
 ```
 
+### Install Xcode Specific Version (Optional)
+
+If you develop other applications using XCode you might be consistently updating to the newest version of Apple Clang. 
+This will likely cause issues building rippled. You may want to install a specific version of Xcode:
+
+1. **Download Xcode**
+
+   - Visit [Apple Developer Downloads](https://developer.apple.com/download/more/)
+   - Sign in with your Apple Developer account
+   - Search for an Xcode version that includes **Apple Clang (Expected Version)**
+   - Download the `.xip` file
+
+2. **Install and Configure Xcode**
+
+   ```bash
+   # Extract the .xip file and rename for version management
+   # Example: Xcode_16.2.app
+
+   # Move to Applications directory
+   sudo mv Xcode_16.2.app /Applications/
+
+   # Set as default toolchain (persistent)
+   sudo xcode-select -s /Applications/Xcode_16.2.app/Contents/Developer
+
+   # Set as environment variable (temporary)
+   export DEVELOPER_DIR=/Applications/Xcode_16.2.app/Contents/Developer
+   ```
+
 The command line developer tools should include Git too:
 
 ```
@@ -72,10 +98,10 @@ and use it to install Conan:
 brew update
 brew install xz
 brew install pyenv
-pyenv install 3.10-dev
-pyenv global 3.10-dev
+pyenv install 3.11
+pyenv global 3.11
 eval "$(pyenv init -)"
-pip install 'conan<2'
+pip install 'conan'
 ```
 
 Install CMake with Homebrew too:

external/README.md

@@ -1,14 +1,10 @@
 # External Conan recipes
 
-The subdirectories in this directory contain either copies or Conan recipes
-of external libraries used by rippled.
-The Conan recipes include patches we have not yet pushed upstream.
+The subdirectories in this directory contain copies of external libraries used
+by rippled.
 
 | Folder          | Upstream                                     | Description |
 |:----------------|:---------------------------------------------|:------------|
 | `antithesis-sdk`| [Project](https://github.com/antithesishq/antithesis-sdk-cpp/) | [Antithesis](https://antithesis.com/docs/using_antithesis/sdk/cpp/overview.html) SDK for C++ |
 | `ed25519-donna` | [Project](https://github.com/floodyberry/ed25519-donna) | [Ed25519](http://ed25519.cr.yp.to/) digital signatures |
-| `rocksdb`       | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/rocksdb) | Fast key/value database. (Supports rotational disks better than NuDB.) |
 | `secp256k1`     | [Project](https://github.com/bitcoin-core/secp256k1)    | ECDSA digital signatures using the **secp256k1** curve |
-| `snappy`        | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/snappy)  | "Snappy" lossless compression algorithm. |
-| `soci`          | [Recipe](https://github.com/conan-io/conan-center-index/tree/master/recipes/soci)    | Abstraction layer for database access. |

external/antithesis-sdk/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.25)
+cmake_minimum_required(VERSION 3.18)
 
 # Note, version set explicitly by rippled project
 project(antithesis-sdk-cpp VERSION 0.4.4 LANGUAGES CXX)

external/blake3/CMakeLists.txt

@@ -1,383 +0,0 @@
-cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
-
-# respect C_EXTENSIONS OFF without explicitly setting C_STANDARD
-if (POLICY CMP0128)
-  cmake_policy(SET CMP0128 NEW)
-endif()
-# mark_as_advanced does not implicitly create UNINITIALIZED cache entries
-if (POLICY CMP0102)
-  cmake_policy(SET CMP0102 NEW)
-endif()
-
-project(libblake3
-  VERSION 1.8.2
-  DESCRIPTION "BLAKE3 C implementation"
-  LANGUAGES C CXX ASM
-)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-option(BLAKE3_USE_TBB "Enable oneTBB parallelism" OFF)
-option(BLAKE3_FETCH_TBB "Allow fetching oneTBB from GitHub if not found on system" OFF)
-
-include(CTest)
-include(FeatureSummary)
-include(GNUInstallDirs)
-
-add_subdirectory(dependencies)
-
-# architecture lists for which to enable assembly / SIMD sources
-set(BLAKE3_AMD64_NAMES amd64 AMD64 x86_64)
-set(BLAKE3_X86_NAMES i686 x86 X86)
-set(BLAKE3_ARMv8_NAMES aarch64 AArch64 arm64 ARM64 armv8 armv8a)
-# default SIMD compiler flag configuration (can be overriden by toolchains or CLI)
-if(MSVC)
-  set(BLAKE3_CFLAGS_SSE2 "/arch:SSE2" CACHE STRING "the compiler flags to enable SSE2")
-  # MSVC has no dedicated sse4.1 flag (see https://learn.microsoft.com/en-us/cpp/build/reference/arch-x86?view=msvc-170)
-  set(BLAKE3_CFLAGS_SSE4.1 "/arch:AVX" CACHE STRING "the compiler flags to enable SSE4.1")
-  set(BLAKE3_CFLAGS_AVX2 "/arch:AVX2" CACHE STRING "the compiler flags to enable AVX2")
-  set(BLAKE3_CFLAGS_AVX512 "/arch:AVX512" CACHE STRING "the compiler flags to enable AVX512")
-
-  set(BLAKE3_AMD64_ASM_SOURCES
-    blake3_avx2_x86-64_windows_msvc.asm
-    blake3_avx512_x86-64_windows_msvc.asm
-    blake3_sse2_x86-64_windows_msvc.asm
-    blake3_sse41_x86-64_windows_msvc.asm
-  )
-
-elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU"
-       OR CMAKE_C_COMPILER_ID STREQUAL "Clang"
-       OR CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
-  set(BLAKE3_CFLAGS_SSE2 "-msse2" CACHE STRING "the compiler flags to enable SSE2")
-  set(BLAKE3_CFLAGS_SSE4.1 "-msse4.1" CACHE STRING "the compiler flags to enable SSE4.1")
-  set(BLAKE3_CFLAGS_AVX2 "-mavx2" CACHE STRING "the compiler flags to enable AVX2")
-  set(BLAKE3_CFLAGS_AVX512 "-mavx512f -mavx512vl" CACHE STRING "the compiler flags to enable AVX512")
-
-  if (WIN32 OR CYGWIN)
-    set(BLAKE3_AMD64_ASM_SOURCES
-      blake3_avx2_x86-64_windows_gnu.S
-      blake3_avx512_x86-64_windows_gnu.S
-      blake3_sse2_x86-64_windows_gnu.S
-      blake3_sse41_x86-64_windows_gnu.S
-    )
-
-  elseif(UNIX)
-    set(BLAKE3_AMD64_ASM_SOURCES
-      blake3_avx2_x86-64_unix.S
-      blake3_avx512_x86-64_unix.S
-      blake3_sse2_x86-64_unix.S
-      blake3_sse41_x86-64_unix.S
-    )
-  endif()
-
-  if (CMAKE_SYSTEM_PROCESSOR IN_LIST BLAKE3_ARMv8_NAMES
-      AND NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-    # 32-bit ARMv8 needs NEON to be enabled explicitly
-    set(BLAKE3_CFLAGS_NEON "-mfpu=neon" CACHE STRING "the compiler flags to enable NEON")
-  endif()
-endif()
-
-mark_as_advanced(BLAKE3_CFLAGS_SSE2 BLAKE3_CFLAGS_SSE4.1 BLAKE3_CFLAGS_AVX2 BLAKE3_CFLAGS_AVX512 BLAKE3_CFLAGS_NEON)
-mark_as_advanced(BLAKE3_AMD64_ASM_SOURCES)
-
-message(STATUS "BLAKE3 SIMD configuration: ${CMAKE_C_COMPILER_ARCHITECTURE_ID}")
-if(MSVC AND DEFINED CMAKE_C_COMPILER_ARCHITECTURE_ID)
-  if(CMAKE_C_COMPILER_ARCHITECTURE_ID MATCHES "[Xx]86")
-    set(BLAKE3_SIMD_TYPE "x86-intrinsics" CACHE STRING "the SIMD acceleration type to use")
-
-  elseif(CMAKE_C_COMPILER_ARCHITECTURE_ID MATCHES "[Xx]64")
-    set(BLAKE3_SIMD_TYPE "amd64-asm" CACHE STRING "the SIMD acceleration type to use")
-
-  elseif(CMAKE_C_COMPILER_ARCHITECTURE_ID MATCHES "[Aa][Rr][Mm]64")
-    set(BLAKE3_SIMD_TYPE "neon-intrinsics" CACHE STRING "the SIMD acceleration type to use")
-
-  else()
-    set(BLAKE3_SIMD_TYPE "none" CACHE STRING "the SIMD acceleration type to use")
-  endif()
-
-elseif(CMAKE_SYSTEM_PROCESSOR IN_LIST BLAKE3_AMD64_NAMES)
-  set(BLAKE3_SIMD_TYPE "amd64-asm" CACHE STRING "the SIMD acceleration type to use")
-
-elseif(CMAKE_SYSTEM_PROCESSOR IN_LIST BLAKE3_X86_NAMES
-       AND DEFINED BLAKE3_CFLAGS_SSE2
-       AND DEFINED BLAKE3_CFLAGS_SSE4.1
-       AND DEFINED BLAKE3_CFLAGS_AVX2
-       AND DEFINED BLAKE3_CFLAGS_AVX512)
-  set(BLAKE3_SIMD_TYPE "x86-intrinsics" CACHE STRING "the SIMD acceleration type to use")
-
-elseif((CMAKE_SYSTEM_PROCESSOR IN_LIST BLAKE3_ARMv8_NAMES
-          OR ANDROID_ABI STREQUAL "armeabi-v7a"
-          OR BLAKE3_USE_NEON_INTRINSICS)
-        AND (DEFINED BLAKE3_CFLAGS_NEON
-          OR CMAKE_SIZEOF_VOID_P EQUAL 8))
-  set(BLAKE3_SIMD_TYPE "neon-intrinsics" CACHE STRING "the SIMD acceleration type to use")
-
-else()
-  set(BLAKE3_SIMD_TYPE "none" CACHE STRING "the SIMD acceleration type to use")
-endif()
-
-mark_as_advanced(BLAKE3_SIMD_TYPE)
-
-# library target
-add_library(blake3
-  blake3.c
-  blake3_dispatch.c
-  blake3_portable.c
-)
-add_library(BLAKE3::blake3 ALIAS blake3)
-
-# library configuration
-set(PKG_CONFIG_CFLAGS)
-if (BUILD_SHARED_LIBS)
-  target_compile_definitions(blake3
-    PUBLIC BLAKE3_DLL
-    PRIVATE BLAKE3_DLL_EXPORTS
-  )
-  list(APPEND PKG_CONFIG_CFLAGS -DBLAKE3_DLL)
-endif()
-target_include_directories(blake3 PUBLIC
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-set_target_properties(blake3 PROPERTIES
-  VERSION ${PROJECT_VERSION}
-  SOVERSION 0
-  C_VISIBILITY_PRESET hidden
-  C_EXTENSIONS OFF
-)
-target_compile_features(blake3 PUBLIC c_std_99)
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12)
-  target_compile_features(blake3 PUBLIC cxx_std_20)
-  # else: add it further below through `BLAKE3_CMAKE_CXXFLAGS_*`
-endif()
-
-# ensure C_EXTENSIONS OFF is respected without overriding CMAKE_C_STANDARD
-# which may be set by the user or toolchain file
-if (NOT POLICY CMP0128 AND NOT DEFINED CMAKE_C_STANDARD)
-  set_target_properties(blake3 PROPERTIES C_STANDARD 99)
-endif()
-
-# optional SIMD sources
-if(BLAKE3_SIMD_TYPE STREQUAL "amd64-asm")
-  if (NOT DEFINED BLAKE3_AMD64_ASM_SOURCES)
-    message(FATAL_ERROR "BLAKE3_SIMD_TYPE is set to 'amd64-asm' but no assembly sources are available for the target architecture.")
-  endif()
-  set(BLAKE3_SIMD_AMD64_ASM ON)
-
-  if(MSVC)
-    enable_language(ASM_MASM)
-  endif()
-
-  target_sources(blake3 PRIVATE ${BLAKE3_AMD64_ASM_SOURCES})
-
-elseif(BLAKE3_SIMD_TYPE STREQUAL "x86-intrinsics")
-  if (NOT DEFINED BLAKE3_CFLAGS_SSE2
-      OR NOT DEFINED BLAKE3_CFLAGS_SSE4.1
-      OR NOT DEFINED BLAKE3_CFLAGS_AVX2
-      OR NOT DEFINED BLAKE3_CFLAGS_AVX512)
-    message(FATAL_ERROR "BLAKE3_SIMD_TYPE is set to 'x86-intrinsics' but no compiler flags are available for the target architecture.")
-  endif()
-  set(BLAKE3_SIMD_X86_INTRINSICS ON)
-
-  target_sources(blake3 PRIVATE
-    blake3_avx2.c
-    blake3_avx512.c
-    blake3_sse2.c
-    blake3_sse41.c
-  )
-  set_source_files_properties(blake3_avx2.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_AVX2}")
-  set_source_files_properties(blake3_avx512.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_AVX512}")
-  set_source_files_properties(blake3_sse2.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_SSE2}")
-  set_source_files_properties(blake3_sse41.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_SSE4.1}")
-
-elseif(BLAKE3_SIMD_TYPE STREQUAL "neon-intrinsics")
-  set(BLAKE3_SIMD_NEON_INTRINSICS ON)
-
-  target_sources(blake3 PRIVATE
-    blake3_neon.c
-  )
-  target_compile_definitions(blake3 PRIVATE
-    BLAKE3_USE_NEON=1
-  )
-
-  if (DEFINED BLAKE3_CFLAGS_NEON)
-    set_source_files_properties(blake3_neon.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_NEON}")
-  endif()
-
-elseif(BLAKE3_SIMD_TYPE STREQUAL "none")
-  target_compile_definitions(blake3 PRIVATE
-    BLAKE3_USE_NEON=0
-    BLAKE3_NO_SSE2
-    BLAKE3_NO_SSE41
-    BLAKE3_NO_AVX2
-    BLAKE3_NO_AVX512
-  )
-
-else()
-  message(FATAL_ERROR "BLAKE3_SIMD_TYPE is set to an unknown value: '${BLAKE3_SIMD_TYPE}'")
-endif()
-
-if(BLAKE3_USE_TBB)
-  find_package(TBB 2021.11.0 QUIET)
-  if(NOT TBB_FOUND AND NOT TARGET TBB::tbb)
-    message(WARNING
-      "oneTBB not found; disabling BLAKE3_USE_TBB\n"
-      "Enable BLAKE3_FETCH_TBB to automatically fetch and build oneTBB"
-    )
-    set(BLAKE3_USE_TBB OFF)
-  else()
-    target_sources(blake3
-      PRIVATE
-        blake3_tbb.cpp)
-    target_link_libraries(blake3
-      PUBLIC
-        # Make shared TBB a transitive dependency. The consuming program is technically not required
-        # to link TBB in order for libblake3 to function but we do this in order to prevent the
-        # possibility of multiple separate TBB runtimes being linked into a final program in case
-        # the consuming program also happens to already use TBB.
-        TBB::tbb)
-    target_compile_definitions(blake3
-      PUBLIC
-        BLAKE3_USE_TBB)
-  endif()
-  list(APPEND PKG_CONFIG_REQUIRES "tbb >= ${TBB_VERSION}")
-  list(APPEND PKG_CONFIG_CFLAGS -DBLAKE3_USE_TBB)
-  include(CheckCXXSymbolExists)
-  check_cxx_symbol_exists(_LIBCPP_VERSION "version" BLAKE3_HAVE_LIBCPP)
-  check_cxx_symbol_exists(__GLIBCXX__ "version" BLAKE3_HAVE_GLIBCXX)
-  if(BLAKE3_HAVE_GLIBCXX)
-    list(APPEND PKG_CONFIG_LIBS -lstdc++)
-  elseif(BLAKE3_HAVE_LIBCPP)
-    list(APPEND PKG_CONFIG_LIBS -lc++)
-  endif()
-endif()
-
-if(BLAKE3_USE_TBB)
-  # Define some scratch variables for building appropriate flags per compiler
-  if(CMAKE_VERSION VERSION_LESS 3.12)
-    set(APPEND BLAKE3_CXX_STANDARD_FLAGS_GNU -std=c++20)
-    set(APPEND BLAKE3_CXX_STANDARD_FLAGS_MSVC /std:c++20)
-  endif()
-  set(BLAKE3_CXXFLAGS_GNU "-fno-exceptions;-fno-rtti;${BLAKE3_CXX_STANDARD_FLAGS_GNU}" CACHE STRING "C++ flags used for compiling private BLAKE3 library components with GNU-like compiler frontends.")
-  set(BLAKE3_CXXFLAGS_MSVC "/EHs-c-;/GR-;${BLAKE3_CXX_STANDARD_FLAGS_MSVC}" CACHE STRING "C++ flags used for compiling private BLAKE3 library components with MSVC-like compiler frontends.")
-  # Get the C++ compiler name without extension
-  get_filename_component(BLAKE3_CMAKE_CXX_COMPILER_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
-  # Strip any trailing versioning from the C++ compiler name
-  string(REGEX MATCH "^(clang\\+\\+|clang-cl)" BLAKE3_CMAKE_CXX_COMPILER_NAME "${BLAKE3_CMAKE_CXX_COMPILER_NAME}")
-
-  # TODO: Simplify with CMAKE_CXX_COMPILER_FRONTEND_VARIANT once min CMake version is 3.14.
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-    target_compile_options(blake3 PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${BLAKE3_CXXFLAGS_GNU}>)
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    if(BLAKE3_CMAKE_CXX_COMPILER_NAME STREQUAL "clang++")
-      target_compile_options(blake3 PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${BLAKE3_CXXFLAGS_GNU}>)
-    elseif(BLAKE3_CMAKE_CXX_COMPILER_NAME STREQUAL "clang-cl")
-      target_compile_options(blake3 PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${BLAKE3_CXXFLAGS_MSVC}>)
-    endif()
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    target_compile_options(blake3 PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${BLAKE3_CXXFLAGS_GNU}>)
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    target_compile_options(blake3 PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${BLAKE3_CXXFLAGS_MSVC}>)
-  endif()
-
-  # Undefine scratch variables
-  unset(BLAKE3_CXX_STANDARD_FLAGS_GNU)
-  unset(BLAKE3_CXX_STANDARD_FLAGS_MSVC)
-  unset(BLAKE3_CMAKE_CXX_COMPILER_NAME)
-  unset(BLAKE3_CXXFLAGS_GNU)
-  unset(BLAKE3_CXXFLAGS_MSVC)
-endif()
-
-# cmake install support
-install(FILES blake3.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-install(TARGETS blake3 EXPORT blake3-targets
-  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-)
-install(EXPORT blake3-targets
-  NAMESPACE BLAKE3::
-  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/blake3"
-)
-
-include(CMakePackageConfigHelpers)
-configure_package_config_file(blake3-config.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/blake3-config.cmake"
-
-    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/blake3"
-)
-write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/blake3-config-version.cmake"
-    VERSION ${libblake3_VERSION}
-    COMPATIBILITY SameMajorVersion
-)
-install(FILES
-        "${CMAKE_CURRENT_BINARY_DIR}/blake3-config.cmake"
-        "${CMAKE_CURRENT_BINARY_DIR}/blake3-config-version.cmake"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/blake3"
-)
-
-# Function for joining paths known from most languages
-#
-# SPDX-License-Identifier: (MIT OR CC0-1.0)
-# Copyright 2020 Jan Tojnar
-# https://github.com/jtojnar/cmake-snips
-#
-# Modelled after Python’s os.path.join
-# https://docs.python.org/3.7/library/os.path.html#os.path.join
-# Windows not supported
-function(join_paths joined_path first_path_segment)
-    set(temp_path "${first_path_segment}")
-    foreach(current_segment IN LISTS ARGN)
-        if(NOT ("${current_segment}" STREQUAL ""))
-            if(IS_ABSOLUTE "${current_segment}")
-                set(temp_path "${current_segment}")
-            else()
-                set(temp_path "${temp_path}/${current_segment}")
-            endif()
-        endif()
-    endforeach()
-    set(${joined_path} "${temp_path}" PARENT_SCOPE)
-endfunction()
-
-# In-place rewrite a string and and join by `sep`.
-#
-# TODO: Replace function with list(JOIN) when updating to CMake 3.12
-function(join_pkg_config_field sep requires)
-  set(_requires "${${requires}}") # avoid shadowing issues, e.g. "${requires}"=len
-  list(LENGTH "${requires}" len)
-  set(idx 1)
-  foreach(req IN LISTS _requires)
-    string(APPEND acc "${req}")
-    if(idx LESS len)
-      string(APPEND acc "${sep}")
-    endif()
-    math(EXPR idx "${idx} + 1")
-  endforeach()
-  set("${requires}" "${acc}" PARENT_SCOPE)
-endfunction()
-
-# pkg-config support
-join_pkg_config_field(", " PKG_CONFIG_REQUIRES)
-join_pkg_config_field(" " PKG_CONFIG_LIBS)
-join_pkg_config_field(" " PKG_CONFIG_CFLAGS)
-join_paths(PKG_CONFIG_INSTALL_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
-join_paths(PKG_CONFIG_INSTALL_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
-configure_file(libblake3.pc.in libblake3.pc @ONLY)
-install(FILES "${CMAKE_BINARY_DIR}/libblake3.pc"
-  DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-
-# print feature summary
-# add_feature_info cannot directly use the BLAKE3_SIMD_TYPE :(
-add_feature_info("AMD64 assembly" BLAKE3_SIMD_AMD64_ASM "The library uses hand written amd64 SIMD assembly.")
-add_feature_info("x86 SIMD intrinsics" BLAKE3_SIMD_X86_INTRINSICS "The library uses x86 SIMD intrinsics.")
-add_feature_info("NEON SIMD intrinsics" BLAKE3_SIMD_NEON_INTRINSICS "The library uses NEON SIMD intrinsics.")
-add_feature_info("oneTBB parallelism" BLAKE3_USE_TBB "The library uses oneTBB parallelism.")
-feature_summary(WHAT ENABLED_FEATURES)
-
-if(BLAKE3_EXAMPLES)
-  include(BLAKE3/Examples)
-endif()
-if(BLAKE3_TESTING)
-  include(BLAKE3/Testing)
-endif()

external/blake3/Makefile.testing

@@ -1,82 +0,0 @@
-# This Makefile is only for testing. C callers should follow the instructions
-# in ./README.md to incorporate these C files into their existing build.
-
-NAME=blake3
-CC=gcc
-CFLAGS=-O3 -Wall -Wextra -std=c11 -pedantic -fstack-protector-strong -D_FORTIFY_SOURCE=2 -fPIE -fvisibility=hidden
-LDFLAGS=-pie -Wl,-z,relro,-z,now
-TARGETS=
-ASM_TARGETS=
-EXTRAFLAGS=-Wa,--noexecstack
-
-ifdef BLAKE3_NO_SSE2
-EXTRAFLAGS += -DBLAKE3_NO_SSE2
-else
-TARGETS += blake3_sse2.o
-ASM_TARGETS += blake3_sse2_x86-64_unix.S
-endif
-
-ifdef BLAKE3_NO_SSE41
-EXTRAFLAGS += -DBLAKE3_NO_SSE41
-else
-TARGETS += blake3_sse41.o
-ASM_TARGETS += blake3_sse41_x86-64_unix.S
-endif
-
-ifdef BLAKE3_NO_AVX2
-EXTRAFLAGS += -DBLAKE3_NO_AVX2
-else
-TARGETS += blake3_avx2.o
-ASM_TARGETS += blake3_avx2_x86-64_unix.S
-endif
-
-ifdef BLAKE3_NO_AVX512
-EXTRAFLAGS += -DBLAKE3_NO_AVX512
-else
-TARGETS += blake3_avx512.o
-ASM_TARGETS += blake3_avx512_x86-64_unix.S
-endif
-
-ifdef BLAKE3_USE_NEON
-EXTRAFLAGS += -DBLAKE3_USE_NEON=1
-TARGETS += blake3_neon.o
-endif
-
-ifdef BLAKE3_NO_NEON
-EXTRAFLAGS += -DBLAKE3_USE_NEON=0
-endif
-
-all: blake3.c blake3_dispatch.c blake3_portable.c main.c $(TARGETS)
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) $^ -o $(NAME) $(LDFLAGS)
-
-blake3_sse2.o: blake3_sse2.c
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) -c $^ -o $@ -msse2
-
-blake3_sse41.o: blake3_sse41.c
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) -c $^ -o $@ -msse4.1
-
-blake3_avx2.o: blake3_avx2.c
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) -c $^ -o $@ -mavx2
-
-blake3_avx512.o: blake3_avx512.c
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) -c $^ -o $@ -mavx512f -mavx512vl
-
-blake3_neon.o: blake3_neon.c
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) -c $^ -o $@
-
-test: CFLAGS += -DBLAKE3_TESTING -fsanitize=address,undefined
-test: all
-	./test.py
-
-asm: blake3.c blake3_dispatch.c blake3_portable.c main.c $(ASM_TARGETS)
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) $^ -o $(NAME) $(LDFLAGS)
-
-test_asm: CFLAGS += -DBLAKE3_TESTING -fsanitize=address,undefined 
-test_asm: asm
-	./test.py
-
-example: example.c blake3.c blake3_dispatch.c blake3_portable.c $(ASM_TARGETS)
-	$(CC) $(CFLAGS) $(EXTRAFLAGS) $^ -o $@ $(LDFLAGS)
-
-clean: 
-	rm -f $(NAME) *.o

external/blake3/README.md

@@ -1,403 +0,0 @@
-The official C implementation of BLAKE3.
-
-# Example
-
-An example program that hashes bytes from standard input and prints the
-result:
-
-```c
-#include "blake3.h"
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int main(void) {
-  // Initialize the hasher.
-  blake3_hasher hasher;
-  blake3_hasher_init(&hasher);
-
-  // Read input bytes from stdin.
-  unsigned char buf[65536];
-  while (1) {
-    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf));
-    if (n > 0) {
-      blake3_hasher_update(&hasher, buf, n);
-    } else if (n == 0) {
-      break; // end of file
-    } else {
-      fprintf(stderr, "read failed: %s\n", strerror(errno));
-      return 1;
-    }
-  }
-
-  // Finalize the hash. BLAKE3_OUT_LEN is the default output length, 32 bytes.
-  uint8_t output[BLAKE3_OUT_LEN];
-  blake3_hasher_finalize(&hasher, output, BLAKE3_OUT_LEN);
-
-  // Print the hash as hexadecimal.
-  for (size_t i = 0; i < BLAKE3_OUT_LEN; i++) {
-    printf("%02x", output[i]);
-  }
-  printf("\n");
-  return 0;
-}
-```
-
-The code above is included in this directory as `example.c`. If you're
-on x86\_64 with a Unix-like OS, you can compile a working binary like
-this:
-
-```bash
-gcc -O3 -o example example.c blake3.c blake3_dispatch.c blake3_portable.c \
-    blake3_sse2_x86-64_unix.S blake3_sse41_x86-64_unix.S blake3_avx2_x86-64_unix.S \
-    blake3_avx512_x86-64_unix.S
-```
-
-# API
-
-## The Struct
-
-```c
-typedef struct {
-  // private fields
-} blake3_hasher;
-```
-
-An incremental BLAKE3 hashing state, which can accept any number of
-updates. This implementation doesn't allocate any heap memory, but
-`sizeof(blake3_hasher)` itself is relatively large, currently 1912 bytes
-on x86-64. This size can be reduced by restricting the maximum input
-length, as described in Section 5.4 of [the BLAKE3
-spec](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf),
-but this implementation doesn't currently support that strategy.
-
-## Common API Functions
-
-```c
-void blake3_hasher_init(
-  blake3_hasher *self);
-```
-
-Initialize a `blake3_hasher` in the default hashing mode.
-
----
-
-```c
-void blake3_hasher_update(
-  blake3_hasher *self,
-  const void *input,
-  size_t input_len);
-```
-
-Add input to the hasher. This can be called any number of times. This function
-is always single-threaded; for multithreading see `blake3_hasher_update_tbb`
-below.
-
-
----
-
-```c
-void blake3_hasher_finalize(
-  const blake3_hasher *self,
-  uint8_t *out,
-  size_t out_len);
-```
-
-Finalize the hasher and return an output of any length, given in bytes.
-This doesn't modify the hasher itself, and it's possible to finalize
-again after adding more input. The constant `BLAKE3_OUT_LEN` provides
-the default output length, 32 bytes, which is recommended for most
-callers. See the [Security Notes](#security-notes) below.
-
-## Less Common API Functions
-
-```c
-void blake3_hasher_init_keyed(
-  blake3_hasher *self,
-  const uint8_t key[BLAKE3_KEY_LEN]);
-```
-
-Initialize a `blake3_hasher` in the keyed hashing mode. The key must be
-exactly 32 bytes.
-
----
-
-```c
-void blake3_hasher_init_derive_key(
-  blake3_hasher *self,
-  const char *context);
-```
-
-Initialize a `blake3_hasher` in the key derivation mode. The context
-string is given as an initialization parameter, and afterwards input key
-material should be given with `blake3_hasher_update`. The context string
-is a null-terminated C string which should be **hardcoded, globally
-unique, and application-specific**. The context string should not
-include any dynamic input like salts, nonces, or identifiers read from a
-database at runtime. A good default format for the context string is
-`"[application] [commit timestamp] [purpose]"`, e.g., `"example.com
-2019-12-25 16:18:03 session tokens v1"`.
-
-This function is intended for application code written in C. For
-language bindings, see `blake3_hasher_init_derive_key_raw` below.
-
----
-
-```c
-void blake3_hasher_init_derive_key_raw(
-  blake3_hasher *self,
-  const void *context,
-  size_t context_len);
-```
-
-As `blake3_hasher_init_derive_key` above, except that the context string
-is given as a pointer to an array of arbitrary bytes with a provided
-length. This is intended for writing language bindings, where C string
-conversion would add unnecessary overhead and new error cases. Unicode
-strings should be encoded as UTF-8.
-
-Application code in C should prefer `blake3_hasher_init_derive_key`,
-which takes the context as a C string. If you need to use arbitrary
-bytes as a context string in application code, consider whether you're
-violating the requirement that context strings should be hardcoded.
-
----
-
-```c
-void blake3_hasher_update_tbb(
-  blake3_hasher *self,
-  const void *input,
-  size_t input_len);
-```
-
-Add input to the hasher, using [oneTBB] to process large inputs using multiple
-threads. This can be called any number of times. This gives the same result as
-`blake3_hasher_update` above.
-
-[oneTBB]: https://uxlfoundation.github.io/oneTBB/
-
-NOTE: This function is only enabled when the library is compiled with CMake option `BLAKE3_USE_TBB`
-and when the oneTBB library is detected on the host system. See the building instructions for
-further details.
-
-To get any performance benefit from multithreading, the input buffer needs to
-be large. As a rule of thumb on x86_64, `blake3_hasher_update_tbb` is _slower_
-than `blake3_hasher_update` for inputs under 128 KiB. That threshold varies
-quite a lot across different processors, and it's important to benchmark your
-specific use case.
-
-Hashing large files with this function usually requires
-[memory-mapping](https://en.wikipedia.org/wiki/Memory-mapped_file), since
-reading a file into memory in a single-threaded loop takes longer than hashing
-the resulting buffer. Note that hashing a memory-mapped file with this function
-produces a "random" pattern of disk reads, which can be slow on spinning disks.
-Again it's important to benchmark your specific use case.
-
-This implementation doesn't require configuration of thread resources and will
-use as many cores as possible by default. More fine-grained control of
-resources is possible using the [oneTBB] API.
-
----
-
-```c
-void blake3_hasher_finalize_seek(
-  const blake3_hasher *self,
-  uint64_t seek,
-  uint8_t *out,
-  size_t out_len);
-```
-
-The same as `blake3_hasher_finalize`, but with an additional `seek`
-parameter for the starting byte position in the output stream. To
-efficiently stream a large output without allocating memory, call this
-function in a loop, incrementing `seek` by the output length each time.
-
----
-
-```c
-void blake3_hasher_reset(
-  blake3_hasher *self);
-```
-
-Reset the hasher to its initial state, prior to any calls to
-`blake3_hasher_update`. Currently this is no different from calling
-`blake3_hasher_init` or similar again.
-
-# Security Notes
-
-Outputs shorter than the default length of 32 bytes (256 bits) provide less security. An N-bit
-BLAKE3 output is intended to provide N bits of first and second preimage resistance and N/2
-bits of collision resistance, for any N up to 256. Longer outputs don't provide any additional
-security.
-
-Avoid relying on the secrecy of the output offset, that is, the `seek` argument of
-`blake3_hasher_finalize_seek`. [_Block-Cipher-Based Tree Hashing_ by Aldo
-Gunsing](https://eprint.iacr.org/2022/283) shows that an attacker who knows both the message
-and the key (if any) can easily determine the offset of an extended output. For comparison,
-AES-CTR has a similar property: if you know the key, you can decrypt a block from an unknown
-position in the output stream to recover its block index. Callers with strong secret keys
-aren't affected in practice, but secret offsets are a [design
-smell](https://en.wikipedia.org/wiki/Design_smell) in any case.
-
-# Building
-
-The easiest and most complete method of compiling this library is with CMake.
-This is the method described in the next section. Toward the end of the
-building section there are more in depth notes about compiling manually and
-things that are useful to understand if you need to integrate this library with
-another build system.
-
-## CMake
-
-The minimum version of CMake is 3.9. The following invocations will compile and
-install `libblake3`. With recent CMake:
-
-```bash
-cmake -S c -B c/build "-DCMAKE_INSTALL_PREFIX=/usr/local"
-cmake --build c/build --target install
-```
-
-With an older CMake:
-
-```bash
-cd c
-mkdir build
-cd build
-cmake .. "-DCMAKE_INSTALL_PREFIX=/usr/local"
-cmake --build . --target install
-```
-
-The following options are available when compiling with CMake:
-
-- `BLAKE3_USE_TBB`: Enable oneTBB parallelism (Requires a C++20 capable compiler)
-- `BLAKE3_FETCH_TBB`: Allow fetching oneTBB from GitHub (only if not found on system)
-- `BLAKE3_EXAMPLES`: Compile and install example programs
-
-Options can be enabled like this:
-
-```bash
-cmake -S c -B c/build "-DCMAKE_INSTALL_PREFIX=/usr/local" -DBLAKE3_USE_TBB=1 -DBLAKE3_FETCH_TBB=1
-```
-
-## Building manually
-
-We try to keep the build simple enough that you can compile this library "by
-hand", and it's expected that many callers will integrate it with their
-pre-existing build systems. See the `gcc` one-liner in the "Example" section
-above.
-
-### x86
-
-Dynamic dispatch is enabled by default on x86. The implementation will
-query the CPU at runtime to detect SIMD support, and it will use the
-widest instruction set available. By default, `blake3_dispatch.c`
-expects to be linked with code for five different instruction sets:
-portable C, SSE2, SSE4.1, AVX2, and AVX-512.
-
-For each of the x86 SIMD instruction sets, four versions are available:
-three flavors of assembly (Unix, Windows MSVC, and Windows GNU) and one
-version using C intrinsics. The assembly versions are generally
-preferred. They perform better, they perform more consistently across
-different compilers, and they build more quickly. On the other hand, the
-assembly versions are x86\_64-only, and you need to select the right
-flavor for your target platform.
-
-Here's an example of building a shared library on x86\_64 Linux using
-the assembly implementations:
-
-```bash
-gcc -shared -O3 -o libblake3.so blake3.c blake3_dispatch.c blake3_portable.c \
-    blake3_sse2_x86-64_unix.S blake3_sse41_x86-64_unix.S blake3_avx2_x86-64_unix.S \
-    blake3_avx512_x86-64_unix.S
-```
-
-When building the intrinsics-based implementations, you need to build
-each implementation separately, with the corresponding instruction set
-explicitly enabled in the compiler. Here's the same shared library using
-the intrinsics-based implementations:
-
-```bash
-gcc -c -fPIC -O3 -msse2 blake3_sse2.c -o blake3_sse2.o
-gcc -c -fPIC -O3 -msse4.1 blake3_sse41.c -o blake3_sse41.o
-gcc -c -fPIC -O3 -mavx2 blake3_avx2.c -o blake3_avx2.o
-gcc -c -fPIC -O3 -mavx512f -mavx512vl blake3_avx512.c -o blake3_avx512.o
-gcc -shared -O3 -o libblake3.so blake3.c blake3_dispatch.c blake3_portable.c \
-    blake3_avx2.o blake3_avx512.o blake3_sse41.o blake3_sse2.o
-```
-
-Note above that building `blake3_avx512.c` requires both `-mavx512f` and
-`-mavx512vl` under GCC and Clang. Under MSVC, the single `/arch:AVX512`
-flag is sufficient. The MSVC equivalent of `-mavx2` is `/arch:AVX2`.
-MSVC enables SSE2 and SSE4.1 by default, and it doesn't have a
-corresponding flag.
-
-If you want to omit SIMD code entirely, you need to explicitly disable
-each instruction set. Here's an example of building a shared library on
-x86 with only portable code:
-
-```bash
-gcc -shared -O3 -o libblake3.so -DBLAKE3_NO_SSE2 -DBLAKE3_NO_SSE41 -DBLAKE3_NO_AVX2 \
-    -DBLAKE3_NO_AVX512 blake3.c blake3_dispatch.c blake3_portable.c
-```
-
-### ARM NEON
-
-The NEON implementation is enabled by default on AArch64, but not on
-other ARM targets, since not all of them support it. To enable it, set
-`BLAKE3_USE_NEON=1`. Here's an example of building a shared library on
-ARM Linux with NEON support:
-
-```bash
-gcc -shared -O3 -o libblake3.so -DBLAKE3_USE_NEON=1 blake3.c blake3_dispatch.c \
-    blake3_portable.c blake3_neon.c
-```
-
-To explicitiy disable using NEON instructions on AArch64, set
-`BLAKE3_USE_NEON=0`.
-
-```bash
-gcc -shared -O3 -o libblake3.so -DBLAKE3_USE_NEON=0 blake3.c blake3_dispatch.c \
-    blake3_portable.c 
-```
-
-Note that on some targets (ARMv7 in particular), extra flags may be
-required to activate NEON support in the compiler. If you see an error
-like...
-
-```
-/usr/lib/gcc/armv7l-unknown-linux-gnueabihf/9.2.0/include/arm_neon.h:635:1: error: inlining failed
-in call to always_inline ‘vaddq_u32’: target specific option mismatch
-```
-
-...then you may need to add something like `-mfpu=neon-vfpv4
--mfloat-abi=hard`.
-
-### Other Platforms
-
-The portable implementation should work on most other architectures. For
-example:
-
-```bash
-gcc -shared -O3 -o libblake3.so blake3.c blake3_dispatch.c blake3_portable.c
-```
-
-### Multithreading
-
-Multithreading is available using [oneTBB], by compiling the optional C++
-support file [`blake3_tbb.cpp`](./blake3_tbb.cpp). For an example of using
-`mmap` (non-Windows) and `blake3_hasher_update_tbb` to get large-file
-performance on par with [`b3sum`](../b3sum), see
-[`example_tbb.c`](./example_tbb.c). You can build it like this:
-
-```bash
-g++ -c -O3 -fno-exceptions -fno-rtti -DBLAKE3_USE_TBB -o blake3_tbb.o blake3_tbb.cpp
-gcc -O3 -o example_tbb -lstdc++ -ltbb -DBLAKE3_USE_TBB blake3_tbb.o example_tbb.c blake3.c \
-    blake3_dispatch.c blake3_portable.c blake3_sse2_x86-64_unix.S blake3_sse41_x86-64_unix.S \
-    blake3_avx2_x86-64_unix.S blake3_avx512_x86-64_unix.S
-```
-
-NOTE: `-fno-exceptions` or equivalent is required to compile `blake3_tbb.cpp`,
-and public API methods with external C linkage are marked `noexcept`. Compiling
-that file with exceptions enabled will fail. Compiling with RTTI disabled isn't
-required but is recommended for code size.

external/blake3/blake3-config.cmake.in

@@ -1,14 +0,0 @@
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-
-# Remember TBB option state
-set(BLAKE3_USE_TBB @BLAKE3_USE_TBB@)
-
-if(BLAKE3_USE_TBB)
-    find_dependency(TBB @TBB_VERSION@)
-endif()
-
-include("${CMAKE_CURRENT_LIST_DIR}/blake3-targets.cmake")
-
-check_required_components(blake3)

external/blake3/blake3.c

@@ -1,650 +0,0 @@
-#include <assert.h>
-#include <stdbool.h>
-#include <string.h>
-
-#include "blake3.h"
-#include "blake3_impl.h"
-
-const char *blake3_version(void) { return BLAKE3_VERSION_STRING; }
-
-INLINE void chunk_state_init(blake3_chunk_state *self, const uint32_t key[8],
-                             uint8_t flags) {
-  memcpy(self->cv, key, BLAKE3_KEY_LEN);
-  self->chunk_counter = 0;
-  memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-  self->buf_len = 0;
-  self->blocks_compressed = 0;
-  self->flags = flags;
-}
-
-INLINE void chunk_state_reset(blake3_chunk_state *self, const uint32_t key[8],
-                              uint64_t chunk_counter) {
-  memcpy(self->cv, key, BLAKE3_KEY_LEN);
-  self->chunk_counter = chunk_counter;
-  self->blocks_compressed = 0;
-  memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-  self->buf_len = 0;
-}
-
-INLINE size_t chunk_state_len(const blake3_chunk_state *self) {
-  return (BLAKE3_BLOCK_LEN * (size_t)self->blocks_compressed) +
-         ((size_t)self->buf_len);
-}
-
-INLINE size_t chunk_state_fill_buf(blake3_chunk_state *self,
-                                   const uint8_t *input, size_t input_len) {
-  size_t take = BLAKE3_BLOCK_LEN - ((size_t)self->buf_len);
-  if (take > input_len) {
-    take = input_len;
-  }
-  uint8_t *dest = self->buf + ((size_t)self->buf_len);
-  memcpy(dest, input, take);
-  self->buf_len += (uint8_t)take;
-  return take;
-}
-
-INLINE uint8_t chunk_state_maybe_start_flag(const blake3_chunk_state *self) {
-  if (self->blocks_compressed == 0) {
-    return CHUNK_START;
-  } else {
-    return 0;
-  }
-}
-
-typedef struct {
-  uint32_t input_cv[8];
-  uint64_t counter;
-  uint8_t block[BLAKE3_BLOCK_LEN];
-  uint8_t block_len;
-  uint8_t flags;
-} output_t;
-
-INLINE output_t make_output(const uint32_t input_cv[8],
-                            const uint8_t block[BLAKE3_BLOCK_LEN],
-                            uint8_t block_len, uint64_t counter,
-                            uint8_t flags) {
-  output_t ret;
-  memcpy(ret.input_cv, input_cv, 32);
-  memcpy(ret.block, block, BLAKE3_BLOCK_LEN);
-  ret.block_len = block_len;
-  ret.counter = counter;
-  ret.flags = flags;
-  return ret;
-}
-
-// Chaining values within a given chunk (specifically the compress_in_place
-// interface) are represented as words. This avoids unnecessary bytes<->words
-// conversion overhead in the portable implementation. However, the hash_many
-// interface handles both user input and parent node blocks, so it accepts
-// bytes. For that reason, chaining values in the CV stack are represented as
-// bytes.
-INLINE void output_chaining_value(const output_t *self, uint8_t cv[32]) {
-  uint32_t cv_words[8];
-  memcpy(cv_words, self->input_cv, 32);
-  blake3_compress_in_place(cv_words, self->block, self->block_len,
-                           self->counter, self->flags);
-  store_cv_words(cv, cv_words);
-}
-
-INLINE void output_root_bytes(const output_t *self, uint64_t seek, uint8_t *out,
-                              size_t out_len) {
-  if (out_len == 0) {
-      return;
-  }
-  uint64_t output_block_counter = seek / 64;
-  size_t offset_within_block = seek % 64;
-  uint8_t wide_buf[64];
-  if(offset_within_block) {
-    blake3_compress_xof(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, wide_buf);
-    const size_t available_bytes = 64 - offset_within_block;
-    const size_t bytes = out_len > available_bytes ? available_bytes : out_len;
-    memcpy(out, wide_buf + offset_within_block, bytes);
-    out += bytes;
-    out_len -= bytes;
-    output_block_counter += 1;
-  }
-  if(out_len / 64) {
-    blake3_xof_many(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, out, out_len / 64);
-  }
-  output_block_counter += out_len / 64;
-  out += out_len & -64;
-  out_len -= out_len & -64;
-  if(out_len) {
-    blake3_compress_xof(self->input_cv, self->block, self->block_len, output_block_counter, self->flags | ROOT, wide_buf);
-    memcpy(out, wide_buf, out_len);
-  }
-}
-
-INLINE void chunk_state_update(blake3_chunk_state *self, const uint8_t *input,
-                               size_t input_len) {
-  if (self->buf_len > 0) {
-    size_t take = chunk_state_fill_buf(self, input, input_len);
-    input += take;
-    input_len -= take;
-    if (input_len > 0) {
-      blake3_compress_in_place(
-          self->cv, self->buf, BLAKE3_BLOCK_LEN, self->chunk_counter,
-          self->flags | chunk_state_maybe_start_flag(self));
-      self->blocks_compressed += 1;
-      self->buf_len = 0;
-      memset(self->buf, 0, BLAKE3_BLOCK_LEN);
-    }
-  }
-
-  while (input_len > BLAKE3_BLOCK_LEN) {
-    blake3_compress_in_place(self->cv, input, BLAKE3_BLOCK_LEN,
-                             self->chunk_counter,
-                             self->flags | chunk_state_maybe_start_flag(self));
-    self->blocks_compressed += 1;
-    input += BLAKE3_BLOCK_LEN;
-    input_len -= BLAKE3_BLOCK_LEN;
-  }
-
-  chunk_state_fill_buf(self, input, input_len);
-}
-
-INLINE output_t chunk_state_output(const blake3_chunk_state *self) {
-  uint8_t block_flags =
-      self->flags | chunk_state_maybe_start_flag(self) | CHUNK_END;
-  return make_output(self->cv, self->buf, self->buf_len, self->chunk_counter,
-                     block_flags);
-}
-
-INLINE output_t parent_output(const uint8_t block[BLAKE3_BLOCK_LEN],
-                              const uint32_t key[8], uint8_t flags) {
-  return make_output(key, block, BLAKE3_BLOCK_LEN, 0, flags | PARENT);
-}
-
-// Given some input larger than one chunk, return the number of bytes that
-// should go in the left subtree. This is the largest power-of-2 number of
-// chunks that leaves at least 1 byte for the right subtree.
-INLINE size_t left_subtree_len(size_t input_len) {
-  // Subtract 1 to reserve at least one byte for the right side. input_len
-  // should always be greater than BLAKE3_CHUNK_LEN.
-  size_t full_chunks = (input_len - 1) / BLAKE3_CHUNK_LEN;
-  return round_down_to_power_of_2(full_chunks) * BLAKE3_CHUNK_LEN;
-}
-
-// Use SIMD parallelism to hash up to MAX_SIMD_DEGREE chunks at the same time
-// on a single thread. Write out the chunk chaining values and return the
-// number of chunks hashed. These chunks are never the root and never empty;
-// those cases use a different codepath.
-INLINE size_t compress_chunks_parallel(const uint8_t *input, size_t input_len,
-                                       const uint32_t key[8],
-                                       uint64_t chunk_counter, uint8_t flags,
-                                       uint8_t *out) {
-#if defined(BLAKE3_TESTING)
-  assert(0 < input_len);
-  assert(input_len <= MAX_SIMD_DEGREE * BLAKE3_CHUNK_LEN);
-#endif
-
-  const uint8_t *chunks_array[MAX_SIMD_DEGREE];
-  size_t input_position = 0;
-  size_t chunks_array_len = 0;
-  while (input_len - input_position >= BLAKE3_CHUNK_LEN) {
-    chunks_array[chunks_array_len] = &input[input_position];
-    input_position += BLAKE3_CHUNK_LEN;
-    chunks_array_len += 1;
-  }
-
-  blake3_hash_many(chunks_array, chunks_array_len,
-                   BLAKE3_CHUNK_LEN / BLAKE3_BLOCK_LEN, key, chunk_counter,
-                   true, flags, CHUNK_START, CHUNK_END, out);
-
-  // Hash the remaining partial chunk, if there is one. Note that the empty
-  // chunk (meaning the empty message) is a different codepath.
-  if (input_len > input_position) {
-    uint64_t counter = chunk_counter + (uint64_t)chunks_array_len;
-    blake3_chunk_state chunk_state;
-    chunk_state_init(&chunk_state, key, flags);
-    chunk_state.chunk_counter = counter;
-    chunk_state_update(&chunk_state, &input[input_position],
-                       input_len - input_position);
-    output_t output = chunk_state_output(&chunk_state);
-    output_chaining_value(&output, &out[chunks_array_len * BLAKE3_OUT_LEN]);
-    return chunks_array_len + 1;
-  } else {
-    return chunks_array_len;
-  }
-}
-
-// Use SIMD parallelism to hash up to MAX_SIMD_DEGREE parents at the same time
-// on a single thread. Write out the parent chaining values and return the
-// number of parents hashed. (If there's an odd input chaining value left over,
-// return it as an additional output.) These parents are never the root and
-// never empty; those cases use a different codepath.
-INLINE size_t compress_parents_parallel(const uint8_t *child_chaining_values,
-                                        size_t num_chaining_values,
-                                        const uint32_t key[8], uint8_t flags,
-                                        uint8_t *out) {
-#if defined(BLAKE3_TESTING)
-  assert(2 <= num_chaining_values);
-  assert(num_chaining_values <= 2 * MAX_SIMD_DEGREE_OR_2);
-#endif
-
-  const uint8_t *parents_array[MAX_SIMD_DEGREE_OR_2];
-  size_t parents_array_len = 0;
-  while (num_chaining_values - (2 * parents_array_len) >= 2) {
-    parents_array[parents_array_len] =
-        &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN];
-    parents_array_len += 1;
-  }
-
-  blake3_hash_many(parents_array, parents_array_len, 1, key,
-                   0, // Parents always use counter 0.
-                   false, flags | PARENT,
-                   0, // Parents have no start flags.
-                   0, // Parents have no end flags.
-                   out);
-
-  // If there's an odd child left over, it becomes an output.
-  if (num_chaining_values > 2 * parents_array_len) {
-    memcpy(&out[parents_array_len * BLAKE3_OUT_LEN],
-           &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN],
-           BLAKE3_OUT_LEN);
-    return parents_array_len + 1;
-  } else {
-    return parents_array_len;
-  }
-}
-
-// The wide helper function returns (writes out) an array of chaining values
-// and returns the length of that array. The number of chaining values returned
-// is the dynamically detected SIMD degree, at most MAX_SIMD_DEGREE. Or fewer,
-// if the input is shorter than that many chunks. The reason for maintaining a
-// wide array of chaining values going back up the tree, is to allow the
-// implementation to hash as many parents in parallel as possible.
-//
-// As a special case when the SIMD degree is 1, this function will still return
-// at least 2 outputs. This guarantees that this function doesn't perform the
-// root compression. (If it did, it would use the wrong flags, and also we
-// wouldn't be able to implement extendable output.) Note that this function is
-// not used when the whole input is only 1 chunk long; that's a different
-// codepath.
-//
-// Why not just have the caller split the input on the first update(), instead
-// of implementing this special rule? Because we don't want to limit SIMD or
-// multi-threading parallelism for that update().
-size_t blake3_compress_subtree_wide(const uint8_t *input, size_t input_len,
-                                    const uint32_t key[8],
-                                    uint64_t chunk_counter, uint8_t flags,
-                                    uint8_t *out, bool use_tbb) {
-  // Note that the single chunk case does *not* bump the SIMD degree up to 2
-  // when it is 1. If this implementation adds multi-threading in the future,
-  // this gives us the option of multi-threading even the 2-chunk case, which
-  // can help performance on smaller platforms.
-  if (input_len <= blake3_simd_degree() * BLAKE3_CHUNK_LEN) {
-    return compress_chunks_parallel(input, input_len, key, chunk_counter, flags,
-                                    out);
-  }
-
-  // With more than simd_degree chunks, we need to recurse. Start by dividing
-  // the input into left and right subtrees. (Note that this is only optimal
-  // as long as the SIMD degree is a power of 2. If we ever get a SIMD degree
-  // of 3 or something, we'll need a more complicated strategy.)
-  size_t left_input_len = left_subtree_len(input_len);
-  size_t right_input_len = input_len - left_input_len;
-  const uint8_t *right_input = &input[left_input_len];
-  uint64_t right_chunk_counter =
-      chunk_counter + (uint64_t)(left_input_len / BLAKE3_CHUNK_LEN);
-
-  // Make space for the child outputs. Here we use MAX_SIMD_DEGREE_OR_2 to
-  // account for the special case of returning 2 outputs when the SIMD degree
-  // is 1.
-  uint8_t cv_array[2 * MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN];
-  size_t degree = blake3_simd_degree();
-  if (left_input_len > BLAKE3_CHUNK_LEN && degree == 1) {
-    // The special case: We always use a degree of at least two, to make
-    // sure there are two outputs. Except, as noted above, at the chunk
-    // level, where we allow degree=1. (Note that the 1-chunk-input case is
-    // a different codepath.)
-    degree = 2;
-  }
-  uint8_t *right_cvs = &cv_array[degree * BLAKE3_OUT_LEN];
-
-  // Recurse!
-  size_t left_n = -1;
-  size_t right_n = -1;
-
-#if defined(BLAKE3_USE_TBB)
-  blake3_compress_subtree_wide_join_tbb(
-      key, flags, use_tbb,
-      // left-hand side
-      input, left_input_len, chunk_counter, cv_array, &left_n,
-      // right-hand side
-      right_input, right_input_len, right_chunk_counter, right_cvs, &right_n);
-#else
-  left_n = blake3_compress_subtree_wide(
-      input, left_input_len, key, chunk_counter, flags, cv_array, use_tbb);
-  right_n = blake3_compress_subtree_wide(right_input, right_input_len, key,
-                                         right_chunk_counter, flags, right_cvs,
-                                         use_tbb);
-#endif // BLAKE3_USE_TBB
-
-  // The special case again. If simd_degree=1, then we'll have left_n=1 and
-  // right_n=1. Rather than compressing them into a single output, return
-  // them directly, to make sure we always have at least two outputs.
-  if (left_n == 1) {
-    memcpy(out, cv_array, 2 * BLAKE3_OUT_LEN);
-    return 2;
-  }
-
-  // Otherwise, do one layer of parent node compression.
-  size_t num_chaining_values = left_n + right_n;
-  return compress_parents_parallel(cv_array, num_chaining_values, key, flags,
-                                   out);
-}
-
-// Hash a subtree with compress_subtree_wide(), and then condense the resulting
-// list of chaining values down to a single parent node. Don't compress that
-// last parent node, however. Instead, return its message bytes (the
-// concatenated chaining values of its children). This is necessary when the
-// first call to update() supplies a complete subtree, because the topmost
-// parent node of that subtree could end up being the root. It's also necessary
-// for extended output in the general case.
-//
-// As with compress_subtree_wide(), this function is not used on inputs of 1
-// chunk or less. That's a different codepath.
-INLINE void
-compress_subtree_to_parent_node(const uint8_t *input, size_t input_len,
-                                const uint32_t key[8], uint64_t chunk_counter,
-                                uint8_t flags, uint8_t out[2 * BLAKE3_OUT_LEN],
-                                bool use_tbb) {
-#if defined(BLAKE3_TESTING)
-  assert(input_len > BLAKE3_CHUNK_LEN);
-#endif
-
-  uint8_t cv_array[MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN];
-  size_t num_cvs = blake3_compress_subtree_wide(input, input_len, key,
-                                                chunk_counter, flags, cv_array, use_tbb);
-  assert(num_cvs <= MAX_SIMD_DEGREE_OR_2);
-  // The following loop never executes when MAX_SIMD_DEGREE_OR_2 is 2, because
-  // as we just asserted, num_cvs will always be <=2 in that case. But GCC
-  // (particularly GCC 8.5) can't tell that it never executes, and if NDEBUG is
-  // set then it emits incorrect warnings here. We tried a few different
-  // hacks to silence these, but in the end our hacks just produced different
-  // warnings (see https://github.com/BLAKE3-team/BLAKE3/pull/380). Out of
-  // desperation, we ifdef out this entire loop when we know it's not needed.
-#if MAX_SIMD_DEGREE_OR_2 > 2
-  // If MAX_SIMD_DEGREE_OR_2 is greater than 2 and there's enough input,
-  // compress_subtree_wide() returns more than 2 chaining values. Condense
-  // them into 2 by forming parent nodes repeatedly.
-  uint8_t out_array[MAX_SIMD_DEGREE_OR_2 * BLAKE3_OUT_LEN / 2];
-  while (num_cvs > 2) {
-    num_cvs =
-        compress_parents_parallel(cv_array, num_cvs, key, flags, out_array);
-    memcpy(cv_array, out_array, num_cvs * BLAKE3_OUT_LEN);
-  }
-#endif
-  memcpy(out, cv_array, 2 * BLAKE3_OUT_LEN);
-}
-
-INLINE void hasher_init_base(blake3_hasher *self, const uint32_t key[8],
-                             uint8_t flags) {
-  memcpy(self->key, key, BLAKE3_KEY_LEN);
-  chunk_state_init(&self->chunk, key, flags);
-  self->cv_stack_len = 0;
-}
-
-void blake3_hasher_init(blake3_hasher *self) { hasher_init_base(self, IV, 0); }
-
-void blake3_hasher_init_keyed(blake3_hasher *self,
-                              const uint8_t key[BLAKE3_KEY_LEN]) {
-  uint32_t key_words[8];
-  load_key_words(key, key_words);
-  hasher_init_base(self, key_words, KEYED_HASH);
-}
-
-void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                       size_t context_len) {
-  blake3_hasher context_hasher;
-  hasher_init_base(&context_hasher, IV, DERIVE_KEY_CONTEXT);
-  blake3_hasher_update(&context_hasher, context, context_len);
-  uint8_t context_key[BLAKE3_KEY_LEN];
-  blake3_hasher_finalize(&context_hasher, context_key, BLAKE3_KEY_LEN);
-  uint32_t context_key_words[8];
-  load_key_words(context_key, context_key_words);
-  hasher_init_base(self, context_key_words, DERIVE_KEY_MATERIAL);
-}
-
-void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context) {
-  blake3_hasher_init_derive_key_raw(self, context, strlen(context));
-}
-
-// As described in hasher_push_cv() below, we do "lazy merging", delaying
-// merges until right before the next CV is about to be added. This is
-// different from the reference implementation. Another difference is that we
-// aren't always merging 1 chunk at a time. Instead, each CV might represent
-// any power-of-two number of chunks, as long as the smaller-above-larger stack
-// order is maintained. Instead of the "count the trailing 0-bits" algorithm
-// described in the spec, we use a "count the total number of 1-bits" variant
-// that doesn't require us to retain the subtree size of the CV on top of the
-// stack. The principle is the same: each CV that should remain in the stack is
-// represented by a 1-bit in the total number of chunks (or bytes) so far.
-INLINE void hasher_merge_cv_stack(blake3_hasher *self, uint64_t total_len) {
-  size_t post_merge_stack_len = (size_t)popcnt(total_len);
-  while (self->cv_stack_len > post_merge_stack_len) {
-    uint8_t *parent_node =
-        &self->cv_stack[(self->cv_stack_len - 2) * BLAKE3_OUT_LEN];
-    output_t output = parent_output(parent_node, self->key, self->chunk.flags);
-    output_chaining_value(&output, parent_node);
-    self->cv_stack_len -= 1;
-  }
-}
-
-// In reference_impl.rs, we merge the new CV with existing CVs from the stack
-// before pushing it. We can do that because we know more input is coming, so
-// we know none of the merges are root.
-//
-// This setting is different. We want to feed as much input as possible to
-// compress_subtree_wide(), without setting aside anything for the chunk_state.
-// If the user gives us 64 KiB, we want to parallelize over all 64 KiB at once
-// as a single subtree, if at all possible.
-//
-// This leads to two problems:
-// 1) This 64 KiB input might be the only call that ever gets made to update.
-//    In this case, the root node of the 64 KiB subtree would be the root node
-//    of the whole tree, and it would need to be ROOT finalized. We can't
-//    compress it until we know.
-// 2) This 64 KiB input might complete a larger tree, whose root node is
-//    similarly going to be the root of the whole tree. For example, maybe
-//    we have 196 KiB (that is, 128 + 64) hashed so far. We can't compress the
-//    node at the root of the 256 KiB subtree until we know how to finalize it.
-//
-// The second problem is solved with "lazy merging". That is, when we're about
-// to add a CV to the stack, we don't merge it with anything first, as the
-// reference impl does. Instead we do merges using the *previous* CV that was
-// added, which is sitting on top of the stack, and we put the new CV
-// (unmerged) on top of the stack afterwards. This guarantees that we never
-// merge the root node until finalize().
-//
-// Solving the first problem requires an additional tool,
-// compress_subtree_to_parent_node(). That function always returns the top
-// *two* chaining values of the subtree it's compressing. We then do lazy
-// merging with each of them separately, so that the second CV will always
-// remain unmerged. (That also helps us support extendable output when we're
-// hashing an input all-at-once.)
-INLINE void hasher_push_cv(blake3_hasher *self, uint8_t new_cv[BLAKE3_OUT_LEN],
-                           uint64_t chunk_counter) {
-  hasher_merge_cv_stack(self, chunk_counter);
-  memcpy(&self->cv_stack[self->cv_stack_len * BLAKE3_OUT_LEN], new_cv,
-         BLAKE3_OUT_LEN);
-  self->cv_stack_len += 1;
-}
-
-INLINE void blake3_hasher_update_base(blake3_hasher *self, const void *input,
-                                      size_t input_len, bool use_tbb) {
-  // Explicitly checking for zero avoids causing UB by passing a null pointer
-  // to memcpy. This comes up in practice with things like:
-  //   std::vector<uint8_t> v;
-  //   blake3_hasher_update(&hasher, v.data(), v.size());
-  if (input_len == 0) {
-    return;
-  }
-
-  const uint8_t *input_bytes = (const uint8_t *)input;
-
-  // If we have some partial chunk bytes in the internal chunk_state, we need
-  // to finish that chunk first.
-  if (chunk_state_len(&self->chunk) > 0) {
-    size_t take = BLAKE3_CHUNK_LEN - chunk_state_len(&self->chunk);
-    if (take > input_len) {
-      take = input_len;
-    }
-    chunk_state_update(&self->chunk, input_bytes, take);
-    input_bytes += take;
-    input_len -= take;
-    // If we've filled the current chunk and there's more coming, finalize this
-    // chunk and proceed. In this case we know it's not the root.
-    if (input_len > 0) {
-      output_t output = chunk_state_output(&self->chunk);
-      uint8_t chunk_cv[32];
-      output_chaining_value(&output, chunk_cv);
-      hasher_push_cv(self, chunk_cv, self->chunk.chunk_counter);
-      chunk_state_reset(&self->chunk, self->key, self->chunk.chunk_counter + 1);
-    } else {
-      return;
-    }
-  }
-
-  // Now the chunk_state is clear, and we have more input. If there's more than
-  // a single chunk (so, definitely not the root chunk), hash the largest whole
-  // subtree we can, with the full benefits of SIMD (and maybe in the future,
-  // multi-threading) parallelism. Two restrictions:
-  // - The subtree has to be a power-of-2 number of chunks. Only subtrees along
-  //   the right edge can be incomplete, and we don't know where the right edge
-  //   is going to be until we get to finalize().
-  // - The subtree must evenly divide the total number of chunks up until this
-  //   point (if total is not 0). If the current incomplete subtree is only
-  //   waiting for 1 more chunk, we can't hash a subtree of 4 chunks. We have
-  //   to complete the current subtree first.
-  // Because we might need to break up the input to form powers of 2, or to
-  // evenly divide what we already have, this part runs in a loop.
-  while (input_len > BLAKE3_CHUNK_LEN) {
-    size_t subtree_len = round_down_to_power_of_2(input_len);
-    uint64_t count_so_far = self->chunk.chunk_counter * BLAKE3_CHUNK_LEN;
-    // Shrink the subtree_len until it evenly divides the count so far. We know
-    // that subtree_len itself is a power of 2, so we can use a bitmasking
-    // trick instead of an actual remainder operation. (Note that if the caller
-    // consistently passes power-of-2 inputs of the same size, as is hopefully
-    // typical, this loop condition will always fail, and subtree_len will
-    // always be the full length of the input.)
-    //
-    // An aside: We don't have to shrink subtree_len quite this much. For
-    // example, if count_so_far is 1, we could pass 2 chunks to
-    // compress_subtree_to_parent_node. Since we'll get 2 CVs back, we'll still
-    // get the right answer in the end, and we might get to use 2-way SIMD
-    // parallelism. The problem with this optimization, is that it gets us
-    // stuck always hashing 2 chunks. The total number of chunks will remain
-    // odd, and we'll never graduate to higher degrees of parallelism. See
-    // https://github.com/BLAKE3-team/BLAKE3/issues/69.
-    while ((((uint64_t)(subtree_len - 1)) & count_so_far) != 0) {
-      subtree_len /= 2;
-    }
-    // The shrunken subtree_len might now be 1 chunk long. If so, hash that one
-    // chunk by itself. Otherwise, compress the subtree into a pair of CVs.
-    uint64_t subtree_chunks = subtree_len / BLAKE3_CHUNK_LEN;
-    if (subtree_len <= BLAKE3_CHUNK_LEN) {
-      blake3_chunk_state chunk_state;
-      chunk_state_init(&chunk_state, self->key, self->chunk.flags);
-      chunk_state.chunk_counter = self->chunk.chunk_counter;
-      chunk_state_update(&chunk_state, input_bytes, subtree_len);
-      output_t output = chunk_state_output(&chunk_state);
-      uint8_t cv[BLAKE3_OUT_LEN];
-      output_chaining_value(&output, cv);
-      hasher_push_cv(self, cv, chunk_state.chunk_counter);
-    } else {
-      // This is the high-performance happy path, though getting here depends
-      // on the caller giving us a long enough input.
-      uint8_t cv_pair[2 * BLAKE3_OUT_LEN];
-      compress_subtree_to_parent_node(input_bytes, subtree_len, self->key,
-                                      self->chunk.chunk_counter,
-                                      self->chunk.flags, cv_pair, use_tbb);
-      hasher_push_cv(self, cv_pair, self->chunk.chunk_counter);
-      hasher_push_cv(self, &cv_pair[BLAKE3_OUT_LEN],
-                     self->chunk.chunk_counter + (subtree_chunks / 2));
-    }
-    self->chunk.chunk_counter += subtree_chunks;
-    input_bytes += subtree_len;
-    input_len -= subtree_len;
-  }
-
-  // If there's any remaining input less than a full chunk, add it to the chunk
-  // state. In that case, also do a final merge loop to make sure the subtree
-  // stack doesn't contain any unmerged pairs. The remaining input means we
-  // know these merges are non-root. This merge loop isn't strictly necessary
-  // here, because hasher_push_chunk_cv already does its own merge loop, but it
-  // simplifies blake3_hasher_finalize below.
-  if (input_len > 0) {
-    chunk_state_update(&self->chunk, input_bytes, input_len);
-    hasher_merge_cv_stack(self, self->chunk.chunk_counter);
-  }
-}
-
-void blake3_hasher_update(blake3_hasher *self, const void *input,
-                          size_t input_len) {
-  bool use_tbb = false;
-  blake3_hasher_update_base(self, input, input_len, use_tbb);
-}
-
-#if defined(BLAKE3_USE_TBB)
-void blake3_hasher_update_tbb(blake3_hasher *self, const void *input,
-                              size_t input_len) {
-  bool use_tbb = true;
-  blake3_hasher_update_base(self, input, input_len, use_tbb);
-}
-#endif // BLAKE3_USE_TBB
-
-void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                            size_t out_len) {
-  blake3_hasher_finalize_seek(self, 0, out, out_len);
-}
-
-void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                 uint8_t *out, size_t out_len) {
-  // Explicitly checking for zero avoids causing UB by passing a null pointer
-  // to memcpy. This comes up in practice with things like:
-  //   std::vector<uint8_t> v;
-  //   blake3_hasher_finalize(&hasher, v.data(), v.size());
-  if (out_len == 0) {
-    return;
-  }
-
-  // If the subtree stack is empty, then the current chunk is the root.
-  if (self->cv_stack_len == 0) {
-    output_t output = chunk_state_output(&self->chunk);
-    output_root_bytes(&output, seek, out, out_len);
-    return;
-  }
-  // If there are any bytes in the chunk state, finalize that chunk and do a
-  // roll-up merge between that chunk hash and every subtree in the stack. In
-  // this case, the extra merge loop at the end of blake3_hasher_update
-  // guarantees that none of the subtrees in the stack need to be merged with
-  // each other first. Otherwise, if there are no bytes in the chunk state,
-  // then the top of the stack is a chunk hash, and we start the merge from
-  // that.
-  output_t output;
-  size_t cvs_remaining;
-  if (chunk_state_len(&self->chunk) > 0) {
-    cvs_remaining = self->cv_stack_len;
-    output = chunk_state_output(&self->chunk);
-  } else {
-    // There are always at least 2 CVs in the stack in this case.
-    cvs_remaining = self->cv_stack_len - 2;
-    output = parent_output(&self->cv_stack[cvs_remaining * 32], self->key,
-                           self->chunk.flags);
-  }
-  while (cvs_remaining > 0) {
-    cvs_remaining -= 1;
-    uint8_t parent_block[BLAKE3_BLOCK_LEN];
-    memcpy(parent_block, &self->cv_stack[cvs_remaining * 32], 32);
-    output_chaining_value(&output, &parent_block[32]);
-    output = parent_output(parent_block, self->key, self->chunk.flags);
-  }
-  output_root_bytes(&output, seek, out, out_len);
-}
-
-void blake3_hasher_reset(blake3_hasher *self) {
-  chunk_state_reset(&self->chunk, self->key, 0);
-  self->cv_stack_len = 0;
-}

external/blake3/blake3.h

@@ -1,86 +0,0 @@
-#ifndef BLAKE3_H
-#define BLAKE3_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#if !defined(BLAKE3_API)
-# if defined(_WIN32) || defined(__CYGWIN__)
-#   if defined(BLAKE3_DLL)
-#     if defined(BLAKE3_DLL_EXPORTS)
-#       define BLAKE3_API __declspec(dllexport)
-#     else
-#       define BLAKE3_API __declspec(dllimport)
-#     endif
-#     define BLAKE3_PRIVATE
-#   else
-#     define BLAKE3_API
-#     define BLAKE3_PRIVATE
-#   endif
-# elif __GNUC__ >= 4
-#   define BLAKE3_API __attribute__((visibility("default")))
-#   define BLAKE3_PRIVATE __attribute__((visibility("hidden")))
-# else
-#   define BLAKE3_API
-#   define BLAKE3_PRIVATE
-# endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define BLAKE3_VERSION_STRING "1.8.2"
-#define BLAKE3_KEY_LEN 32
-#define BLAKE3_OUT_LEN 32
-#define BLAKE3_BLOCK_LEN 64
-#define BLAKE3_CHUNK_LEN 1024
-#define BLAKE3_MAX_DEPTH 54
-
-// This struct is a private implementation detail. It has to be here because
-// it's part of blake3_hasher below.
-typedef struct {
-  uint32_t cv[8];
-  uint64_t chunk_counter;
-  uint8_t buf[BLAKE3_BLOCK_LEN];
-  uint8_t buf_len;
-  uint8_t blocks_compressed;
-  uint8_t flags;
-} blake3_chunk_state;
-
-typedef struct {
-  uint32_t key[8];
-  blake3_chunk_state chunk;
-  uint8_t cv_stack_len;
-  // The stack size is MAX_DEPTH + 1 because we do lazy merging. For example,
-  // with 7 chunks, we have 3 entries in the stack. Adding an 8th chunk
-  // requires a 4th entry, rather than merging everything down to 1, because we
-  // don't know whether more input is coming. This is different from how the
-  // reference implementation does things.
-  uint8_t cv_stack[(BLAKE3_MAX_DEPTH + 1) * BLAKE3_OUT_LEN];
-} blake3_hasher;
-
-BLAKE3_API const char *blake3_version(void);
-BLAKE3_API void blake3_hasher_init(blake3_hasher *self);
-BLAKE3_API void blake3_hasher_init_keyed(blake3_hasher *self,
-                                         const uint8_t key[BLAKE3_KEY_LEN]);
-BLAKE3_API void blake3_hasher_init_derive_key(blake3_hasher *self, const char *context);
-BLAKE3_API void blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context,
-                                                  size_t context_len);
-BLAKE3_API void blake3_hasher_update(blake3_hasher *self, const void *input,
-                                     size_t input_len);
-#if defined(BLAKE3_USE_TBB)
-BLAKE3_API void blake3_hasher_update_tbb(blake3_hasher *self, const void *input,
-                                         size_t input_len);
-#endif // BLAKE3_USE_TBB
-BLAKE3_API void blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out,
-                                       size_t out_len);
-BLAKE3_API void blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek,
-                                            uint8_t *out, size_t out_len);
-BLAKE3_API void blake3_hasher_reset(blake3_hasher *self);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* BLAKE3_H */

external/blake3/blake3_avx2.c

@@ -1,326 +0,0 @@
-#include "blake3_impl.h"
-
-#include <immintrin.h>
-
-#define DEGREE 8
-
-INLINE __m256i loadu(const uint8_t src[32]) {
-  return _mm256_loadu_si256((const __m256i *)src);
-}
-
-INLINE void storeu(__m256i src, uint8_t dest[16]) {
-  _mm256_storeu_si256((__m256i *)dest, src);
-}
-
-INLINE __m256i addv(__m256i a, __m256i b) { return _mm256_add_epi32(a, b); }
-
-// Note that clang-format doesn't like the name "xor" for some reason.
-INLINE __m256i xorv(__m256i a, __m256i b) { return _mm256_xor_si256(a, b); }
-
-INLINE __m256i set1(uint32_t x) { return _mm256_set1_epi32((int32_t)x); }
-
-INLINE __m256i rot16(__m256i x) {
-  return _mm256_shuffle_epi8(
-      x, _mm256_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2,
-                         13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2));
-}
-
-INLINE __m256i rot12(__m256i x) {
-  return _mm256_or_si256(_mm256_srli_epi32(x, 12), _mm256_slli_epi32(x, 32 - 12));
-}
-
-INLINE __m256i rot8(__m256i x) {
-  return _mm256_shuffle_epi8(
-      x, _mm256_set_epi8(12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1,
-                         12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1));
-}
-
-INLINE __m256i rot7(__m256i x) {
-  return _mm256_or_si256(_mm256_srli_epi32(x, 7), _mm256_slli_epi32(x, 32 - 7));
-}
-
-INLINE void round_fn(__m256i v[16], __m256i m[16], size_t r) {
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][0]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][2]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][4]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][6]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[15] = rot16(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot12(v[4]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][1]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][3]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][5]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][7]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[15] = rot8(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot7(v[4]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][8]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][10]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][12]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][14]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot16(v[15]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[4] = rot12(v[4]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][9]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][11]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][13]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][15]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot8(v[15]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-  v[4] = rot7(v[4]);
-}
-
-INLINE void transpose_vecs(__m256i vecs[DEGREE]) {
-  // Interleave 32-bit lanes. The low unpack is lanes 00/11/44/55, and the high
-  // is 22/33/66/77.
-  __m256i ab_0145 = _mm256_unpacklo_epi32(vecs[0], vecs[1]);
-  __m256i ab_2367 = _mm256_unpackhi_epi32(vecs[0], vecs[1]);
-  __m256i cd_0145 = _mm256_unpacklo_epi32(vecs[2], vecs[3]);
-  __m256i cd_2367 = _mm256_unpackhi_epi32(vecs[2], vecs[3]);
-  __m256i ef_0145 = _mm256_unpacklo_epi32(vecs[4], vecs[5]);
-  __m256i ef_2367 = _mm256_unpackhi_epi32(vecs[4], vecs[5]);
-  __m256i gh_0145 = _mm256_unpacklo_epi32(vecs[6], vecs[7]);
-  __m256i gh_2367 = _mm256_unpackhi_epi32(vecs[6], vecs[7]);
-
-  // Interleave 64-bit lanes. The low unpack is lanes 00/22 and the high is
-  // 11/33.
-  __m256i abcd_04 = _mm256_unpacklo_epi64(ab_0145, cd_0145);
-  __m256i abcd_15 = _mm256_unpackhi_epi64(ab_0145, cd_0145);
-  __m256i abcd_26 = _mm256_unpacklo_epi64(ab_2367, cd_2367);
-  __m256i abcd_37 = _mm256_unpackhi_epi64(ab_2367, cd_2367);
-  __m256i efgh_04 = _mm256_unpacklo_epi64(ef_0145, gh_0145);
-  __m256i efgh_15 = _mm256_unpackhi_epi64(ef_0145, gh_0145);
-  __m256i efgh_26 = _mm256_unpacklo_epi64(ef_2367, gh_2367);
-  __m256i efgh_37 = _mm256_unpackhi_epi64(ef_2367, gh_2367);
-
-  // Interleave 128-bit lanes.
-  vecs[0] = _mm256_permute2x128_si256(abcd_04, efgh_04, 0x20);
-  vecs[1] = _mm256_permute2x128_si256(abcd_15, efgh_15, 0x20);
-  vecs[2] = _mm256_permute2x128_si256(abcd_26, efgh_26, 0x20);
-  vecs[3] = _mm256_permute2x128_si256(abcd_37, efgh_37, 0x20);
-  vecs[4] = _mm256_permute2x128_si256(abcd_04, efgh_04, 0x31);
-  vecs[5] = _mm256_permute2x128_si256(abcd_15, efgh_15, 0x31);
-  vecs[6] = _mm256_permute2x128_si256(abcd_26, efgh_26, 0x31);
-  vecs[7] = _mm256_permute2x128_si256(abcd_37, efgh_37, 0x31);
-}
-
-INLINE void transpose_msg_vecs(const uint8_t *const *inputs,
-                               size_t block_offset, __m256i out[16]) {
-  out[0] = loadu(&inputs[0][block_offset + 0 * sizeof(__m256i)]);
-  out[1] = loadu(&inputs[1][block_offset + 0 * sizeof(__m256i)]);
-  out[2] = loadu(&inputs[2][block_offset + 0 * sizeof(__m256i)]);
-  out[3] = loadu(&inputs[3][block_offset + 0 * sizeof(__m256i)]);
-  out[4] = loadu(&inputs[4][block_offset + 0 * sizeof(__m256i)]);
-  out[5] = loadu(&inputs[5][block_offset + 0 * sizeof(__m256i)]);
-  out[6] = loadu(&inputs[6][block_offset + 0 * sizeof(__m256i)]);
-  out[7] = loadu(&inputs[7][block_offset + 0 * sizeof(__m256i)]);
-  out[8] = loadu(&inputs[0][block_offset + 1 * sizeof(__m256i)]);
-  out[9] = loadu(&inputs[1][block_offset + 1 * sizeof(__m256i)]);
-  out[10] = loadu(&inputs[2][block_offset + 1 * sizeof(__m256i)]);
-  out[11] = loadu(&inputs[3][block_offset + 1 * sizeof(__m256i)]);
-  out[12] = loadu(&inputs[4][block_offset + 1 * sizeof(__m256i)]);
-  out[13] = loadu(&inputs[5][block_offset + 1 * sizeof(__m256i)]);
-  out[14] = loadu(&inputs[6][block_offset + 1 * sizeof(__m256i)]);
-  out[15] = loadu(&inputs[7][block_offset + 1 * sizeof(__m256i)]);
-  for (size_t i = 0; i < 8; ++i) {
-    _mm_prefetch((const void *)&inputs[i][block_offset + 256], _MM_HINT_T0);
-  }
-  transpose_vecs(&out[0]);
-  transpose_vecs(&out[8]);
-}
-
-INLINE void load_counters(uint64_t counter, bool increment_counter,
-                          __m256i *out_lo, __m256i *out_hi) {
-  const __m256i mask = _mm256_set1_epi32(-(int32_t)increment_counter);
-  const __m256i add0 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
-  const __m256i add1 = _mm256_and_si256(mask, add0);
-  __m256i l = _mm256_add_epi32(_mm256_set1_epi32((int32_t)counter), add1);
-  __m256i carry = _mm256_cmpgt_epi32(_mm256_xor_si256(add1, _mm256_set1_epi32(0x80000000)), 
-                                     _mm256_xor_si256(   l, _mm256_set1_epi32(0x80000000)));
-  __m256i h = _mm256_sub_epi32(_mm256_set1_epi32((int32_t)(counter >> 32)), carry);
-  *out_lo = l;
-  *out_hi = h;
-}
-
-static
-void blake3_hash8_avx2(const uint8_t *const *inputs, size_t blocks,
-                       const uint32_t key[8], uint64_t counter,
-                       bool increment_counter, uint8_t flags,
-                       uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-  __m256i h_vecs[8] = {
-      set1(key[0]), set1(key[1]), set1(key[2]), set1(key[3]),
-      set1(key[4]), set1(key[5]), set1(key[6]), set1(key[7]),
-  };
-  __m256i counter_low_vec, counter_high_vec;
-  load_counters(counter, increment_counter, &counter_low_vec,
-                &counter_high_vec);
-  uint8_t block_flags = flags | flags_start;
-
-  for (size_t block = 0; block < blocks; block++) {
-    if (block + 1 == blocks) {
-      block_flags |= flags_end;
-    }
-    __m256i block_len_vec = set1(BLAKE3_BLOCK_LEN);
-    __m256i block_flags_vec = set1(block_flags);
-    __m256i msg_vecs[16];
-    transpose_msg_vecs(inputs, block * BLAKE3_BLOCK_LEN, msg_vecs);
-
-    __m256i v[16] = {
-        h_vecs[0],       h_vecs[1],        h_vecs[2],     h_vecs[3],
-        h_vecs[4],       h_vecs[5],        h_vecs[6],     h_vecs[7],
-        set1(IV[0]),     set1(IV[1]),      set1(IV[2]),   set1(IV[3]),
-        counter_low_vec, counter_high_vec, block_len_vec, block_flags_vec,
-    };
-    round_fn(v, msg_vecs, 0);
-    round_fn(v, msg_vecs, 1);
-    round_fn(v, msg_vecs, 2);
-    round_fn(v, msg_vecs, 3);
-    round_fn(v, msg_vecs, 4);
-    round_fn(v, msg_vecs, 5);
-    round_fn(v, msg_vecs, 6);
-    h_vecs[0] = xorv(v[0], v[8]);
-    h_vecs[1] = xorv(v[1], v[9]);
-    h_vecs[2] = xorv(v[2], v[10]);
-    h_vecs[3] = xorv(v[3], v[11]);
-    h_vecs[4] = xorv(v[4], v[12]);
-    h_vecs[5] = xorv(v[5], v[13]);
-    h_vecs[6] = xorv(v[6], v[14]);
-    h_vecs[7] = xorv(v[7], v[15]);
-
-    block_flags = flags;
-  }
-
-  transpose_vecs(h_vecs);
-  storeu(h_vecs[0], &out[0 * sizeof(__m256i)]);
-  storeu(h_vecs[1], &out[1 * sizeof(__m256i)]);
-  storeu(h_vecs[2], &out[2 * sizeof(__m256i)]);
-  storeu(h_vecs[3], &out[3 * sizeof(__m256i)]);
-  storeu(h_vecs[4], &out[4 * sizeof(__m256i)]);
-  storeu(h_vecs[5], &out[5 * sizeof(__m256i)]);
-  storeu(h_vecs[6], &out[6 * sizeof(__m256i)]);
-  storeu(h_vecs[7], &out[7 * sizeof(__m256i)]);
-}
-
-#if !defined(BLAKE3_NO_SSE41)
-void blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
-                            size_t blocks, const uint32_t key[8],
-                            uint64_t counter, bool increment_counter,
-                            uint8_t flags, uint8_t flags_start,
-                            uint8_t flags_end, uint8_t *out);
-#else
-void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                               size_t blocks, const uint32_t key[8],
-                               uint64_t counter, bool increment_counter,
-                               uint8_t flags, uint8_t flags_start,
-                               uint8_t flags_end, uint8_t *out);
-#endif
-
-void blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out) {
-  while (num_inputs >= DEGREE) {
-    blake3_hash8_avx2(inputs, blocks, key, counter, increment_counter, flags,
-                      flags_start, flags_end, out);
-    if (increment_counter) {
-      counter += DEGREE;
-    }
-    inputs += DEGREE;
-    num_inputs -= DEGREE;
-    out = &out[DEGREE * BLAKE3_OUT_LEN];
-  }
-#if !defined(BLAKE3_NO_SSE41)
-  blake3_hash_many_sse41(inputs, num_inputs, blocks, key, counter,
-                         increment_counter, flags, flags_start, flags_end, out);
-#else
-  blake3_hash_many_portable(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end,
-                            out);
-#endif
-}

external/blake3/blake3_c_rust_bindings/Cargo.toml

@@ -1,32 +0,0 @@
-# These are Rust bindings for the C implementation of BLAKE3. As there is a
-# native (and faster) Rust implementation of BLAKE3 provided in this same repo,
-# these bindings are not expected to be used in production. They're intended
-# for testing and benchmarking.
-
-[package]
-name = "blake3_c_rust_bindings"
-version = "0.0.0"
-description = "TESTING ONLY Rust bindings for the BLAKE3 C implementation"
-edition = "2021"
-
-[features]
-# By default the x86-64 build uses assembly implementations. This feature makes
-# the build use the C intrinsics implementations instead.
-prefer_intrinsics = []
-# Activate NEON bindings. We don't currently do any CPU feature detection for
-# this. If this Cargo feature is on, the NEON gets used.
-neon = []
-# Enable TBB-based multithreading.
-tbb = []
-
-[dev-dependencies]
-arrayref = "0.3.5"
-arrayvec = { version = "0.7.0", default-features = false }
-page_size = "0.6.0"
-rand = "0.9.0"
-rand_chacha = "0.9.0"
-reference_impl = { path = "../../reference_impl" }
-
-[build-dependencies]
-cc = "1.0.48"
-ignore = "0.4.23"

external/blake3/blake3_c_rust_bindings/README.md

@@ -1,4 +0,0 @@
-These are Rust bindings for the C implementation of BLAKE3. As there is
-a native Rust implementation of BLAKE3 provided in this same repo, these
-bindings are not expected to be used in production. They're intended for
-testing and benchmarking.

external/blake3/blake3_c_rust_bindings/benches/bench.rs

@@ -1,477 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-
-use arrayref::array_ref;
-use arrayvec::ArrayVec;
-use rand::prelude::*;
-use test::Bencher;
-
-const KIB: usize = 1024;
-const MAX_SIMD_DEGREE: usize = 16;
-
-const BLOCK_LEN: usize = 64;
-const CHUNK_LEN: usize = 1024;
-const OUT_LEN: usize = 32;
-
-// This struct randomizes two things:
-// 1. The actual bytes of input.
-// 2. The page offset the input starts at.
-pub struct RandomInput {
-    buf: Vec<u8>,
-    len: usize,
-    offsets: Vec<usize>,
-    offset_index: usize,
-}
-
-impl RandomInput {
-    pub fn new(b: &mut Bencher, len: usize) -> Self {
-        b.bytes += len as u64;
-        let page_size: usize = page_size::get();
-        let mut buf = vec![0u8; len + page_size];
-        let mut rng = rand::rng();
-        rng.fill_bytes(&mut buf);
-        let mut offsets: Vec<usize> = (0..page_size).collect();
-        offsets.shuffle(&mut rng);
-        Self {
-            buf,
-            len,
-            offsets,
-            offset_index: 0,
-        }
-    }
-
-    pub fn get(&mut self) -> &[u8] {
-        let offset = self.offsets[self.offset_index];
-        self.offset_index += 1;
-        if self.offset_index >= self.offsets.len() {
-            self.offset_index = 0;
-        }
-        &self.buf[offset..][..self.len]
-    }
-}
-
-type CompressInPlaceFn =
-    unsafe extern "C" fn(cv: *mut u32, block: *const u8, block_len: u8, counter: u64, flags: u8);
-
-fn bench_single_compression_fn(b: &mut Bencher, f: CompressInPlaceFn) {
-    let mut state = [1u32; 8];
-    let mut r = RandomInput::new(b, 64);
-    let input = array_ref!(r.get(), 0, 64);
-    b.iter(|| unsafe { f(state.as_mut_ptr(), input.as_ptr(), 64, 0, 0) });
-}
-
-#[bench]
-fn bench_single_compression_portable(b: &mut Bencher) {
-    bench_single_compression_fn(
-        b,
-        blake3_c_rust_bindings::ffi::blake3_compress_in_place_portable,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_single_compression_sse2(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse2_detected() {
-        return;
-    }
-    bench_single_compression_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_compress_in_place_sse2,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_single_compression_sse41(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse41_detected() {
-        return;
-    }
-    bench_single_compression_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_compress_in_place_sse41,
-    );
-}
-
-#[bench]
-fn bench_single_compression_avx512(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::avx512_detected() {
-        return;
-    }
-    bench_single_compression_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_compress_in_place_avx512,
-    );
-}
-
-type HashManyFn = unsafe extern "C" fn(
-    inputs: *const *const u8,
-    num_inputs: usize,
-    blocks: usize,
-    key: *const u32,
-    counter: u64,
-    increment_counter: bool,
-    flags: u8,
-    flags_start: u8,
-    flags_end: u8,
-    out: *mut u8,
-);
-
-fn bench_many_chunks_fn(b: &mut Bencher, f: HashManyFn, degree: usize) {
-    let mut inputs = Vec::new();
-    for _ in 0..degree {
-        inputs.push(RandomInput::new(b, CHUNK_LEN));
-    }
-    b.iter(|| {
-        let input_arrays: ArrayVec<&[u8; CHUNK_LEN], MAX_SIMD_DEGREE> = inputs
-            .iter_mut()
-            .take(degree)
-            .map(|i| array_ref!(i.get(), 0, CHUNK_LEN))
-            .collect();
-        let mut out = [0; MAX_SIMD_DEGREE * OUT_LEN];
-        unsafe {
-            f(
-                input_arrays.as_ptr() as _,
-                input_arrays.len(),
-                CHUNK_LEN / BLOCK_LEN,
-                [0u32; 8].as_ptr(),
-                0,
-                true,
-                0,
-                0,
-                0,
-                out.as_mut_ptr(),
-            )
-        }
-    });
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_chunks_sse2(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse2_detected() {
-        return;
-    }
-    bench_many_chunks_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_sse2,
-        4,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_chunks_sse41(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse41_detected() {
-        return;
-    }
-    bench_many_chunks_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_sse41,
-        4,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_chunks_avx2(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::avx2_detected() {
-        return;
-    }
-    bench_many_chunks_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_avx2,
-        8,
-    );
-}
-
-#[bench]
-fn bench_many_chunks_avx512(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::avx512_detected() {
-        return;
-    }
-    bench_many_chunks_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_avx512,
-        16,
-    );
-}
-
-#[bench]
-#[cfg(feature = "neon")]
-fn bench_many_chunks_neon(b: &mut Bencher) {
-    // When "neon" is on, NEON support is assumed.
-    bench_many_chunks_fn(
-        b,
-        blake3_c_rust_bindings::ffi::neon::blake3_hash_many_neon,
-        4,
-    );
-}
-
-// TODO: When we get const generics we can unify this with the chunks code.
-fn bench_many_parents_fn(b: &mut Bencher, f: HashManyFn, degree: usize) {
-    let mut inputs = Vec::new();
-    for _ in 0..degree {
-        inputs.push(RandomInput::new(b, BLOCK_LEN));
-    }
-    b.iter(|| {
-        let input_arrays: ArrayVec<&[u8; BLOCK_LEN], MAX_SIMD_DEGREE> = inputs
-            .iter_mut()
-            .take(degree)
-            .map(|i| array_ref!(i.get(), 0, BLOCK_LEN))
-            .collect();
-        let mut out = [0; MAX_SIMD_DEGREE * OUT_LEN];
-        unsafe {
-            f(
-                input_arrays.as_ptr() as _,
-                input_arrays.len(),
-                1,
-                [0u32; 8].as_ptr(),
-                0,
-                false,
-                0,
-                0,
-                0,
-                out.as_mut_ptr(),
-            )
-        }
-    });
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_parents_sse2(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse2_detected() {
-        return;
-    }
-    bench_many_parents_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_sse2,
-        4,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_parents_sse41(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::sse41_detected() {
-        return;
-    }
-    bench_many_parents_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_sse41,
-        4,
-    );
-}
-
-#[bench]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn bench_many_parents_avx2(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::avx2_detected() {
-        return;
-    }
-    bench_many_parents_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_avx2,
-        8,
-    );
-}
-
-#[bench]
-fn bench_many_parents_avx512(b: &mut Bencher) {
-    if !blake3_c_rust_bindings::avx512_detected() {
-        return;
-    }
-    bench_many_parents_fn(
-        b,
-        blake3_c_rust_bindings::ffi::x86::blake3_hash_many_avx512,
-        16,
-    );
-}
-
-#[bench]
-#[cfg(feature = "neon")]
-fn bench_many_parents_neon(b: &mut Bencher) {
-    // When "neon" is on, NEON support is assumed.
-    bench_many_parents_fn(
-        b,
-        blake3_c_rust_bindings::ffi::neon::blake3_hash_many_neon,
-        4,
-    );
-}
-
-fn bench_incremental(b: &mut Bencher, len: usize) {
-    let mut input = RandomInput::new(b, len);
-    b.iter(|| {
-        let mut hasher = blake3_c_rust_bindings::Hasher::new();
-        hasher.update(input.get());
-        let mut out = [0; 32];
-        hasher.finalize(&mut out);
-        out
-    });
-}
-
-#[bench]
-fn bench_incremental_0001_block(b: &mut Bencher) {
-    bench_incremental(b, BLOCK_LEN);
-}
-
-#[bench]
-fn bench_incremental_0001_kib(b: &mut Bencher) {
-    bench_incremental(b, 1 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0002_kib(b: &mut Bencher) {
-    bench_incremental(b, 2 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0004_kib(b: &mut Bencher) {
-    bench_incremental(b, 4 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0008_kib(b: &mut Bencher) {
-    bench_incremental(b, 8 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0016_kib(b: &mut Bencher) {
-    bench_incremental(b, 16 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0032_kib(b: &mut Bencher) {
-    bench_incremental(b, 32 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0064_kib(b: &mut Bencher) {
-    bench_incremental(b, 64 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0128_kib(b: &mut Bencher) {
-    bench_incremental(b, 128 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0256_kib(b: &mut Bencher) {
-    bench_incremental(b, 256 * KIB);
-}
-
-#[bench]
-fn bench_incremental_0512_kib(b: &mut Bencher) {
-    bench_incremental(b, 512 * KIB);
-}
-
-#[bench]
-fn bench_incremental_1024_kib(b: &mut Bencher) {
-    bench_incremental(b, 1024 * KIB);
-}
-
-#[cfg(feature = "tbb")]
-fn bench_tbb(b: &mut Bencher, len: usize) {
-    let mut input = RandomInput::new(b, len);
-    b.iter(|| {
-        let mut hasher = blake3_c_rust_bindings::Hasher::new();
-        hasher.update_tbb(input.get());
-        let mut out = [0; 32];
-        hasher.finalize(&mut out);
-        out
-    });
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0001_block(b: &mut Bencher) {
-    bench_tbb(b, BLOCK_LEN);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0001_kib(b: &mut Bencher) {
-    bench_tbb(b, 1 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0002_kib(b: &mut Bencher) {
-    bench_tbb(b, 2 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0004_kib(b: &mut Bencher) {
-    bench_tbb(b, 4 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0008_kib(b: &mut Bencher) {
-    bench_tbb(b, 8 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0016_kib(b: &mut Bencher) {
-    bench_tbb(b, 16 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0032_kib(b: &mut Bencher) {
-    bench_tbb(b, 32 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0064_kib(b: &mut Bencher) {
-    bench_tbb(b, 64 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0128_kib(b: &mut Bencher) {
-    bench_tbb(b, 128 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0256_kib(b: &mut Bencher) {
-    bench_tbb(b, 256 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_0512_kib(b: &mut Bencher) {
-    bench_tbb(b, 512 * KIB);
-}
-
-#[bench]
-#[cfg(feature = "tbb")]
-fn bench_tbb_1024_kib(b: &mut Bencher) {
-    bench_tbb(b, 1024 * KIB);
-}
-
-// This checks that update() splits up its input in increasing powers of 2, so
-// that it can recover a high degree of parallelism when the number of bytes
-// hashed so far is uneven. The performance of this benchmark should be
-// reasonably close to bench_incremental_0064_kib, within 80% or so. When we
-// had a bug in this logic (https://github.com/BLAKE3-team/BLAKE3/issues/69),
-// performance was less than half.
-#[bench]
-fn bench_two_updates(b: &mut Bencher) {
-    let len = 65536;
-    let mut input = RandomInput::new(b, len);
-    b.iter(|| {
-        let mut hasher = blake3_c_rust_bindings::Hasher::new();
-        let input = input.get();
-        hasher.update(&input[..1]);
-        hasher.update(&input[1..]);
-        let mut out = [0; 32];
-        hasher.finalize(&mut out);
-        out
-    });
-}

external/blake3/blake3_c_rust_bindings/build.rs

@@ -1,253 +0,0 @@
-use std::env;
-
-fn defined(var: &str) -> bool {
-    env::var_os(var).is_some()
-}
-
-fn target_components() -> Vec<String> {
-    let target = env::var("TARGET").unwrap();
-    target.split("-").map(|s| s.to_string()).collect()
-}
-
-fn is_x86_64() -> bool {
-    target_components()[0] == "x86_64"
-}
-
-fn is_windows_target() -> bool {
-    env::var("CARGO_CFG_TARGET_OS").unwrap() == "windows"
-}
-
-fn use_msvc_asm() -> bool {
-    const MSVC_NAMES: &[&str] = &["", "cl", "cl.exe"];
-    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
-    let target_env = env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
-    let target_windows_msvc = target_os == "windows" && target_env == "msvc";
-    let host_triple = env::var("HOST").unwrap_or_default();
-    let target_triple = env::var("TARGET").unwrap_or_default();
-    let cross_compiling = host_triple != target_triple;
-    let cc = env::var("CC").unwrap_or_default().to_ascii_lowercase();
-    if !target_windows_msvc {
-        // We are not building for Windows with the MSVC toolchain.
-        false
-    } else if !cross_compiling && MSVC_NAMES.contains(&&*cc) {
-        // We are building on Windows with the MSVC toolchain (and not cross-compiling for another architecture or target).
-        true
-    } else {
-        // We are cross-compiling to Windows with the MSVC toolchain.
-        let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
-        let target_vendor = env::var("CARGO_CFG_TARGET_VENDOR").unwrap_or_default();
-        let cc = env::var(format!("CC_{target_arch}_{target_vendor}_windows_msvc"))
-            .unwrap_or_default()
-            .to_ascii_lowercase();
-        // Check if we are using the MSVC compiler.
-        MSVC_NAMES.contains(&&*cc)
-    }
-}
-
-fn is_x86_32() -> bool {
-    let arch = &target_components()[0];
-    arch == "i386" || arch == "i586" || arch == "i686"
-}
-
-fn is_armv7() -> bool {
-    target_components()[0] == "armv7"
-}
-
-fn is_aarch64() -> bool {
-    target_components()[0] == "aarch64"
-}
-
-// Windows targets may be using the MSVC toolchain or the GNU toolchain. The
-// right compiler flags to use depend on the toolchain. (And we don't want to
-// use flag_if_supported, because we don't want features to be silently
-// disabled by old compilers.)
-fn is_windows_msvc() -> bool {
-    // Some targets are only two components long, so check in steps.
-    target_components()[1] == "pc"
-        && target_components()[2] == "windows"
-        && target_components()[3] == "msvc"
-}
-
-fn new_build() -> cc::Build {
-    let mut build = cc::Build::new();
-    if !is_windows_msvc() {
-        build.flag("-std=c11");
-    }
-    build
-}
-
-fn new_cpp_build() -> cc::Build {
-    let mut build = cc::Build::new();
-    build.cpp(true);
-    if is_windows_msvc() {
-        build.flag("/std:c++20");
-        build.flag("/EHs-c-");
-        build.flag("/GR-");
-    } else {
-        build.flag("-std=c++20");
-        build.flag("-fno-exceptions");
-        build.flag("-fno-rtti");
-    }
-    build
-}
-
-fn c_dir_path(filename: &str) -> String {
-    // The `cross` tool doesn't support reading files in parent directories. As a hacky workaround
-    // in `cross_test.sh`, we move the c/ directory around and set BLAKE3_C_DIR_OVERRIDE. Regular
-    // building and testing doesn't require this.
-    if let Ok(c_dir_override) = env::var("BLAKE3_C_DIR_OVERRIDE") {
-        c_dir_override + "/" + filename
-    } else {
-        "../".to_string() + filename
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut base_build = new_build();
-    base_build.file(c_dir_path("blake3.c"));
-    base_build.file(c_dir_path("blake3_dispatch.c"));
-    base_build.file(c_dir_path("blake3_portable.c"));
-    if cfg!(feature = "tbb") {
-        base_build.define("BLAKE3_USE_TBB", "1");
-    }
-    base_build.compile("blake3_base");
-
-    if cfg!(feature = "tbb") {
-        let mut tbb_build = new_cpp_build();
-        tbb_build.define("BLAKE3_USE_TBB", "1");
-        tbb_build.file(c_dir_path("blake3_tbb.cpp"));
-        tbb_build.compile("blake3_tbb");
-        println!("cargo::rustc-link-lib=tbb");
-    }
-
-    if is_x86_64() && !defined("CARGO_FEATURE_PREFER_INTRINSICS") {
-        // On 64-bit, use the assembly implementations, unless the
-        // "prefer_intrinsics" feature is enabled.
-        if is_windows_target() {
-            if use_msvc_asm() {
-                let mut build = new_build();
-                build.file(c_dir_path("blake3_sse2_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_sse41_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_avx2_x86-64_windows_msvc.asm"));
-                build.file(c_dir_path("blake3_avx512_x86-64_windows_msvc.asm"));
-                build.compile("blake3_asm");
-            } else {
-                let mut build = new_build();
-                build.file(c_dir_path("blake3_sse2_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_sse41_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_avx2_x86-64_windows_gnu.S"));
-                build.file(c_dir_path("blake3_avx512_x86-64_windows_gnu.S"));
-                build.compile("blake3_asm");
-            }
-        } else {
-            // All non-Windows implementations are assumed to support
-            // Linux-style assembly. These files do contain a small
-            // explicit workaround for macOS also.
-            let mut build = new_build();
-            build.file(c_dir_path("blake3_sse2_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_sse41_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_avx2_x86-64_unix.S"));
-            build.file(c_dir_path("blake3_avx512_x86-64_unix.S"));
-            build.compile("blake3_asm");
-        }
-    } else if is_x86_64() || is_x86_32() {
-        // Assembly implementations are only for 64-bit. On 32-bit, or if
-        // the "prefer_intrinsics" feature is enabled, use the
-        // intrinsics-based C implementations. These each need to be
-        // compiled separately, with the corresponding instruction set
-        // extension explicitly enabled in the compiler.
-
-        let mut sse2_build = new_build();
-        sse2_build.file(c_dir_path("blake3_sse2.c"));
-        if is_windows_msvc() {
-            // /arch:SSE2 is the default on x86 and undefined on x86_64:
-            // https://docs.microsoft.com/en-us/cpp/build/reference/arch-x86
-            // It also includes SSE4.1 intrinsics:
-            // https://stackoverflow.com/a/32183222/823869
-        } else {
-            sse2_build.flag("-msse2");
-        }
-        sse2_build.compile("blake3_sse2");
-
-        let mut sse41_build = new_build();
-        sse41_build.file(c_dir_path("blake3_sse41.c"));
-        if is_windows_msvc() {
-            // /arch:SSE2 is the default on x86 and undefined on x86_64:
-            // https://docs.microsoft.com/en-us/cpp/build/reference/arch-x86
-            // It also includes SSE4.1 intrinsics:
-            // https://stackoverflow.com/a/32183222/823869
-        } else {
-            sse41_build.flag("-msse4.1");
-        }
-        sse41_build.compile("blake3_sse41");
-
-        let mut avx2_build = new_build();
-        avx2_build.file(c_dir_path("blake3_avx2.c"));
-        if is_windows_msvc() {
-            avx2_build.flag("/arch:AVX2");
-        } else {
-            avx2_build.flag("-mavx2");
-        }
-        avx2_build.compile("blake3_avx2");
-
-        let mut avx512_build = new_build();
-        avx512_build.file(c_dir_path("blake3_avx512.c"));
-        if is_windows_msvc() {
-            // Note that a lot of versions of MSVC don't support /arch:AVX512,
-            // and they'll discard it with a warning, hopefully leading to a
-            // build error.
-            avx512_build.flag("/arch:AVX512");
-        } else {
-            avx512_build.flag("-mavx512f");
-            avx512_build.flag("-mavx512vl");
-        }
-        avx512_build.compile("blake3_avx512");
-    }
-
-    // We only build NEON code here if
-    // 1) it's requested
-    // and 2) the root crate is not already building it.
-    // The only time this will really happen is if you build this
-    // crate by hand with the "neon" feature for some reason.
-    //
-    // In addition, 3) if the target is aarch64, NEON is on by default.
-    if defined("CARGO_FEATURE_NEON") || is_aarch64() {
-        let mut neon_build = new_build();
-        neon_build.file(c_dir_path("blake3_neon.c"));
-        // ARMv7 platforms that support NEON generally need the following
-        // flags. AArch64 supports NEON by default and does not support -mpfu.
-        if is_armv7() {
-            neon_build.flag("-mfpu=neon-vfpv4");
-            neon_build.flag("-mfloat-abi=hard");
-        }
-        neon_build.compile("blake3_neon");
-    }
-
-    // The `cc` crate does not automatically emit rerun-if directives for the
-    // environment variables it supports, in particular for $CC. We expect to
-    // do a lot of benchmarking across different compilers, so we explicitly
-    // add the variables that we're likely to need.
-    println!("cargo:rerun-if-env-changed=CC");
-    println!("cargo:rerun-if-env-changed=CFLAGS");
-
-    // Ditto for source files, though these shouldn't change as often. `ignore::Walk` respects
-    // .gitignore, so this doesn't traverse target/.
-    for result in ignore::Walk::new("..") {
-        let result = result?;
-        let path = result.path();
-        if path.is_file() {
-            println!("cargo:rerun-if-changed={}", path.to_str().unwrap());
-        }
-    }
-
-    // When compiling with clang-cl for windows, it adds .asm files to the root
-    // which we need to delete so cargo doesn't get angry
-    if is_windows_target() && !use_msvc_asm() {
-        let _ = std::fs::remove_file("blake3_avx2_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_avx512_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_sse2_x86-64_windows_gnu.asm");
-        let _ = std::fs::remove_file("blake3_sse41_x86-64_windows_gnu.asm");
-    }
-
-    Ok(())
-}

external/blake3/blake3_c_rust_bindings/cross_test.sh

@@ -1,31 +0,0 @@
-#! /usr/bin/env bash
-
-# This hacky script works around the fact that `cross test` does not support
-# path dependencies. (It uses a docker shared folder to let the guest access
-# project files, so parent directories aren't available.) Solve this problem by
-# copying the entire project to a temp dir and rearranging paths to put "c" and
-# "reference_impl" underneath "blake3_c_rust_bindings", so that everything is
-# accessible. Hopefully this will just run on CI forever and no one will ever
-# read this and discover my deep shame.
-
-set -e -u -o pipefail
-
-project_root="$(realpath "$(dirname "$BASH_SOURCE")/../..")"
-tmpdir="$(mktemp -d)"
-echo "Running cross tests in $tmpdir"
-cd "$tmpdir"
-git clone "$project_root" blake3
-mv blake3/c/blake3_c_rust_bindings .
-mv blake3/reference_impl blake3_c_rust_bindings
-mv blake3/c blake3_c_rust_bindings
-cd blake3_c_rust_bindings
-sed -i 's|reference_impl = { path = "../../reference_impl" }|reference_impl = { path = "reference_impl" }|' Cargo.toml
-
-export BLAKE3_C_DIR_OVERRIDE="./c"
-cat > Cross.toml << EOF
-[build.env]
-passthrough = [
-    "BLAKE3_C_DIR_OVERRIDE",
-]
-EOF
-cross test "$@"

external/blake3/blake3_c_rust_bindings/src/lib.rs

@@ -1,333 +0,0 @@
-//! These are Rust bindings for the C implementation of BLAKE3. As there is a
-//! native (and faster) Rust implementation of BLAKE3 provided in this same
-//! repo, these bindings are not expected to be used in production. They're
-//! intended for testing and benchmarking.
-
-use std::ffi::{c_void, CString};
-use std::mem::MaybeUninit;
-
-#[cfg(test)]
-mod test;
-
-pub const BLOCK_LEN: usize = 64;
-pub const CHUNK_LEN: usize = 1024;
-pub const OUT_LEN: usize = 32;
-
-// Feature detection functions for tests and benchmarks. Note that the C code
-// does its own feature detection in blake3_dispatch.c.
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn sse2_detected() -> bool {
-    is_x86_feature_detected!("sse2")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn sse41_detected() -> bool {
-    is_x86_feature_detected!("sse4.1")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn avx2_detected() -> bool {
-    is_x86_feature_detected!("avx2")
-}
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn avx512_detected() -> bool {
-    is_x86_feature_detected!("avx512f") && is_x86_feature_detected!("avx512vl")
-}
-
-#[derive(Clone)]
-pub struct Hasher(ffi::blake3_hasher);
-
-impl Hasher {
-    pub fn new() -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init(c_state.as_mut_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_keyed(key: &[u8; 32]) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init_keyed(c_state.as_mut_ptr(), key.as_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_derive_key(context: &str) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        let context_c_string = CString::new(context).expect("valid C string, no null bytes");
-        unsafe {
-            ffi::blake3_hasher_init_derive_key(c_state.as_mut_ptr(), context_c_string.as_ptr());
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn new_derive_key_raw(context: &[u8]) -> Self {
-        let mut c_state = MaybeUninit::uninit();
-        unsafe {
-            ffi::blake3_hasher_init_derive_key_raw(
-                c_state.as_mut_ptr(),
-                context.as_ptr() as *const _,
-                context.len(),
-            );
-            Self(c_state.assume_init())
-        }
-    }
-
-    pub fn update(&mut self, input: &[u8]) {
-        unsafe {
-            ffi::blake3_hasher_update(&mut self.0, input.as_ptr() as *const c_void, input.len());
-        }
-    }
-
-    #[cfg(feature = "tbb")]
-    pub fn update_tbb(&mut self, input: &[u8]) {
-        unsafe {
-            ffi::blake3_hasher_update_tbb(
-                &mut self.0,
-                input.as_ptr() as *const c_void,
-                input.len(),
-            );
-        }
-    }
-
-    pub fn finalize(&self, output: &mut [u8]) {
-        unsafe {
-            ffi::blake3_hasher_finalize(&self.0, output.as_mut_ptr(), output.len());
-        }
-    }
-
-    pub fn finalize_seek(&self, seek: u64, output: &mut [u8]) {
-        unsafe {
-            ffi::blake3_hasher_finalize_seek(&self.0, seek, output.as_mut_ptr(), output.len());
-        }
-    }
-
-    pub fn reset(&mut self) {
-        unsafe {
-            ffi::blake3_hasher_reset(&mut self.0);
-        }
-    }
-}
-
-pub mod ffi {
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct blake3_chunk_state {
-        pub cv: [u32; 8usize],
-        pub chunk_counter: u64,
-        pub buf: [u8; 64usize],
-        pub buf_len: u8,
-        pub blocks_compressed: u8,
-        pub flags: u8,
-    }
-
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct blake3_hasher {
-        pub key: [u32; 8usize],
-        pub chunk: blake3_chunk_state,
-        pub cv_stack_len: u8,
-        pub cv_stack: [u8; 1728usize],
-    }
-
-    extern "C" {
-        // public interface
-        pub fn blake3_hasher_init(self_: *mut blake3_hasher);
-        pub fn blake3_hasher_init_keyed(self_: *mut blake3_hasher, key: *const u8);
-        pub fn blake3_hasher_init_derive_key(
-            self_: *mut blake3_hasher,
-            context: *const ::std::os::raw::c_char,
-        );
-        pub fn blake3_hasher_init_derive_key_raw(
-            self_: *mut blake3_hasher,
-            context: *const ::std::os::raw::c_void,
-            context_len: usize,
-        );
-        pub fn blake3_hasher_update(
-            self_: *mut blake3_hasher,
-            input: *const ::std::os::raw::c_void,
-            input_len: usize,
-        );
-        #[cfg(feature = "tbb")]
-        pub fn blake3_hasher_update_tbb(
-            self_: *mut blake3_hasher,
-            input: *const ::std::os::raw::c_void,
-            input_len: usize,
-        );
-        pub fn blake3_hasher_finalize(self_: *const blake3_hasher, out: *mut u8, out_len: usize);
-        pub fn blake3_hasher_finalize_seek(
-            self_: *const blake3_hasher,
-            seek: u64,
-            out: *mut u8,
-            out_len: usize,
-        );
-        pub fn blake3_hasher_reset(self_: *mut blake3_hasher);
-
-        // portable low-level functions
-        pub fn blake3_compress_in_place_portable(
-            cv: *mut u32,
-            block: *const u8,
-            block_len: u8,
-            counter: u64,
-            flags: u8,
-        );
-        pub fn blake3_compress_xof_portable(
-            cv: *const u32,
-            block: *const u8,
-            block_len: u8,
-            counter: u64,
-            flags: u8,
-            out: *mut u8,
-        );
-        pub fn blake3_hash_many_portable(
-            inputs: *const *const u8,
-            num_inputs: usize,
-            blocks: usize,
-            key: *const u32,
-            counter: u64,
-            increment_counter: bool,
-            flags: u8,
-            flags_start: u8,
-            flags_end: u8,
-            out: *mut u8,
-        );
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    pub mod x86 {
-        extern "C" {
-            // SSE2 low level functions
-            pub fn blake3_compress_in_place_sse2(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_compress_xof_sse2(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_hash_many_sse2(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // SSE4.1 low level functions
-            pub fn blake3_compress_in_place_sse41(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_compress_xof_sse41(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_hash_many_sse41(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // AVX2 low level functions
-            pub fn blake3_hash_many_avx2(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-
-            // AVX-512 low level functions
-            pub fn blake3_compress_xof_avx512(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-            );
-            pub fn blake3_compress_in_place_avx512(
-                cv: *mut u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-            );
-            pub fn blake3_hash_many_avx512(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-            #[cfg(unix)]
-            pub fn blake3_xof_many_avx512(
-                cv: *const u32,
-                block: *const u8,
-                block_len: u8,
-                counter: u64,
-                flags: u8,
-                out: *mut u8,
-                outblocks: usize,
-            );
-        }
-    }
-
-    #[cfg(feature = "neon")]
-    pub mod neon {
-        extern "C" {
-            // NEON low level functions
-            pub fn blake3_hash_many_neon(
-                inputs: *const *const u8,
-                num_inputs: usize,
-                blocks: usize,
-                key: *const u32,
-                counter: u64,
-                increment_counter: bool,
-                flags: u8,
-                flags_start: u8,
-                flags_end: u8,
-                out: *mut u8,
-            );
-        }
-    }
-}

external/blake3/blake3_c_rust_bindings/src/test.rs

@@ -1,696 +0,0 @@
-// Most of this code is duplicated from the root `blake3` crate. Perhaps we
-// could share more of it in the future.
-
-use crate::{BLOCK_LEN, CHUNK_LEN, OUT_LEN};
-use arrayref::{array_mut_ref, array_ref};
-use arrayvec::ArrayVec;
-use core::usize;
-use rand::prelude::*;
-
-const CHUNK_START: u8 = 1 << 0;
-const CHUNK_END: u8 = 1 << 1;
-const PARENT: u8 = 1 << 2;
-const ROOT: u8 = 1 << 3;
-const KEYED_HASH: u8 = 1 << 4;
-// const DERIVE_KEY_CONTEXT: u8 = 1 << 5;
-// const DERIVE_KEY_MATERIAL: u8 = 1 << 6;
-
-// Interesting input lengths to run tests on.
-pub const TEST_CASES: &[usize] = &[
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    BLOCK_LEN - 1,
-    BLOCK_LEN,
-    BLOCK_LEN + 1,
-    2 * BLOCK_LEN - 1,
-    2 * BLOCK_LEN,
-    2 * BLOCK_LEN + 1,
-    CHUNK_LEN - 1,
-    CHUNK_LEN,
-    CHUNK_LEN + 1,
-    2 * CHUNK_LEN,
-    2 * CHUNK_LEN + 1,
-    3 * CHUNK_LEN,
-    3 * CHUNK_LEN + 1,
-    4 * CHUNK_LEN,
-    4 * CHUNK_LEN + 1,
-    5 * CHUNK_LEN,
-    5 * CHUNK_LEN + 1,
-    6 * CHUNK_LEN,
-    6 * CHUNK_LEN + 1,
-    7 * CHUNK_LEN,
-    7 * CHUNK_LEN + 1,
-    8 * CHUNK_LEN,
-    8 * CHUNK_LEN + 1,
-    16 * CHUNK_LEN,  // AVX512's bandwidth
-    31 * CHUNK_LEN,  // 16 + 8 + 4 + 2 + 1
-    100 * CHUNK_LEN, // subtrees larger than MAX_SIMD_DEGREE chunks
-];
-
-pub const TEST_CASES_MAX: usize = 100 * CHUNK_LEN;
-
-// There's a test to make sure these two are equal below.
-pub const TEST_KEY: [u8; 32] = *b"whats the Elvish word for friend";
-pub const TEST_KEY_WORDS: [u32; 8] = [
-    1952540791, 1752440947, 1816469605, 1752394102, 1919907616, 1868963940, 1919295602, 1684956521,
-];
-
-// Paint the input with a repeating byte pattern. We use a cycle length of 251,
-// because that's the largest prime number less than 256. This makes it
-// unlikely to swapping any two adjacent input blocks or chunks will give the
-// same answer.
-fn paint_test_input(buf: &mut [u8]) {
-    for (i, b) in buf.iter_mut().enumerate() {
-        *b = (i % 251) as u8;
-    }
-}
-
-#[inline(always)]
-fn le_bytes_from_words_32(words: &[u32; 8]) -> [u8; 32] {
-    let mut out = [0; 32];
-    *array_mut_ref!(out, 0 * 4, 4) = words[0].to_le_bytes();
-    *array_mut_ref!(out, 1 * 4, 4) = words[1].to_le_bytes();
-    *array_mut_ref!(out, 2 * 4, 4) = words[2].to_le_bytes();
-    *array_mut_ref!(out, 3 * 4, 4) = words[3].to_le_bytes();
-    *array_mut_ref!(out, 4 * 4, 4) = words[4].to_le_bytes();
-    *array_mut_ref!(out, 5 * 4, 4) = words[5].to_le_bytes();
-    *array_mut_ref!(out, 6 * 4, 4) = words[6].to_le_bytes();
-    *array_mut_ref!(out, 7 * 4, 4) = words[7].to_le_bytes();
-    out
-}
-
-type CompressInPlaceFn =
-    unsafe extern "C" fn(cv: *mut u32, block: *const u8, block_len: u8, counter: u64, flags: u8);
-
-type CompressXofFn = unsafe extern "C" fn(
-    cv: *const u32,
-    block: *const u8,
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-    out: *mut u8,
-);
-
-// A shared helper function for platform-specific tests.
-pub fn test_compress_fn(compress_in_place_fn: CompressInPlaceFn, compress_xof_fn: CompressXofFn) {
-    let initial_state = TEST_KEY_WORDS;
-    let block_len: u8 = 61;
-    let mut block = [0; BLOCK_LEN];
-    paint_test_input(&mut block[..block_len as usize]);
-    // Use a counter with set bits in both 32-bit words.
-    let counter = (5u64 << 32) + 6;
-    let flags = CHUNK_END | ROOT | KEYED_HASH;
-
-    let mut portable_out = [0; 64];
-    unsafe {
-        crate::ffi::blake3_compress_xof_portable(
-            initial_state.as_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-            portable_out.as_mut_ptr(),
-        );
-    }
-
-    let mut test_state = initial_state;
-    unsafe {
-        compress_in_place_fn(
-            test_state.as_mut_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-        )
-    };
-    let test_state_bytes = le_bytes_from_words_32(&test_state);
-    let mut test_xof = [0; 64];
-    unsafe {
-        compress_xof_fn(
-            initial_state.as_ptr(),
-            block.as_ptr(),
-            block_len,
-            counter,
-            flags,
-            test_xof.as_mut_ptr(),
-        )
-    };
-
-    assert_eq!(&portable_out[..32], &test_state_bytes[..]);
-    assert_eq!(&portable_out[..], &test_xof[..]);
-}
-
-// Testing the portable implementation against itself is circular, but why not.
-#[test]
-fn test_compress_portable() {
-    test_compress_fn(
-        crate::ffi::blake3_compress_in_place_portable,
-        crate::ffi::blake3_compress_xof_portable,
-    );
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_compress_sse2() {
-    if !crate::sse2_detected() {
-        return;
-    }
-    test_compress_fn(
-        crate::ffi::x86::blake3_compress_in_place_sse2,
-        crate::ffi::x86::blake3_compress_xof_sse2,
-    );
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_compress_sse41() {
-    if !crate::sse41_detected() {
-        return;
-    }
-    test_compress_fn(
-        crate::ffi::x86::blake3_compress_in_place_sse41,
-        crate::ffi::x86::blake3_compress_xof_sse41,
-    );
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_compress_avx512() {
-    if !crate::avx512_detected() {
-        return;
-    }
-    test_compress_fn(
-        crate::ffi::x86::blake3_compress_in_place_avx512,
-        crate::ffi::x86::blake3_compress_xof_avx512,
-    );
-}
-
-type HashManyFn = unsafe extern "C" fn(
-    inputs: *const *const u8,
-    num_inputs: usize,
-    blocks: usize,
-    key: *const u32,
-    counter: u64,
-    increment_counter: bool,
-    flags: u8,
-    flags_start: u8,
-    flags_end: u8,
-    out: *mut u8,
-);
-
-// A shared helper function for platform-specific tests.
-pub fn test_hash_many_fn(hash_many_fn: HashManyFn) {
-    // Test a few different initial counter values.
-    // - 0: The base case.
-    // - u32::MAX: The low word of the counter overflows for all inputs except the first.
-    // - i32::MAX: *No* overflow. But carry bugs in tricky SIMD code can screw this up, if you XOR
-    //   when you're supposed to ANDNOT...
-    let initial_counters = [0, u32::MAX as u64, i32::MAX as u64];
-    for counter in initial_counters {
-        dbg!(counter);
-
-        // 31 (16 + 8 + 4 + 2 + 1) inputs
-        const NUM_INPUTS: usize = 31;
-        let mut input_buf = [0; CHUNK_LEN * NUM_INPUTS];
-        crate::test::paint_test_input(&mut input_buf);
-
-        // First hash chunks.
-        let mut chunks = ArrayVec::<&[u8; CHUNK_LEN], NUM_INPUTS>::new();
-        for i in 0..NUM_INPUTS {
-            chunks.push(array_ref!(input_buf, i * CHUNK_LEN, CHUNK_LEN));
-        }
-        let mut portable_chunks_out = [0; NUM_INPUTS * OUT_LEN];
-        unsafe {
-            crate::ffi::blake3_hash_many_portable(
-                chunks.as_ptr() as _,
-                chunks.len(),
-                CHUNK_LEN / BLOCK_LEN,
-                TEST_KEY_WORDS.as_ptr(),
-                counter,
-                true,
-                KEYED_HASH,
-                CHUNK_START,
-                CHUNK_END,
-                portable_chunks_out.as_mut_ptr(),
-            );
-        }
-
-        let mut test_chunks_out = [0; NUM_INPUTS * OUT_LEN];
-        unsafe {
-            hash_many_fn(
-                chunks.as_ptr() as _,
-                chunks.len(),
-                CHUNK_LEN / BLOCK_LEN,
-                TEST_KEY_WORDS.as_ptr(),
-                counter,
-                true,
-                KEYED_HASH,
-                CHUNK_START,
-                CHUNK_END,
-                test_chunks_out.as_mut_ptr(),
-            );
-        }
-        for n in 0..NUM_INPUTS {
-            dbg!(n);
-            assert_eq!(
-                &portable_chunks_out[n * OUT_LEN..][..OUT_LEN],
-                &test_chunks_out[n * OUT_LEN..][..OUT_LEN]
-            );
-        }
-
-        // Then hash parents.
-        let mut parents = ArrayVec::<&[u8; 2 * OUT_LEN], NUM_INPUTS>::new();
-        for i in 0..NUM_INPUTS {
-            parents.push(array_ref!(input_buf, i * 2 * OUT_LEN, 2 * OUT_LEN));
-        }
-        let mut portable_parents_out = [0; NUM_INPUTS * OUT_LEN];
-        unsafe {
-            crate::ffi::blake3_hash_many_portable(
-                parents.as_ptr() as _,
-                parents.len(),
-                1,
-                TEST_KEY_WORDS.as_ptr(),
-                counter,
-                false,
-                KEYED_HASH | PARENT,
-                0,
-                0,
-                portable_parents_out.as_mut_ptr(),
-            );
-        }
-
-        let mut test_parents_out = [0; NUM_INPUTS * OUT_LEN];
-        unsafe {
-            hash_many_fn(
-                parents.as_ptr() as _,
-                parents.len(),
-                1,
-                TEST_KEY_WORDS.as_ptr(),
-                counter,
-                false,
-                KEYED_HASH | PARENT,
-                0,
-                0,
-                test_parents_out.as_mut_ptr(),
-            );
-        }
-        for n in 0..NUM_INPUTS {
-            dbg!(n);
-            assert_eq!(
-                &portable_parents_out[n * OUT_LEN..][..OUT_LEN],
-                &test_parents_out[n * OUT_LEN..][..OUT_LEN]
-            );
-        }
-    }
-}
-
-// Testing the portable implementation against itself is circular, but why not.
-#[test]
-fn test_hash_many_portable() {
-    test_hash_many_fn(crate::ffi::blake3_hash_many_portable);
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_hash_many_sse2() {
-    if !crate::sse2_detected() {
-        return;
-    }
-    test_hash_many_fn(crate::ffi::x86::blake3_hash_many_sse2);
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_hash_many_sse41() {
-    if !crate::sse41_detected() {
-        return;
-    }
-    test_hash_many_fn(crate::ffi::x86::blake3_hash_many_sse41);
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_hash_many_avx2() {
-    if !crate::avx2_detected() {
-        return;
-    }
-    test_hash_many_fn(crate::ffi::x86::blake3_hash_many_avx2);
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_hash_many_avx512() {
-    if !crate::avx512_detected() {
-        return;
-    }
-    test_hash_many_fn(crate::ffi::x86::blake3_hash_many_avx512);
-}
-
-#[test]
-#[cfg(feature = "neon")]
-fn test_hash_many_neon() {
-    test_hash_many_fn(crate::ffi::neon::blake3_hash_many_neon);
-}
-
-#[allow(unused)]
-type XofManyFunction = unsafe extern "C" fn(
-    cv: *const u32,
-    block: *const u8,
-    block_len: u8,
-    counter: u64,
-    flags: u8,
-    out: *mut u8,
-    outblocks: usize,
-);
-
-// A shared helper function for platform-specific tests.
-#[allow(unused)]
-pub fn test_xof_many_fn(xof_many_function: XofManyFunction) {
-    let mut block = [0; BLOCK_LEN];
-    let block_len = 42;
-    crate::test::paint_test_input(&mut block[..block_len]);
-    let cv = [40, 41, 42, 43, 44, 45, 46, 47];
-    let flags = KEYED_HASH;
-
-    // Test a few different initial counter values.
-    // - 0: The base case.
-    // - u32::MAX: The low word of the counter overflows for all inputs except the first.
-    // - i32::MAX: *No* overflow. But carry bugs in tricky SIMD code can screw this up, if you XOR
-    //   when you're supposed to ANDNOT...
-    let initial_counters = [0, u32::MAX as u64, i32::MAX as u64];
-    for counter in initial_counters {
-        dbg!(counter);
-
-        // 31 (16 + 8 + 4 + 2 + 1) outputs
-        const OUTPUT_SIZE: usize = 31 * BLOCK_LEN;
-
-        let mut portable_out = [0u8; OUTPUT_SIZE];
-        for (i, out_block) in portable_out.chunks_exact_mut(BLOCK_LEN).enumerate() {
-            unsafe {
-                crate::ffi::blake3_compress_xof_portable(
-                    cv.as_ptr(),
-                    block.as_ptr(),
-                    block_len as u8,
-                    counter + i as u64,
-                    flags,
-                    out_block.as_mut_ptr(),
-                );
-            }
-        }
-
-        let mut test_out = [0u8; OUTPUT_SIZE];
-        unsafe {
-            xof_many_function(
-                cv.as_ptr(),
-                block.as_ptr(),
-                block_len as u8,
-                counter,
-                flags,
-                test_out.as_mut_ptr(),
-                OUTPUT_SIZE / BLOCK_LEN,
-            );
-        }
-
-        assert_eq!(portable_out, test_out);
-    }
-
-    // Test that xof_many doesn't write more blocks than requested. Note that the current assembly
-    // implementation always outputs at least one block, so we don't test the zero case.
-    for block_count in 1..=32 {
-        let mut array = [0; BLOCK_LEN * 33];
-        let output_start = 17;
-        let output_len = block_count * BLOCK_LEN;
-        let output_end = output_start + output_len;
-        let output = &mut array[output_start..output_end];
-        unsafe {
-            xof_many_function(
-                cv.as_ptr(),
-                block.as_ptr(),
-                block_len as u8,
-                0,
-                flags,
-                output.as_mut_ptr(),
-                block_count,
-            );
-        }
-        for i in 0..array.len() {
-            if i < output_start || output_end <= i {
-                assert_eq!(0, array[i], "index {i}");
-            }
-        }
-    }
-}
-
-#[test]
-#[cfg(unix)]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn test_xof_many_avx512() {
-    if !crate::avx512_detected() {
-        return;
-    }
-    test_xof_many_fn(crate::ffi::x86::blake3_xof_many_avx512);
-}
-
-#[test]
-fn test_compare_reference_impl() {
-    const OUT: usize = 303; // more than 64, not a multiple of 4
-    let mut input_buf = [0; TEST_CASES_MAX];
-    paint_test_input(&mut input_buf);
-    for &case in TEST_CASES {
-        let input = &input_buf[..case];
-        dbg!(case);
-
-        // regular
-        {
-            let mut reference_hasher = reference_impl::Hasher::new();
-            reference_hasher.update(input);
-            let mut expected_out = [0; OUT];
-            reference_hasher.finalize(&mut expected_out);
-
-            let mut test_hasher = crate::Hasher::new();
-            test_hasher.update(input);
-            let mut test_out = [0; OUT];
-            test_hasher.finalize(&mut test_out);
-            assert_eq!(test_out[..], expected_out[..]);
-
-            #[cfg(feature = "tbb")]
-            {
-                let mut tbb_hasher = crate::Hasher::new();
-                tbb_hasher.update_tbb(input);
-                let mut tbb_out = [0; OUT];
-                tbb_hasher.finalize(&mut tbb_out);
-                assert_eq!(tbb_out[..], expected_out[..]);
-            }
-        }
-
-        // keyed
-        {
-            let mut reference_hasher = reference_impl::Hasher::new_keyed(&TEST_KEY);
-            reference_hasher.update(input);
-            let mut expected_out = [0; OUT];
-            reference_hasher.finalize(&mut expected_out);
-
-            let mut test_hasher = crate::Hasher::new_keyed(&TEST_KEY);
-            test_hasher.update(input);
-            let mut test_out = [0; OUT];
-            test_hasher.finalize(&mut test_out);
-            assert_eq!(test_out[..], expected_out[..]);
-
-            #[cfg(feature = "tbb")]
-            {
-                let mut tbb_hasher = crate::Hasher::new_keyed(&TEST_KEY);
-                tbb_hasher.update_tbb(input);
-                let mut tbb_out = [0; OUT];
-                tbb_hasher.finalize(&mut tbb_out);
-                assert_eq!(tbb_out[..], expected_out[..]);
-            }
-        }
-
-        // derive_key
-        {
-            let context = "BLAKE3 2019-12-27 16:13:59 example context (not the test vector one)";
-            let mut reference_hasher = reference_impl::Hasher::new_derive_key(context);
-            reference_hasher.update(input);
-            let mut expected_out = [0; OUT];
-            reference_hasher.finalize(&mut expected_out);
-
-            // the regular C string API
-            let mut test_hasher = crate::Hasher::new_derive_key(context);
-            test_hasher.update(input);
-            let mut test_out = [0; OUT];
-            test_hasher.finalize(&mut test_out);
-            assert_eq!(test_out[..], expected_out[..]);
-
-            // the raw bytes API
-            let mut test_hasher_raw = crate::Hasher::new_derive_key_raw(context.as_bytes());
-            test_hasher_raw.update(input);
-            let mut test_out_raw = [0; OUT];
-            test_hasher_raw.finalize(&mut test_out_raw);
-            assert_eq!(test_out_raw[..], expected_out[..]);
-
-            #[cfg(feature = "tbb")]
-            {
-                let mut tbb_hasher = crate::Hasher::new_derive_key(context);
-                tbb_hasher.update_tbb(input);
-                let mut tbb_out = [0; OUT];
-                tbb_hasher.finalize(&mut tbb_out);
-                assert_eq!(tbb_out[..], expected_out[..]);
-            }
-        }
-    }
-}
-
-fn reference_hash(input: &[u8]) -> [u8; OUT_LEN] {
-    let mut hasher = reference_impl::Hasher::new();
-    hasher.update(input);
-    let mut bytes = [0; OUT_LEN];
-    hasher.finalize(&mut bytes);
-    bytes.into()
-}
-
-#[test]
-fn test_compare_update_multiple() {
-    // Don't use all the long test cases here, since that's unnecessarily slow
-    // in debug mode.
-    let mut short_test_cases = TEST_CASES;
-    while *short_test_cases.last().unwrap() > 4 * CHUNK_LEN {
-        short_test_cases = &short_test_cases[..short_test_cases.len() - 1];
-    }
-    assert_eq!(*short_test_cases.last().unwrap(), 4 * CHUNK_LEN);
-
-    let mut input_buf = [0; 2 * TEST_CASES_MAX];
-    paint_test_input(&mut input_buf);
-
-    for &first_update in short_test_cases {
-        dbg!(first_update);
-        let first_input = &input_buf[..first_update];
-        let mut test_hasher = crate::Hasher::new();
-        test_hasher.update(first_input);
-
-        for &second_update in short_test_cases {
-            dbg!(second_update);
-            let second_input = &input_buf[first_update..][..second_update];
-            let total_input = &input_buf[..first_update + second_update];
-
-            // Clone the hasher with first_update bytes already written, so
-            // that the next iteration can reuse it.
-            let mut test_hasher = test_hasher.clone();
-            test_hasher.update(second_input);
-            let mut test_out = [0; OUT_LEN];
-            test_hasher.finalize(&mut test_out);
-
-            let expected = reference_hash(total_input);
-            assert_eq!(expected, test_out);
-        }
-    }
-}
-
-#[test]
-fn test_fuzz_hasher() {
-    const INPUT_MAX: usize = 4 * CHUNK_LEN;
-    let mut input_buf = [0; 3 * INPUT_MAX];
-    paint_test_input(&mut input_buf);
-
-    // Don't do too many iterations in debug mode, to keep the tests under a
-    // second or so. CI should run tests in release mode also. Provide an
-    // environment variable for specifying a larger number of fuzz iterations.
-    let num_tests = if cfg!(debug_assertions) { 100 } else { 10_000 };
-
-    // Use a fixed RNG seed for reproducibility.
-    let mut rng = rand_chacha::ChaCha8Rng::from_seed([1; 32]);
-    for _num_test in 0..num_tests {
-        dbg!(_num_test);
-        let mut hasher = crate::Hasher::new();
-        let mut total_input = 0;
-        // For each test, write 3 inputs of random length.
-        for _ in 0..3 {
-            let input_len = rng.random_range(0..INPUT_MAX + 1);
-            dbg!(input_len);
-            let input = &input_buf[total_input..][..input_len];
-            hasher.update(input);
-            total_input += input_len;
-        }
-        let expected = reference_hash(&input_buf[..total_input]);
-        let mut test_out = [0; 32];
-        hasher.finalize(&mut test_out);
-        assert_eq!(expected, test_out);
-    }
-}
-
-#[test]
-fn test_finalize_seek() {
-    let mut expected = [0; 1000];
-    {
-        let mut reference_hasher = reference_impl::Hasher::new();
-        reference_hasher.update(b"foobarbaz");
-        reference_hasher.finalize(&mut expected);
-    }
-
-    let mut test_hasher = crate::Hasher::new();
-    test_hasher.update(b"foobarbaz");
-
-    let mut out = [0; 103];
-    for &seek in &[0, 1, 7, 59, 63, 64, 65, 501, expected.len() - out.len()] {
-        dbg!(seek);
-        test_hasher.finalize_seek(seek as u64, &mut out);
-        assert_eq!(&expected[seek..][..out.len()], &out[..]);
-    }
-}
-
-#[test]
-fn test_reset() {
-    {
-        let mut hasher = crate::Hasher::new();
-        hasher.update(&[42; 3 * CHUNK_LEN + 7]);
-        hasher.reset();
-        hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut output = [0; 32];
-        hasher.finalize(&mut output);
-
-        let mut reference_hasher = reference_impl::Hasher::new();
-        reference_hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut reference_hash = [0; 32];
-        reference_hasher.finalize(&mut reference_hash);
-
-        assert_eq!(reference_hash, output);
-    }
-    {
-        let key = &[99; 32];
-        let mut hasher = crate::Hasher::new_keyed(key);
-        hasher.update(&[42; 3 * CHUNK_LEN + 7]);
-        hasher.reset();
-        hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut output = [0; 32];
-        hasher.finalize(&mut output);
-
-        let mut reference_hasher = reference_impl::Hasher::new_keyed(key);
-        reference_hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut reference_hash = [0; 32];
-        reference_hasher.finalize(&mut reference_hash);
-
-        assert_eq!(reference_hash, output);
-    }
-    {
-        let context = "BLAKE3 2020-02-12 10:20:58 reset test";
-        let mut hasher = crate::Hasher::new_derive_key(context);
-        hasher.update(&[42; 3 * CHUNK_LEN + 7]);
-        hasher.reset();
-        hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut output = [0; 32];
-        hasher.finalize(&mut output);
-
-        let mut reference_hasher = reference_impl::Hasher::new_derive_key(context);
-        reference_hasher.update(&[42; CHUNK_LEN + 3]);
-        let mut reference_hash = [0; 32];
-        reference_hasher.finalize(&mut reference_hash);
-
-        assert_eq!(reference_hash, output);
-    }
-}

external/blake3/blake3_dispatch.c

@@ -1,332 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "blake3_impl.h"
-
-#if defined(_MSC_VER)
-#include <Windows.h>
-#endif
-
-#if defined(IS_X86)
-#if defined(_MSC_VER)
-#include <intrin.h>
-#elif defined(__GNUC__)
-#include <immintrin.h>
-#else
-#undef IS_X86 /* Unimplemented! */
-#endif
-#endif
-
-#if !defined(BLAKE3_ATOMICS)
-#if defined(__has_include)
-#if __has_include(<stdatomic.h>) && !defined(_MSC_VER)
-#define BLAKE3_ATOMICS 1
-#else
-#define BLAKE3_ATOMICS 0
-#endif /* __has_include(<stdatomic.h>) && !defined(_MSC_VER) */
-#else
-#define BLAKE3_ATOMICS 0
-#endif /* defined(__has_include) */
-#endif /* BLAKE3_ATOMICS */
-
-#if BLAKE3_ATOMICS
-#define ATOMIC_INT _Atomic int
-#define ATOMIC_LOAD(x) x
-#define ATOMIC_STORE(x, y) x = y
-#elif defined(_MSC_VER)
-#define ATOMIC_INT LONG
-#define ATOMIC_LOAD(x) InterlockedOr(&x, 0)
-#define ATOMIC_STORE(x, y) InterlockedExchange(&x, y)
-#else
-#define ATOMIC_INT int
-#define ATOMIC_LOAD(x) x
-#define ATOMIC_STORE(x, y) x = y
-#endif
-
-#define MAYBE_UNUSED(x) (void)((x))
-
-#if defined(IS_X86)
-static uint64_t xgetbv(void) {
-#if defined(_MSC_VER)
-  return _xgetbv(0);
-#else
-  uint32_t eax = 0, edx = 0;
-  __asm__ __volatile__("xgetbv\n" : "=a"(eax), "=d"(edx) : "c"(0));
-  return ((uint64_t)edx << 32) | eax;
-#endif
-}
-
-static void cpuid(uint32_t out[4], uint32_t id) {
-#if defined(_MSC_VER)
-  __cpuid((int *)out, id);
-#elif defined(__i386__) || defined(_M_IX86)
-  __asm__ __volatile__("movl %%ebx, %1\n"
-                       "cpuid\n"
-                       "xchgl %1, %%ebx\n"
-                       : "=a"(out[0]), "=r"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id));
-#else
-  __asm__ __volatile__("cpuid\n"
-                       : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id));
-#endif
-}
-
-static void cpuidex(uint32_t out[4], uint32_t id, uint32_t sid) {
-#if defined(_MSC_VER)
-  __cpuidex((int *)out, id, sid);
-#elif defined(__i386__) || defined(_M_IX86)
-  __asm__ __volatile__("movl %%ebx, %1\n"
-                       "cpuid\n"
-                       "xchgl %1, %%ebx\n"
-                       : "=a"(out[0]), "=r"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id), "c"(sid));
-#else
-  __asm__ __volatile__("cpuid\n"
-                       : "=a"(out[0]), "=b"(out[1]), "=c"(out[2]), "=d"(out[3])
-                       : "a"(id), "c"(sid));
-#endif
-}
-
-#endif
-
-enum cpu_feature {
-  SSE2 = 1 << 0,
-  SSSE3 = 1 << 1,
-  SSE41 = 1 << 2,
-  AVX = 1 << 3,
-  AVX2 = 1 << 4,
-  AVX512F = 1 << 5,
-  AVX512VL = 1 << 6,
-  /* ... */
-  UNDEFINED = 1 << 30
-};
-
-#if !defined(BLAKE3_TESTING)
-static /* Allow the variable to be controlled manually for testing */
-#endif
-    ATOMIC_INT g_cpu_features = UNDEFINED;
-
-#if !defined(BLAKE3_TESTING)
-static
-#endif
-    enum cpu_feature
-    get_cpu_features(void) {
-
-  /* If TSAN detects a data race here, try compiling with -DBLAKE3_ATOMICS=1 */
-  enum cpu_feature features = ATOMIC_LOAD(g_cpu_features);
-  if (features != UNDEFINED) {
-    return features;
-  } else {
-#if defined(IS_X86)
-    uint32_t regs[4] = {0};
-    uint32_t *eax = &regs[0], *ebx = &regs[1], *ecx = &regs[2], *edx = &regs[3];
-    (void)edx;
-    features = 0;
-    cpuid(regs, 0);
-    const int max_id = *eax;
-    cpuid(regs, 1);
-#if defined(__amd64__) || defined(_M_X64)
-    features |= SSE2;
-#else
-    if (*edx & (1UL << 26))
-      features |= SSE2;
-#endif
-    if (*ecx & (1UL << 9))
-      features |= SSSE3;
-    if (*ecx & (1UL << 19))
-      features |= SSE41;
-
-    if (*ecx & (1UL << 27)) { // OSXSAVE
-      const uint64_t mask = xgetbv();
-      if ((mask & 6) == 6) { // SSE and AVX states
-        if (*ecx & (1UL << 28))
-          features |= AVX;
-        if (max_id >= 7) {
-          cpuidex(regs, 7, 0);
-          if (*ebx & (1UL << 5))
-            features |= AVX2;
-          if ((mask & 224) == 224) { // Opmask, ZMM_Hi256, Hi16_Zmm
-            if (*ebx & (1UL << 31))
-              features |= AVX512VL;
-            if (*ebx & (1UL << 16))
-              features |= AVX512F;
-          }
-        }
-      }
-    }
-    ATOMIC_STORE(g_cpu_features, features);
-    return features;
-#else
-    /* How to detect NEON? */
-    return 0;
-#endif
-  }
-}
-
-void blake3_compress_in_place(uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_compress_in_place_avx512(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_compress_in_place_sse41(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_compress_in_place_sse2(cv, block, block_len, counter, flags);
-    return;
-  }
-#endif
-#endif
-  blake3_compress_in_place_portable(cv, block, block_len, counter, flags);
-}
-
-void blake3_compress_xof(const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags,
-                         uint8_t out[64]) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_compress_xof_avx512(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_compress_xof_sse41(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_compress_xof_sse2(cv, block, block_len, counter, flags, out);
-    return;
-  }
-#endif
-#endif
-  blake3_compress_xof_portable(cv, block, block_len, counter, flags, out);
-}
-
-
-void blake3_xof_many(const uint32_t cv[8],
-                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                     uint8_t block_len, uint64_t counter, uint8_t flags,
-                     uint8_t out[64], size_t outblocks) {
-  if (outblocks == 0) {
-    // The current assembly implementation always outputs at least 1 block.
-    return;
-  }
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(_WIN32) && !defined(BLAKE3_NO_AVX512)
-  if (features & AVX512VL) {
-    blake3_xof_many_avx512(cv, block, block_len, counter, flags, out, outblocks);
-    return;
-  }
-#endif
-#endif
-  for(size_t i = 0; i < outblocks; ++i) {
-    blake3_compress_xof(cv, block, block_len, counter + i, flags, out + 64*i);
-  }
-}
-
-void blake3_hash_many(const uint8_t *const *inputs, size_t num_inputs,
-                      size_t blocks, const uint32_t key[8], uint64_t counter,
-                      bool increment_counter, uint8_t flags,
-                      uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if ((features & (AVX512F|AVX512VL)) == (AVX512F|AVX512VL)) {
-    blake3_hash_many_avx512(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end,
-                            out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-  if (features & AVX2) {
-    blake3_hash_many_avx2(inputs, num_inputs, blocks, key, counter,
-                          increment_counter, flags, flags_start, flags_end,
-                          out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    blake3_hash_many_sse41(inputs, num_inputs, blocks, key, counter,
-                           increment_counter, flags, flags_start, flags_end,
-                           out);
-    return;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    blake3_hash_many_sse2(inputs, num_inputs, blocks, key, counter,
-                          increment_counter, flags, flags_start, flags_end,
-                          out);
-    return;
-  }
-#endif
-#endif
-
-#if BLAKE3_USE_NEON == 1
-  blake3_hash_many_neon(inputs, num_inputs, blocks, key, counter,
-                        increment_counter, flags, flags_start, flags_end, out);
-  return;
-#endif
-
-  blake3_hash_many_portable(inputs, num_inputs, blocks, key, counter,
-                            increment_counter, flags, flags_start, flags_end,
-                            out);
-}
-
-// The dynamically detected SIMD degree of the current platform.
-size_t blake3_simd_degree(void) {
-#if defined(IS_X86)
-  const enum cpu_feature features = get_cpu_features();
-  MAYBE_UNUSED(features);
-#if !defined(BLAKE3_NO_AVX512)
-  if ((features & (AVX512F|AVX512VL)) == (AVX512F|AVX512VL)) {
-    return 16;
-  }
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-  if (features & AVX2) {
-    return 8;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-  if (features & SSE41) {
-    return 4;
-  }
-#endif
-#if !defined(BLAKE3_NO_SSE2)
-  if (features & SSE2) {
-    return 4;
-  }
-#endif
-#endif
-#if BLAKE3_USE_NEON == 1
-  return 4;
-#endif
-  return 1;
-}

external/blake3/blake3_impl.h

@@ -1,333 +0,0 @@
-#ifndef BLAKE3_IMPL_H
-#define BLAKE3_IMPL_H
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "blake3.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// internal flags
-enum blake3_flags {
-  CHUNK_START         = 1 << 0,
-  CHUNK_END           = 1 << 1,
-  PARENT              = 1 << 2,
-  ROOT                = 1 << 3,
-  KEYED_HASH          = 1 << 4,
-  DERIVE_KEY_CONTEXT  = 1 << 5,
-  DERIVE_KEY_MATERIAL = 1 << 6,
-};
-
-// This C implementation tries to support recent versions of GCC, Clang, and
-// MSVC.
-#if defined(_MSC_VER)
-#define INLINE static __forceinline
-#else
-#define INLINE static inline __attribute__((always_inline))
-#endif
-
-#ifdef __cplusplus
-#define NOEXCEPT noexcept
-#else
-#define NOEXCEPT
-#endif
-
-#if (defined(__x86_64__) || defined(_M_X64)) && !defined(_M_ARM64EC)
-#define IS_X86
-#define IS_X86_64
-#endif
-
-#if defined(__i386__) || defined(_M_IX86)
-#define IS_X86
-#define IS_X86_32
-#endif
-
-#if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
-#define IS_AARCH64
-#endif
-
-#if defined(IS_X86)
-#if defined(_MSC_VER)
-#include <intrin.h>
-#endif
-#endif
-
-#if !defined(BLAKE3_USE_NEON) 
-  // If BLAKE3_USE_NEON not manually set, autodetect based on AArch64ness
-  #if defined(IS_AARCH64)
-    #if defined(__ARM_BIG_ENDIAN)
-      #define BLAKE3_USE_NEON 0
-    #else
-      #define BLAKE3_USE_NEON 1
-    #endif
-  #else
-    #define BLAKE3_USE_NEON 0
-  #endif
-#endif
-
-#if defined(IS_X86)
-#define MAX_SIMD_DEGREE 16
-#elif BLAKE3_USE_NEON == 1
-#define MAX_SIMD_DEGREE 4
-#else
-#define MAX_SIMD_DEGREE 1
-#endif
-
-// There are some places where we want a static size that's equal to the
-// MAX_SIMD_DEGREE, but also at least 2.
-#define MAX_SIMD_DEGREE_OR_2 (MAX_SIMD_DEGREE > 2 ? MAX_SIMD_DEGREE : 2)
-
-static const uint32_t IV[8] = {0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL,
-                               0xA54FF53AUL, 0x510E527FUL, 0x9B05688CUL,
-                               0x1F83D9ABUL, 0x5BE0CD19UL};
-
-static const uint8_t MSG_SCHEDULE[7][16] = {
-    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
-    {2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8},
-    {3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1},
-    {10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6},
-    {12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4},
-    {9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7},
-    {11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13},
-};
-
-/* Find index of the highest set bit */
-/* x is assumed to be nonzero.       */
-static unsigned int highest_one(uint64_t x) {
-#if defined(__GNUC__) || defined(__clang__)
-  return 63 ^ (unsigned int)__builtin_clzll(x);
-#elif defined(_MSC_VER) && defined(IS_X86_64)
-  unsigned long index;
-  _BitScanReverse64(&index, x);
-  return index;
-#elif defined(_MSC_VER) && defined(IS_X86_32)
-  if(x >> 32) {
-    unsigned long index;
-    _BitScanReverse(&index, (unsigned long)(x >> 32));
-    return 32 + index;
-  } else {
-    unsigned long index;
-    _BitScanReverse(&index, (unsigned long)x);
-    return index;
-  }
-#else
-  unsigned int c = 0;
-  if(x & 0xffffffff00000000ULL) { x >>= 32; c += 32; }
-  if(x & 0x00000000ffff0000ULL) { x >>= 16; c += 16; }
-  if(x & 0x000000000000ff00ULL) { x >>=  8; c +=  8; }
-  if(x & 0x00000000000000f0ULL) { x >>=  4; c +=  4; }
-  if(x & 0x000000000000000cULL) { x >>=  2; c +=  2; }
-  if(x & 0x0000000000000002ULL) {           c +=  1; }
-  return c;
-#endif
-}
-
-// Count the number of 1 bits.
-INLINE unsigned int popcnt(uint64_t x) {
-#if defined(__GNUC__) || defined(__clang__)
-  return (unsigned int)__builtin_popcountll(x);
-#else
-  unsigned int count = 0;
-  while (x != 0) {
-    count += 1;
-    x &= x - 1;
-  }
-  return count;
-#endif
-}
-
-// Largest power of two less than or equal to x. As a special case, returns 1
-// when x is 0. 
-INLINE uint64_t round_down_to_power_of_2(uint64_t x) {
-  return 1ULL << highest_one(x | 1);
-}
-
-INLINE uint32_t counter_low(uint64_t counter) { return (uint32_t)counter; }
-
-INLINE uint32_t counter_high(uint64_t counter) {
-  return (uint32_t)(counter >> 32);
-}
-
-INLINE uint32_t load32(const void *src) {
-  const uint8_t *p = (const uint8_t *)src;
-  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
-         ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);
-}
-
-INLINE void load_key_words(const uint8_t key[BLAKE3_KEY_LEN],
-                           uint32_t key_words[8]) {
-  key_words[0] = load32(&key[0 * 4]);
-  key_words[1] = load32(&key[1 * 4]);
-  key_words[2] = load32(&key[2 * 4]);
-  key_words[3] = load32(&key[3 * 4]);
-  key_words[4] = load32(&key[4 * 4]);
-  key_words[5] = load32(&key[5 * 4]);
-  key_words[6] = load32(&key[6 * 4]);
-  key_words[7] = load32(&key[7 * 4]);
-}
-
-INLINE void load_block_words(const uint8_t block[BLAKE3_BLOCK_LEN],
-                             uint32_t block_words[16]) {
-  for (size_t i = 0; i < 16; i++) {
-      block_words[i] = load32(&block[i * 4]);
-  }
-}
-
-INLINE void store32(void *dst, uint32_t w) {
-  uint8_t *p = (uint8_t *)dst;
-  p[0] = (uint8_t)(w >> 0);
-  p[1] = (uint8_t)(w >> 8);
-  p[2] = (uint8_t)(w >> 16);
-  p[3] = (uint8_t)(w >> 24);
-}
-
-INLINE void store_cv_words(uint8_t bytes_out[32], uint32_t cv_words[8]) {
-  store32(&bytes_out[0 * 4], cv_words[0]);
-  store32(&bytes_out[1 * 4], cv_words[1]);
-  store32(&bytes_out[2 * 4], cv_words[2]);
-  store32(&bytes_out[3 * 4], cv_words[3]);
-  store32(&bytes_out[4 * 4], cv_words[4]);
-  store32(&bytes_out[5 * 4], cv_words[5]);
-  store32(&bytes_out[6 * 4], cv_words[6]);
-  store32(&bytes_out[7 * 4], cv_words[7]);
-}
-
-void blake3_compress_in_place(uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags);
-
-void blake3_compress_xof(const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags,
-                         uint8_t out[64]);
-
-void blake3_xof_many(const uint32_t cv[8],
-                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                     uint8_t block_len, uint64_t counter, uint8_t flags,
-                     uint8_t out[64], size_t outblocks);
-
-void blake3_hash_many(const uint8_t *const *inputs, size_t num_inputs,
-                      size_t blocks, const uint32_t key[8], uint64_t counter,
-                      bool increment_counter, uint8_t flags,
-                      uint8_t flags_start, uint8_t flags_end, uint8_t *out);
-
-size_t blake3_simd_degree(void);
-
-BLAKE3_PRIVATE size_t blake3_compress_subtree_wide(const uint8_t *input, size_t input_len,
-                                                   const uint32_t key[8],
-                                                   uint64_t chunk_counter, uint8_t flags,
-                                                   uint8_t *out, bool use_tbb);
-
-#if defined(BLAKE3_USE_TBB)
-BLAKE3_PRIVATE void blake3_compress_subtree_wide_join_tbb(
-    // shared params
-    const uint32_t key[8], uint8_t flags, bool use_tbb,
-    // left-hand side params
-    const uint8_t *l_input, size_t l_input_len, uint64_t l_chunk_counter,
-    uint8_t *l_cvs, size_t *l_n,
-    // right-hand side params
-    const uint8_t *r_input, size_t r_input_len, uint64_t r_chunk_counter,
-    uint8_t *r_cvs, size_t *r_n) NOEXCEPT;
-#endif
-
-// Declarations for implementation-specific functions.
-void blake3_compress_in_place_portable(uint32_t cv[8],
-                                       const uint8_t block[BLAKE3_BLOCK_LEN],
-                                       uint8_t block_len, uint64_t counter,
-                                       uint8_t flags);
-
-void blake3_compress_xof_portable(const uint32_t cv[8],
-                                  const uint8_t block[BLAKE3_BLOCK_LEN],
-                                  uint8_t block_len, uint64_t counter,
-                                  uint8_t flags, uint8_t out[64]);
-
-void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                               size_t blocks, const uint32_t key[8],
-                               uint64_t counter, bool increment_counter,
-                               uint8_t flags, uint8_t flags_start,
-                               uint8_t flags_end, uint8_t *out);
-
-#if defined(IS_X86)
-#if !defined(BLAKE3_NO_SSE2)
-void blake3_compress_in_place_sse2(uint32_t cv[8],
-                                   const uint8_t block[BLAKE3_BLOCK_LEN],
-                                   uint8_t block_len, uint64_t counter,
-                                   uint8_t flags);
-void blake3_compress_xof_sse2(const uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags, uint8_t out[64]);
-void blake3_hash_many_sse2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_SSE41)
-void blake3_compress_in_place_sse41(uint32_t cv[8],
-                                    const uint8_t block[BLAKE3_BLOCK_LEN],
-                                    uint8_t block_len, uint64_t counter,
-                                    uint8_t flags);
-void blake3_compress_xof_sse41(const uint32_t cv[8],
-                               const uint8_t block[BLAKE3_BLOCK_LEN],
-                               uint8_t block_len, uint64_t counter,
-                               uint8_t flags, uint8_t out[64]);
-void blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
-                            size_t blocks, const uint32_t key[8],
-                            uint64_t counter, bool increment_counter,
-                            uint8_t flags, uint8_t flags_start,
-                            uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_AVX2)
-void blake3_hash_many_avx2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-#if !defined(BLAKE3_NO_AVX512)
-void blake3_compress_in_place_avx512(uint32_t cv[8],
-                                     const uint8_t block[BLAKE3_BLOCK_LEN],
-                                     uint8_t block_len, uint64_t counter,
-                                     uint8_t flags);
-
-void blake3_compress_xof_avx512(const uint32_t cv[8],
-                                const uint8_t block[BLAKE3_BLOCK_LEN],
-                                uint8_t block_len, uint64_t counter,
-                                uint8_t flags, uint8_t out[64]);
-
-void blake3_hash_many_avx512(const uint8_t *const *inputs, size_t num_inputs,
-                             size_t blocks, const uint32_t key[8],
-                             uint64_t counter, bool increment_counter,
-                             uint8_t flags, uint8_t flags_start,
-                             uint8_t flags_end, uint8_t *out);
-
-#if !defined(_WIN32)
-void blake3_xof_many_avx512(const uint32_t cv[8],
-                            const uint8_t block[BLAKE3_BLOCK_LEN],
-                            uint8_t block_len, uint64_t counter, uint8_t flags,
-                            uint8_t* out, size_t outblocks);
-#endif
-#endif
-#endif
-
-#if BLAKE3_USE_NEON == 1
-void blake3_hash_many_neon(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* BLAKE3_IMPL_H */

external/blake3/blake3_neon.c

@@ -1,366 +0,0 @@
-#include "blake3_impl.h"
-
-#include <arm_neon.h>
-
-#ifdef __ARM_BIG_ENDIAN
-#error "This implementation only supports little-endian ARM."
-// It might be that all we need for big-endian support here is to get the loads
-// and stores right, but step zero would be finding a way to test it in CI.
-#endif
-
-INLINE uint32x4_t loadu_128(const uint8_t src[16]) {
-  // vld1q_u32 has alignment requirements. Don't use it.
-  return vreinterpretq_u32_u8(vld1q_u8(src));
-}
-
-INLINE void storeu_128(uint32x4_t src, uint8_t dest[16]) {
-  // vst1q_u32 has alignment requirements. Don't use it.
-  vst1q_u8(dest, vreinterpretq_u8_u32(src));
-}
-
-INLINE uint32x4_t add_128(uint32x4_t a, uint32x4_t b) {
-  return vaddq_u32(a, b);
-}
-
-INLINE uint32x4_t xor_128(uint32x4_t a, uint32x4_t b) {
-  return veorq_u32(a, b);
-}
-
-INLINE uint32x4_t set1_128(uint32_t x) { return vld1q_dup_u32(&x); }
-
-INLINE uint32x4_t set4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
-  uint32_t array[4] = {a, b, c, d};
-  return vld1q_u32(array);
-}
-
-INLINE uint32x4_t rot16_128(uint32x4_t x) {
-  // The straightforward implementation would be two shifts and an or, but that's
-  // slower on microarchitectures we've tested. See
-  // https://github.com/BLAKE3-team/BLAKE3/pull/319.
-  // return vorrq_u32(vshrq_n_u32(x, 16), vshlq_n_u32(x, 32 - 16));
-  return vreinterpretq_u32_u16(vrev32q_u16(vreinterpretq_u16_u32(x)));
-}
-
-INLINE uint32x4_t rot12_128(uint32x4_t x) {
-  // See comment in rot16_128.
-  // return vorrq_u32(vshrq_n_u32(x, 12), vshlq_n_u32(x, 32 - 12));
-  return vsriq_n_u32(vshlq_n_u32(x, 32-12), x, 12);
-}
-
-INLINE uint32x4_t rot8_128(uint32x4_t x) {
-  // See comment in rot16_128.
-  // return vorrq_u32(vshrq_n_u32(x, 8), vshlq_n_u32(x, 32 - 8));
-#if defined(__clang__)
-  return vreinterpretq_u32_u8(__builtin_shufflevector(vreinterpretq_u8_u32(x), vreinterpretq_u8_u32(x), 1,2,3,0,5,6,7,4,9,10,11,8,13,14,15,12));
-#elif __GNUC__ * 10000 + __GNUC_MINOR__ * 100 >=40700
-  static const uint8x16_t r8 = {1,2,3,0,5,6,7,4,9,10,11,8,13,14,15,12};
-  return vreinterpretq_u32_u8(__builtin_shuffle(vreinterpretq_u8_u32(x), vreinterpretq_u8_u32(x), r8));
-#else 
-  return vsriq_n_u32(vshlq_n_u32(x, 32-8), x, 8);
-#endif
-}
-
-INLINE uint32x4_t rot7_128(uint32x4_t x) {
-  // See comment in rot16_128.
-  // return vorrq_u32(vshrq_n_u32(x, 7), vshlq_n_u32(x, 32 - 7));
-  return vsriq_n_u32(vshlq_n_u32(x, 32-7), x, 7);
-}
-
-// TODO: compress_neon
-
-// TODO: hash2_neon
-
-/*
- * ----------------------------------------------------------------------------
- * hash4_neon
- * ----------------------------------------------------------------------------
- */
-
-INLINE void round_fn4(uint32x4_t v[16], uint32x4_t m[16], size_t r) {
-  v[0] = add_128(v[0], m[(size_t)MSG_SCHEDULE[r][0]]);
-  v[1] = add_128(v[1], m[(size_t)MSG_SCHEDULE[r][2]]);
-  v[2] = add_128(v[2], m[(size_t)MSG_SCHEDULE[r][4]]);
-  v[3] = add_128(v[3], m[(size_t)MSG_SCHEDULE[r][6]]);
-  v[0] = add_128(v[0], v[4]);
-  v[1] = add_128(v[1], v[5]);
-  v[2] = add_128(v[2], v[6]);
-  v[3] = add_128(v[3], v[7]);
-  v[12] = xor_128(v[12], v[0]);
-  v[13] = xor_128(v[13], v[1]);
-  v[14] = xor_128(v[14], v[2]);
-  v[15] = xor_128(v[15], v[3]);
-  v[12] = rot16_128(v[12]);
-  v[13] = rot16_128(v[13]);
-  v[14] = rot16_128(v[14]);
-  v[15] = rot16_128(v[15]);
-  v[8] = add_128(v[8], v[12]);
-  v[9] = add_128(v[9], v[13]);
-  v[10] = add_128(v[10], v[14]);
-  v[11] = add_128(v[11], v[15]);
-  v[4] = xor_128(v[4], v[8]);
-  v[5] = xor_128(v[5], v[9]);
-  v[6] = xor_128(v[6], v[10]);
-  v[7] = xor_128(v[7], v[11]);
-  v[4] = rot12_128(v[4]);
-  v[5] = rot12_128(v[5]);
-  v[6] = rot12_128(v[6]);
-  v[7] = rot12_128(v[7]);
-  v[0] = add_128(v[0], m[(size_t)MSG_SCHEDULE[r][1]]);
-  v[1] = add_128(v[1], m[(size_t)MSG_SCHEDULE[r][3]]);
-  v[2] = add_128(v[2], m[(size_t)MSG_SCHEDULE[r][5]]);
-  v[3] = add_128(v[3], m[(size_t)MSG_SCHEDULE[r][7]]);
-  v[0] = add_128(v[0], v[4]);
-  v[1] = add_128(v[1], v[5]);
-  v[2] = add_128(v[2], v[6]);
-  v[3] = add_128(v[3], v[7]);
-  v[12] = xor_128(v[12], v[0]);
-  v[13] = xor_128(v[13], v[1]);
-  v[14] = xor_128(v[14], v[2]);
-  v[15] = xor_128(v[15], v[3]);
-  v[12] = rot8_128(v[12]);
-  v[13] = rot8_128(v[13]);
-  v[14] = rot8_128(v[14]);
-  v[15] = rot8_128(v[15]);
-  v[8] = add_128(v[8], v[12]);
-  v[9] = add_128(v[9], v[13]);
-  v[10] = add_128(v[10], v[14]);
-  v[11] = add_128(v[11], v[15]);
-  v[4] = xor_128(v[4], v[8]);
-  v[5] = xor_128(v[5], v[9]);
-  v[6] = xor_128(v[6], v[10]);
-  v[7] = xor_128(v[7], v[11]);
-  v[4] = rot7_128(v[4]);
-  v[5] = rot7_128(v[5]);
-  v[6] = rot7_128(v[6]);
-  v[7] = rot7_128(v[7]);
-
-  v[0] = add_128(v[0], m[(size_t)MSG_SCHEDULE[r][8]]);
-  v[1] = add_128(v[1], m[(size_t)MSG_SCHEDULE[r][10]]);
-  v[2] = add_128(v[2], m[(size_t)MSG_SCHEDULE[r][12]]);
-  v[3] = add_128(v[3], m[(size_t)MSG_SCHEDULE[r][14]]);
-  v[0] = add_128(v[0], v[5]);
-  v[1] = add_128(v[1], v[6]);
-  v[2] = add_128(v[2], v[7]);
-  v[3] = add_128(v[3], v[4]);
-  v[15] = xor_128(v[15], v[0]);
-  v[12] = xor_128(v[12], v[1]);
-  v[13] = xor_128(v[13], v[2]);
-  v[14] = xor_128(v[14], v[3]);
-  v[15] = rot16_128(v[15]);
-  v[12] = rot16_128(v[12]);
-  v[13] = rot16_128(v[13]);
-  v[14] = rot16_128(v[14]);
-  v[10] = add_128(v[10], v[15]);
-  v[11] = add_128(v[11], v[12]);
-  v[8] = add_128(v[8], v[13]);
-  v[9] = add_128(v[9], v[14]);
-  v[5] = xor_128(v[5], v[10]);
-  v[6] = xor_128(v[6], v[11]);
-  v[7] = xor_128(v[7], v[8]);
-  v[4] = xor_128(v[4], v[9]);
-  v[5] = rot12_128(v[5]);
-  v[6] = rot12_128(v[6]);
-  v[7] = rot12_128(v[7]);
-  v[4] = rot12_128(v[4]);
-  v[0] = add_128(v[0], m[(size_t)MSG_SCHEDULE[r][9]]);
-  v[1] = add_128(v[1], m[(size_t)MSG_SCHEDULE[r][11]]);
-  v[2] = add_128(v[2], m[(size_t)MSG_SCHEDULE[r][13]]);
-  v[3] = add_128(v[3], m[(size_t)MSG_SCHEDULE[r][15]]);
-  v[0] = add_128(v[0], v[5]);
-  v[1] = add_128(v[1], v[6]);
-  v[2] = add_128(v[2], v[7]);
-  v[3] = add_128(v[3], v[4]);
-  v[15] = xor_128(v[15], v[0]);
-  v[12] = xor_128(v[12], v[1]);
-  v[13] = xor_128(v[13], v[2]);
-  v[14] = xor_128(v[14], v[3]);
-  v[15] = rot8_128(v[15]);
-  v[12] = rot8_128(v[12]);
-  v[13] = rot8_128(v[13]);
-  v[14] = rot8_128(v[14]);
-  v[10] = add_128(v[10], v[15]);
-  v[11] = add_128(v[11], v[12]);
-  v[8] = add_128(v[8], v[13]);
-  v[9] = add_128(v[9], v[14]);
-  v[5] = xor_128(v[5], v[10]);
-  v[6] = xor_128(v[6], v[11]);
-  v[7] = xor_128(v[7], v[8]);
-  v[4] = xor_128(v[4], v[9]);
-  v[5] = rot7_128(v[5]);
-  v[6] = rot7_128(v[6]);
-  v[7] = rot7_128(v[7]);
-  v[4] = rot7_128(v[4]);
-}
-
-INLINE void transpose_vecs_128(uint32x4_t vecs[4]) {
-  // Individually transpose the four 2x2 sub-matrices in each corner.
-  uint32x4x2_t rows01 = vtrnq_u32(vecs[0], vecs[1]);
-  uint32x4x2_t rows23 = vtrnq_u32(vecs[2], vecs[3]);
-
-  // Swap the top-right and bottom-left 2x2s (which just got transposed).
-  vecs[0] =
-      vcombine_u32(vget_low_u32(rows01.val[0]), vget_low_u32(rows23.val[0]));
-  vecs[1] =
-      vcombine_u32(vget_low_u32(rows01.val[1]), vget_low_u32(rows23.val[1]));
-  vecs[2] =
-      vcombine_u32(vget_high_u32(rows01.val[0]), vget_high_u32(rows23.val[0]));
-  vecs[3] =
-      vcombine_u32(vget_high_u32(rows01.val[1]), vget_high_u32(rows23.val[1]));
-}
-
-INLINE void transpose_msg_vecs4(const uint8_t *const *inputs,
-                                size_t block_offset, uint32x4_t out[16]) {
-  out[0] = loadu_128(&inputs[0][block_offset + 0 * sizeof(uint32x4_t)]);
-  out[1] = loadu_128(&inputs[1][block_offset + 0 * sizeof(uint32x4_t)]);
-  out[2] = loadu_128(&inputs[2][block_offset + 0 * sizeof(uint32x4_t)]);
-  out[3] = loadu_128(&inputs[3][block_offset + 0 * sizeof(uint32x4_t)]);
-  out[4] = loadu_128(&inputs[0][block_offset + 1 * sizeof(uint32x4_t)]);
-  out[5] = loadu_128(&inputs[1][block_offset + 1 * sizeof(uint32x4_t)]);
-  out[6] = loadu_128(&inputs[2][block_offset + 1 * sizeof(uint32x4_t)]);
-  out[7] = loadu_128(&inputs[3][block_offset + 1 * sizeof(uint32x4_t)]);
-  out[8] = loadu_128(&inputs[0][block_offset + 2 * sizeof(uint32x4_t)]);
-  out[9] = loadu_128(&inputs[1][block_offset + 2 * sizeof(uint32x4_t)]);
-  out[10] = loadu_128(&inputs[2][block_offset + 2 * sizeof(uint32x4_t)]);
-  out[11] = loadu_128(&inputs[3][block_offset + 2 * sizeof(uint32x4_t)]);
-  out[12] = loadu_128(&inputs[0][block_offset + 3 * sizeof(uint32x4_t)]);
-  out[13] = loadu_128(&inputs[1][block_offset + 3 * sizeof(uint32x4_t)]);
-  out[14] = loadu_128(&inputs[2][block_offset + 3 * sizeof(uint32x4_t)]);
-  out[15] = loadu_128(&inputs[3][block_offset + 3 * sizeof(uint32x4_t)]);
-  transpose_vecs_128(&out[0]);
-  transpose_vecs_128(&out[4]);
-  transpose_vecs_128(&out[8]);
-  transpose_vecs_128(&out[12]);
-}
-
-INLINE void load_counters4(uint64_t counter, bool increment_counter,
-                           uint32x4_t *out_low, uint32x4_t *out_high) {
-  uint64_t mask = (increment_counter ? ~0 : 0);
-  *out_low = set4(
-      counter_low(counter + (mask & 0)), counter_low(counter + (mask & 1)),
-      counter_low(counter + (mask & 2)), counter_low(counter + (mask & 3)));
-  *out_high = set4(
-      counter_high(counter + (mask & 0)), counter_high(counter + (mask & 1)),
-      counter_high(counter + (mask & 2)), counter_high(counter + (mask & 3)));
-}
-
-void blake3_hash4_neon(const uint8_t *const *inputs, size_t blocks,
-                       const uint32_t key[8], uint64_t counter,
-                       bool increment_counter, uint8_t flags,
-                       uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-  uint32x4_t h_vecs[8] = {
-      set1_128(key[0]), set1_128(key[1]), set1_128(key[2]), set1_128(key[3]),
-      set1_128(key[4]), set1_128(key[5]), set1_128(key[6]), set1_128(key[7]),
-  };
-  uint32x4_t counter_low_vec, counter_high_vec;
-  load_counters4(counter, increment_counter, &counter_low_vec,
-                 &counter_high_vec);
-  uint8_t block_flags = flags | flags_start;
-
-  for (size_t block = 0; block < blocks; block++) {
-    if (block + 1 == blocks) {
-      block_flags |= flags_end;
-    }
-    uint32x4_t block_len_vec = set1_128(BLAKE3_BLOCK_LEN);
-    uint32x4_t block_flags_vec = set1_128(block_flags);
-    uint32x4_t msg_vecs[16];
-    transpose_msg_vecs4(inputs, block * BLAKE3_BLOCK_LEN, msg_vecs);
-
-    uint32x4_t v[16] = {
-        h_vecs[0],       h_vecs[1],        h_vecs[2],       h_vecs[3],
-        h_vecs[4],       h_vecs[5],        h_vecs[6],       h_vecs[7],
-        set1_128(IV[0]), set1_128(IV[1]),  set1_128(IV[2]), set1_128(IV[3]),
-        counter_low_vec, counter_high_vec, block_len_vec,   block_flags_vec,
-    };
-    round_fn4(v, msg_vecs, 0);
-    round_fn4(v, msg_vecs, 1);
-    round_fn4(v, msg_vecs, 2);
-    round_fn4(v, msg_vecs, 3);
-    round_fn4(v, msg_vecs, 4);
-    round_fn4(v, msg_vecs, 5);
-    round_fn4(v, msg_vecs, 6);
-    h_vecs[0] = xor_128(v[0], v[8]);
-    h_vecs[1] = xor_128(v[1], v[9]);
-    h_vecs[2] = xor_128(v[2], v[10]);
-    h_vecs[3] = xor_128(v[3], v[11]);
-    h_vecs[4] = xor_128(v[4], v[12]);
-    h_vecs[5] = xor_128(v[5], v[13]);
-    h_vecs[6] = xor_128(v[6], v[14]);
-    h_vecs[7] = xor_128(v[7], v[15]);
-
-    block_flags = flags;
-  }
-
-  transpose_vecs_128(&h_vecs[0]);
-  transpose_vecs_128(&h_vecs[4]);
-  // The first four vecs now contain the first half of each output, and the
-  // second four vecs contain the second half of each output.
-  storeu_128(h_vecs[0], &out[0 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[4], &out[1 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[1], &out[2 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[5], &out[3 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[2], &out[4 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[6], &out[5 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[3], &out[6 * sizeof(uint32x4_t)]);
-  storeu_128(h_vecs[7], &out[7 * sizeof(uint32x4_t)]);
-}
-
-/*
- * ----------------------------------------------------------------------------
- * hash_many_neon
- * ----------------------------------------------------------------------------
- */
-
-void blake3_compress_in_place_portable(uint32_t cv[8],
-                                       const uint8_t block[BLAKE3_BLOCK_LEN],
-                                       uint8_t block_len, uint64_t counter,
-                                       uint8_t flags);
-
-INLINE void hash_one_neon(const uint8_t *input, size_t blocks,
-                          const uint32_t key[8], uint64_t counter,
-                          uint8_t flags, uint8_t flags_start, uint8_t flags_end,
-                          uint8_t out[BLAKE3_OUT_LEN]) {
-  uint32_t cv[8];
-  memcpy(cv, key, BLAKE3_KEY_LEN);
-  uint8_t block_flags = flags | flags_start;
-  while (blocks > 0) {
-    if (blocks == 1) {
-      block_flags |= flags_end;
-    }
-    // TODO: Implement compress_neon. However note that according to
-    // https://github.com/BLAKE2/BLAKE2/commit/7965d3e6e1b4193438b8d3a656787587d2579227,
-    // compress_neon might not be any faster than compress_portable.
-    blake3_compress_in_place_portable(cv, input, BLAKE3_BLOCK_LEN, counter,
-                                      block_flags);
-    input = &input[BLAKE3_BLOCK_LEN];
-    blocks -= 1;
-    block_flags = flags;
-  }
-  memcpy(out, cv, BLAKE3_OUT_LEN);
-}
-
-void blake3_hash_many_neon(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out) {
-  while (num_inputs >= 4) {
-    blake3_hash4_neon(inputs, blocks, key, counter, increment_counter, flags,
-                      flags_start, flags_end, out);
-    if (increment_counter) {
-      counter += 4;
-    }
-    inputs += 4;
-    num_inputs -= 4;
-    out = &out[4 * BLAKE3_OUT_LEN];
-  }
-  while (num_inputs > 0) {
-    hash_one_neon(inputs[0], blocks, key, counter, flags, flags_start,
-                  flags_end, out);
-    if (increment_counter) {
-      counter += 1;
-    }
-    inputs += 1;
-    num_inputs -= 1;
-    out = &out[BLAKE3_OUT_LEN];
-  }
-}

external/blake3/blake3_portable.c

@@ -1,160 +0,0 @@
-#include "blake3_impl.h"
-#include <string.h>
-
-INLINE uint32_t rotr32(uint32_t w, uint32_t c) {
-  return (w >> c) | (w << (32 - c));
-}
-
-INLINE void g(uint32_t *state, size_t a, size_t b, size_t c, size_t d,
-              uint32_t x, uint32_t y) {
-  state[a] = state[a] + state[b] + x;
-  state[d] = rotr32(state[d] ^ state[a], 16);
-  state[c] = state[c] + state[d];
-  state[b] = rotr32(state[b] ^ state[c], 12);
-  state[a] = state[a] + state[b] + y;
-  state[d] = rotr32(state[d] ^ state[a], 8);
-  state[c] = state[c] + state[d];
-  state[b] = rotr32(state[b] ^ state[c], 7);
-}
-
-INLINE void round_fn(uint32_t state[16], const uint32_t *msg, size_t round) {
-  // Select the message schedule based on the round.
-  const uint8_t *schedule = MSG_SCHEDULE[round];
-
-  // Mix the columns.
-  g(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
-  g(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
-  g(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
-  g(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
-
-  // Mix the rows.
-  g(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]]);
-  g(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]]);
-  g(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]]);
-  g(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]]);
-}
-
-INLINE void compress_pre(uint32_t state[16], const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags) {
-  uint32_t block_words[16];
-  block_words[0] = load32(block + 4 * 0);
-  block_words[1] = load32(block + 4 * 1);
-  block_words[2] = load32(block + 4 * 2);
-  block_words[3] = load32(block + 4 * 3);
-  block_words[4] = load32(block + 4 * 4);
-  block_words[5] = load32(block + 4 * 5);
-  block_words[6] = load32(block + 4 * 6);
-  block_words[7] = load32(block + 4 * 7);
-  block_words[8] = load32(block + 4 * 8);
-  block_words[9] = load32(block + 4 * 9);
-  block_words[10] = load32(block + 4 * 10);
-  block_words[11] = load32(block + 4 * 11);
-  block_words[12] = load32(block + 4 * 12);
-  block_words[13] = load32(block + 4 * 13);
-  block_words[14] = load32(block + 4 * 14);
-  block_words[15] = load32(block + 4 * 15);
-
-  state[0] = cv[0];
-  state[1] = cv[1];
-  state[2] = cv[2];
-  state[3] = cv[3];
-  state[4] = cv[4];
-  state[5] = cv[5];
-  state[6] = cv[6];
-  state[7] = cv[7];
-  state[8] = IV[0];
-  state[9] = IV[1];
-  state[10] = IV[2];
-  state[11] = IV[3];
-  state[12] = counter_low(counter);
-  state[13] = counter_high(counter);
-  state[14] = (uint32_t)block_len;
-  state[15] = (uint32_t)flags;
-
-  round_fn(state, &block_words[0], 0);
-  round_fn(state, &block_words[0], 1);
-  round_fn(state, &block_words[0], 2);
-  round_fn(state, &block_words[0], 3);
-  round_fn(state, &block_words[0], 4);
-  round_fn(state, &block_words[0], 5);
-  round_fn(state, &block_words[0], 6);
-}
-
-void blake3_compress_in_place_portable(uint32_t cv[8],
-                                       const uint8_t block[BLAKE3_BLOCK_LEN],
-                                       uint8_t block_len, uint64_t counter,
-                                       uint8_t flags) {
-  uint32_t state[16];
-  compress_pre(state, cv, block, block_len, counter, flags);
-  cv[0] = state[0] ^ state[8];
-  cv[1] = state[1] ^ state[9];
-  cv[2] = state[2] ^ state[10];
-  cv[3] = state[3] ^ state[11];
-  cv[4] = state[4] ^ state[12];
-  cv[5] = state[5] ^ state[13];
-  cv[6] = state[6] ^ state[14];
-  cv[7] = state[7] ^ state[15];
-}
-
-void blake3_compress_xof_portable(const uint32_t cv[8],
-                                  const uint8_t block[BLAKE3_BLOCK_LEN],
-                                  uint8_t block_len, uint64_t counter,
-                                  uint8_t flags, uint8_t out[64]) {
-  uint32_t state[16];
-  compress_pre(state, cv, block, block_len, counter, flags);
-
-  store32(&out[0 * 4], state[0] ^ state[8]);
-  store32(&out[1 * 4], state[1] ^ state[9]);
-  store32(&out[2 * 4], state[2] ^ state[10]);
-  store32(&out[3 * 4], state[3] ^ state[11]);
-  store32(&out[4 * 4], state[4] ^ state[12]);
-  store32(&out[5 * 4], state[5] ^ state[13]);
-  store32(&out[6 * 4], state[6] ^ state[14]);
-  store32(&out[7 * 4], state[7] ^ state[15]);
-  store32(&out[8 * 4], state[8] ^ cv[0]);
-  store32(&out[9 * 4], state[9] ^ cv[1]);
-  store32(&out[10 * 4], state[10] ^ cv[2]);
-  store32(&out[11 * 4], state[11] ^ cv[3]);
-  store32(&out[12 * 4], state[12] ^ cv[4]);
-  store32(&out[13 * 4], state[13] ^ cv[5]);
-  store32(&out[14 * 4], state[14] ^ cv[6]);
-  store32(&out[15 * 4], state[15] ^ cv[7]);
-}
-
-INLINE void hash_one_portable(const uint8_t *input, size_t blocks,
-                              const uint32_t key[8], uint64_t counter,
-                              uint8_t flags, uint8_t flags_start,
-                              uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN]) {
-  uint32_t cv[8];
-  memcpy(cv, key, BLAKE3_KEY_LEN);
-  uint8_t block_flags = flags | flags_start;
-  while (blocks > 0) {
-    if (blocks == 1) {
-      block_flags |= flags_end;
-    }
-    blake3_compress_in_place_portable(cv, input, BLAKE3_BLOCK_LEN, counter,
-                                      block_flags);
-    input = &input[BLAKE3_BLOCK_LEN];
-    blocks -= 1;
-    block_flags = flags;
-  }
-  store_cv_words(out, cv);
-}
-
-void blake3_hash_many_portable(const uint8_t *const *inputs, size_t num_inputs,
-                               size_t blocks, const uint32_t key[8],
-                               uint64_t counter, bool increment_counter,
-                               uint8_t flags, uint8_t flags_start,
-                               uint8_t flags_end, uint8_t *out) {
-  while (num_inputs > 0) {
-    hash_one_portable(inputs[0], blocks, key, counter, flags, flags_start,
-                      flags_end, out);
-    if (increment_counter) {
-      counter += 1;
-    }
-    inputs += 1;
-    num_inputs -= 1;
-    out = &out[BLAKE3_OUT_LEN];
-  }
-}

external/blake3/blake3_sse2.c

@@ -1,566 +0,0 @@
-#include "blake3_impl.h"
-
-#include <immintrin.h>
-
-#define DEGREE 4
-
-#define _mm_shuffle_ps2(a, b, c)                                               \
-  (_mm_castps_si128(                                                           \
-      _mm_shuffle_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b), (c))))
-
-INLINE __m128i loadu(const uint8_t src[16]) {
-  return _mm_loadu_si128((const __m128i *)src);
-}
-
-INLINE void storeu(__m128i src, uint8_t dest[16]) {
-  _mm_storeu_si128((__m128i *)dest, src);
-}
-
-INLINE __m128i addv(__m128i a, __m128i b) { return _mm_add_epi32(a, b); }
-
-// Note that clang-format doesn't like the name "xor" for some reason.
-INLINE __m128i xorv(__m128i a, __m128i b) { return _mm_xor_si128(a, b); }
-
-INLINE __m128i set1(uint32_t x) { return _mm_set1_epi32((int32_t)x); }
-
-INLINE __m128i set4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
-  return _mm_setr_epi32((int32_t)a, (int32_t)b, (int32_t)c, (int32_t)d);
-}
-
-INLINE __m128i rot16(__m128i x) {
-  return _mm_shufflehi_epi16(_mm_shufflelo_epi16(x, 0xB1), 0xB1);
-}
-
-INLINE __m128i rot12(__m128i x) {
-  return xorv(_mm_srli_epi32(x, 12), _mm_slli_epi32(x, 32 - 12));
-}
-
-INLINE __m128i rot8(__m128i x) {
-  return xorv(_mm_srli_epi32(x, 8), _mm_slli_epi32(x, 32 - 8));
-}
-
-INLINE __m128i rot7(__m128i x) {
-  return xorv(_mm_srli_epi32(x, 7), _mm_slli_epi32(x, 32 - 7));
-}
-
-INLINE void g1(__m128i *row0, __m128i *row1, __m128i *row2, __m128i *row3,
-               __m128i m) {
-  *row0 = addv(addv(*row0, m), *row1);
-  *row3 = xorv(*row3, *row0);
-  *row3 = rot16(*row3);
-  *row2 = addv(*row2, *row3);
-  *row1 = xorv(*row1, *row2);
-  *row1 = rot12(*row1);
-}
-
-INLINE void g2(__m128i *row0, __m128i *row1, __m128i *row2, __m128i *row3,
-               __m128i m) {
-  *row0 = addv(addv(*row0, m), *row1);
-  *row3 = xorv(*row3, *row0);
-  *row3 = rot8(*row3);
-  *row2 = addv(*row2, *row3);
-  *row1 = xorv(*row1, *row2);
-  *row1 = rot7(*row1);
-}
-
-// Note the optimization here of leaving row1 as the unrotated row, rather than
-// row0. All the message loads below are adjusted to compensate for this. See
-// discussion at https://github.com/sneves/blake2-avx2/pull/4
-INLINE void diagonalize(__m128i *row0, __m128i *row2, __m128i *row3) {
-  *row0 = _mm_shuffle_epi32(*row0, _MM_SHUFFLE(2, 1, 0, 3));
-  *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE(1, 0, 3, 2));
-  *row2 = _mm_shuffle_epi32(*row2, _MM_SHUFFLE(0, 3, 2, 1));
-}
-
-INLINE void undiagonalize(__m128i *row0, __m128i *row2, __m128i *row3) {
-  *row0 = _mm_shuffle_epi32(*row0, _MM_SHUFFLE(0, 3, 2, 1));
-  *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE(1, 0, 3, 2));
-  *row2 = _mm_shuffle_epi32(*row2, _MM_SHUFFLE(2, 1, 0, 3));
-}
-
-INLINE __m128i blend_epi16(__m128i a, __m128i b, const int16_t imm8) {
-  const __m128i bits = _mm_set_epi16(0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01);
-  __m128i mask = _mm_set1_epi16(imm8);
-  mask = _mm_and_si128(mask, bits);
-  mask = _mm_cmpeq_epi16(mask, bits);
-  return _mm_or_si128(_mm_and_si128(mask, b), _mm_andnot_si128(mask, a));
-}
-
-INLINE void compress_pre(__m128i rows[4], const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags) {
-  rows[0] = loadu((uint8_t *)&cv[0]);
-  rows[1] = loadu((uint8_t *)&cv[4]);
-  rows[2] = set4(IV[0], IV[1], IV[2], IV[3]);
-  rows[3] = set4(counter_low(counter), counter_high(counter),
-                 (uint32_t)block_len, (uint32_t)flags);
-
-  __m128i m0 = loadu(&block[sizeof(__m128i) * 0]);
-  __m128i m1 = loadu(&block[sizeof(__m128i) * 1]);
-  __m128i m2 = loadu(&block[sizeof(__m128i) * 2]);
-  __m128i m3 = loadu(&block[sizeof(__m128i) * 3]);
-
-  __m128i t0, t1, t2, t3, tt;
-
-  // Round 1. The first round permutes the message words from the original
-  // input order, into the groups that get mixed in parallel.
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(2, 0, 2, 0)); //  6  4  2  0
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 3, 1)); //  7  5  3  1
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(2, 0, 2, 0)); // 14 12 10  8
-  t2 = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2, 1, 0, 3));   // 12 10  8 14
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 1, 3, 1)); // 15 13 11  9
-  t3 = _mm_shuffle_epi32(t3, _MM_SHUFFLE(2, 1, 0, 3));   // 13 11  9 15
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 2. This round and all following rounds apply a fixed permutation
-  // to the message words from the round before.
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 3
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 4
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 5
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 6
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 7
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-}
-
-void blake3_compress_in_place_sse2(uint32_t cv[8],
-                                   const uint8_t block[BLAKE3_BLOCK_LEN],
-                                   uint8_t block_len, uint64_t counter,
-                                   uint8_t flags) {
-  __m128i rows[4];
-  compress_pre(rows, cv, block, block_len, counter, flags);
-  storeu(xorv(rows[0], rows[2]), (uint8_t *)&cv[0]);
-  storeu(xorv(rows[1], rows[3]), (uint8_t *)&cv[4]);
-}
-
-void blake3_compress_xof_sse2(const uint32_t cv[8],
-                              const uint8_t block[BLAKE3_BLOCK_LEN],
-                              uint8_t block_len, uint64_t counter,
-                              uint8_t flags, uint8_t out[64]) {
-  __m128i rows[4];
-  compress_pre(rows, cv, block, block_len, counter, flags);
-  storeu(xorv(rows[0], rows[2]), &out[0]);
-  storeu(xorv(rows[1], rows[3]), &out[16]);
-  storeu(xorv(rows[2], loadu((uint8_t *)&cv[0])), &out[32]);
-  storeu(xorv(rows[3], loadu((uint8_t *)&cv[4])), &out[48]);
-}
-
-INLINE void round_fn(__m128i v[16], __m128i m[16], size_t r) {
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][0]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][2]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][4]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][6]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[15] = rot16(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot12(v[4]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][1]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][3]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][5]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][7]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[15] = rot8(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot7(v[4]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][8]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][10]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][12]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][14]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot16(v[15]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[4] = rot12(v[4]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][9]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][11]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][13]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][15]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot8(v[15]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-  v[4] = rot7(v[4]);
-}
-
-INLINE void transpose_vecs(__m128i vecs[DEGREE]) {
-  // Interleave 32-bit lanes. The low unpack is lanes 00/11 and the high is
-  // 22/33. Note that this doesn't split the vector into two lanes, as the
-  // AVX2 counterparts do.
-  __m128i ab_01 = _mm_unpacklo_epi32(vecs[0], vecs[1]);
-  __m128i ab_23 = _mm_unpackhi_epi32(vecs[0], vecs[1]);
-  __m128i cd_01 = _mm_unpacklo_epi32(vecs[2], vecs[3]);
-  __m128i cd_23 = _mm_unpackhi_epi32(vecs[2], vecs[3]);
-
-  // Interleave 64-bit lanes.
-  __m128i abcd_0 = _mm_unpacklo_epi64(ab_01, cd_01);
-  __m128i abcd_1 = _mm_unpackhi_epi64(ab_01, cd_01);
-  __m128i abcd_2 = _mm_unpacklo_epi64(ab_23, cd_23);
-  __m128i abcd_3 = _mm_unpackhi_epi64(ab_23, cd_23);
-
-  vecs[0] = abcd_0;
-  vecs[1] = abcd_1;
-  vecs[2] = abcd_2;
-  vecs[3] = abcd_3;
-}
-
-INLINE void transpose_msg_vecs(const uint8_t *const *inputs,
-                               size_t block_offset, __m128i out[16]) {
-  out[0] = loadu(&inputs[0][block_offset + 0 * sizeof(__m128i)]);
-  out[1] = loadu(&inputs[1][block_offset + 0 * sizeof(__m128i)]);
-  out[2] = loadu(&inputs[2][block_offset + 0 * sizeof(__m128i)]);
-  out[3] = loadu(&inputs[3][block_offset + 0 * sizeof(__m128i)]);
-  out[4] = loadu(&inputs[0][block_offset + 1 * sizeof(__m128i)]);
-  out[5] = loadu(&inputs[1][block_offset + 1 * sizeof(__m128i)]);
-  out[6] = loadu(&inputs[2][block_offset + 1 * sizeof(__m128i)]);
-  out[7] = loadu(&inputs[3][block_offset + 1 * sizeof(__m128i)]);
-  out[8] = loadu(&inputs[0][block_offset + 2 * sizeof(__m128i)]);
-  out[9] = loadu(&inputs[1][block_offset + 2 * sizeof(__m128i)]);
-  out[10] = loadu(&inputs[2][block_offset + 2 * sizeof(__m128i)]);
-  out[11] = loadu(&inputs[3][block_offset + 2 * sizeof(__m128i)]);
-  out[12] = loadu(&inputs[0][block_offset + 3 * sizeof(__m128i)]);
-  out[13] = loadu(&inputs[1][block_offset + 3 * sizeof(__m128i)]);
-  out[14] = loadu(&inputs[2][block_offset + 3 * sizeof(__m128i)]);
-  out[15] = loadu(&inputs[3][block_offset + 3 * sizeof(__m128i)]);
-  for (size_t i = 0; i < 4; ++i) {
-    _mm_prefetch((const void *)&inputs[i][block_offset + 256], _MM_HINT_T0);
-  }
-  transpose_vecs(&out[0]);
-  transpose_vecs(&out[4]);
-  transpose_vecs(&out[8]);
-  transpose_vecs(&out[12]);
-}
-
-INLINE void load_counters(uint64_t counter, bool increment_counter,
-                          __m128i *out_lo, __m128i *out_hi) {
-  const __m128i mask = _mm_set1_epi32(-(int32_t)increment_counter);
-  const __m128i add0 = _mm_set_epi32(3, 2, 1, 0);
-  const __m128i add1 = _mm_and_si128(mask, add0);
-  __m128i l = _mm_add_epi32(_mm_set1_epi32((int32_t)counter), add1);
-  __m128i carry = _mm_cmpgt_epi32(_mm_xor_si128(add1, _mm_set1_epi32(0x80000000)), 
-                                  _mm_xor_si128(   l, _mm_set1_epi32(0x80000000)));
-  __m128i h = _mm_sub_epi32(_mm_set1_epi32((int32_t)(counter >> 32)), carry);
-  *out_lo = l;
-  *out_hi = h;
-}
-
-static
-void blake3_hash4_sse2(const uint8_t *const *inputs, size_t blocks,
-                       const uint32_t key[8], uint64_t counter,
-                       bool increment_counter, uint8_t flags,
-                       uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-  __m128i h_vecs[8] = {
-      set1(key[0]), set1(key[1]), set1(key[2]), set1(key[3]),
-      set1(key[4]), set1(key[5]), set1(key[6]), set1(key[7]),
-  };
-  __m128i counter_low_vec, counter_high_vec;
-  load_counters(counter, increment_counter, &counter_low_vec,
-                &counter_high_vec);
-  uint8_t block_flags = flags | flags_start;
-
-  for (size_t block = 0; block < blocks; block++) {
-    if (block + 1 == blocks) {
-      block_flags |= flags_end;
-    }
-    __m128i block_len_vec = set1(BLAKE3_BLOCK_LEN);
-    __m128i block_flags_vec = set1(block_flags);
-    __m128i msg_vecs[16];
-    transpose_msg_vecs(inputs, block * BLAKE3_BLOCK_LEN, msg_vecs);
-
-    __m128i v[16] = {
-        h_vecs[0],       h_vecs[1],        h_vecs[2],     h_vecs[3],
-        h_vecs[4],       h_vecs[5],        h_vecs[6],     h_vecs[7],
-        set1(IV[0]),     set1(IV[1]),      set1(IV[2]),   set1(IV[3]),
-        counter_low_vec, counter_high_vec, block_len_vec, block_flags_vec,
-    };
-    round_fn(v, msg_vecs, 0);
-    round_fn(v, msg_vecs, 1);
-    round_fn(v, msg_vecs, 2);
-    round_fn(v, msg_vecs, 3);
-    round_fn(v, msg_vecs, 4);
-    round_fn(v, msg_vecs, 5);
-    round_fn(v, msg_vecs, 6);
-    h_vecs[0] = xorv(v[0], v[8]);
-    h_vecs[1] = xorv(v[1], v[9]);
-    h_vecs[2] = xorv(v[2], v[10]);
-    h_vecs[3] = xorv(v[3], v[11]);
-    h_vecs[4] = xorv(v[4], v[12]);
-    h_vecs[5] = xorv(v[5], v[13]);
-    h_vecs[6] = xorv(v[6], v[14]);
-    h_vecs[7] = xorv(v[7], v[15]);
-
-    block_flags = flags;
-  }
-
-  transpose_vecs(&h_vecs[0]);
-  transpose_vecs(&h_vecs[4]);
-  // The first four vecs now contain the first half of each output, and the
-  // second four vecs contain the second half of each output.
-  storeu(h_vecs[0], &out[0 * sizeof(__m128i)]);
-  storeu(h_vecs[4], &out[1 * sizeof(__m128i)]);
-  storeu(h_vecs[1], &out[2 * sizeof(__m128i)]);
-  storeu(h_vecs[5], &out[3 * sizeof(__m128i)]);
-  storeu(h_vecs[2], &out[4 * sizeof(__m128i)]);
-  storeu(h_vecs[6], &out[5 * sizeof(__m128i)]);
-  storeu(h_vecs[3], &out[6 * sizeof(__m128i)]);
-  storeu(h_vecs[7], &out[7 * sizeof(__m128i)]);
-}
-
-INLINE void hash_one_sse2(const uint8_t *input, size_t blocks,
-                          const uint32_t key[8], uint64_t counter,
-                          uint8_t flags, uint8_t flags_start,
-                          uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN]) {
-  uint32_t cv[8];
-  memcpy(cv, key, BLAKE3_KEY_LEN);
-  uint8_t block_flags = flags | flags_start;
-  while (blocks > 0) {
-    if (blocks == 1) {
-      block_flags |= flags_end;
-    }
-    blake3_compress_in_place_sse2(cv, input, BLAKE3_BLOCK_LEN, counter,
-                                  block_flags);
-    input = &input[BLAKE3_BLOCK_LEN];
-    blocks -= 1;
-    block_flags = flags;
-  }
-  memcpy(out, cv, BLAKE3_OUT_LEN);
-}
-
-void blake3_hash_many_sse2(const uint8_t *const *inputs, size_t num_inputs,
-                           size_t blocks, const uint32_t key[8],
-                           uint64_t counter, bool increment_counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t *out) {
-  while (num_inputs >= DEGREE) {
-    blake3_hash4_sse2(inputs, blocks, key, counter, increment_counter, flags,
-                      flags_start, flags_end, out);
-    if (increment_counter) {
-      counter += DEGREE;
-    }
-    inputs += DEGREE;
-    num_inputs -= DEGREE;
-    out = &out[DEGREE * BLAKE3_OUT_LEN];
-  }
-  while (num_inputs > 0) {
-    hash_one_sse2(inputs[0], blocks, key, counter, flags, flags_start,
-                  flags_end, out);
-    if (increment_counter) {
-      counter += 1;
-    }
-    inputs += 1;
-    num_inputs -= 1;
-    out = &out[BLAKE3_OUT_LEN];
-  }
-}

external/blake3/blake3_sse41.c

@@ -1,560 +0,0 @@
-#include "blake3_impl.h"
-
-#include <immintrin.h>
-
-#define DEGREE 4
-
-#define _mm_shuffle_ps2(a, b, c)                                               \
-  (_mm_castps_si128(                                                           \
-      _mm_shuffle_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b), (c))))
-
-INLINE __m128i loadu(const uint8_t src[16]) {
-  return _mm_loadu_si128((const __m128i *)src);
-}
-
-INLINE void storeu(__m128i src, uint8_t dest[16]) {
-  _mm_storeu_si128((__m128i *)dest, src);
-}
-
-INLINE __m128i addv(__m128i a, __m128i b) { return _mm_add_epi32(a, b); }
-
-// Note that clang-format doesn't like the name "xor" for some reason.
-INLINE __m128i xorv(__m128i a, __m128i b) { return _mm_xor_si128(a, b); }
-
-INLINE __m128i set1(uint32_t x) { return _mm_set1_epi32((int32_t)x); }
-
-INLINE __m128i set4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
-  return _mm_setr_epi32((int32_t)a, (int32_t)b, (int32_t)c, (int32_t)d);
-}
-
-INLINE __m128i rot16(__m128i x) {
-  return _mm_shuffle_epi8(
-      x, _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2));
-}
-
-INLINE __m128i rot12(__m128i x) {
-  return xorv(_mm_srli_epi32(x, 12), _mm_slli_epi32(x, 32 - 12));
-}
-
-INLINE __m128i rot8(__m128i x) {
-  return _mm_shuffle_epi8(
-      x, _mm_set_epi8(12, 15, 14, 13, 8, 11, 10, 9, 4, 7, 6, 5, 0, 3, 2, 1));
-}
-
-INLINE __m128i rot7(__m128i x) {
-  return xorv(_mm_srli_epi32(x, 7), _mm_slli_epi32(x, 32 - 7));
-}
-
-INLINE void g1(__m128i *row0, __m128i *row1, __m128i *row2, __m128i *row3,
-               __m128i m) {
-  *row0 = addv(addv(*row0, m), *row1);
-  *row3 = xorv(*row3, *row0);
-  *row3 = rot16(*row3);
-  *row2 = addv(*row2, *row3);
-  *row1 = xorv(*row1, *row2);
-  *row1 = rot12(*row1);
-}
-
-INLINE void g2(__m128i *row0, __m128i *row1, __m128i *row2, __m128i *row3,
-               __m128i m) {
-  *row0 = addv(addv(*row0, m), *row1);
-  *row3 = xorv(*row3, *row0);
-  *row3 = rot8(*row3);
-  *row2 = addv(*row2, *row3);
-  *row1 = xorv(*row1, *row2);
-  *row1 = rot7(*row1);
-}
-
-// Note the optimization here of leaving row1 as the unrotated row, rather than
-// row0. All the message loads below are adjusted to compensate for this. See
-// discussion at https://github.com/sneves/blake2-avx2/pull/4
-INLINE void diagonalize(__m128i *row0, __m128i *row2, __m128i *row3) {
-  *row0 = _mm_shuffle_epi32(*row0, _MM_SHUFFLE(2, 1, 0, 3));
-  *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE(1, 0, 3, 2));
-  *row2 = _mm_shuffle_epi32(*row2, _MM_SHUFFLE(0, 3, 2, 1));
-}
-
-INLINE void undiagonalize(__m128i *row0, __m128i *row2, __m128i *row3) {
-  *row0 = _mm_shuffle_epi32(*row0, _MM_SHUFFLE(0, 3, 2, 1));
-  *row3 = _mm_shuffle_epi32(*row3, _MM_SHUFFLE(1, 0, 3, 2));
-  *row2 = _mm_shuffle_epi32(*row2, _MM_SHUFFLE(2, 1, 0, 3));
-}
-
-INLINE void compress_pre(__m128i rows[4], const uint32_t cv[8],
-                         const uint8_t block[BLAKE3_BLOCK_LEN],
-                         uint8_t block_len, uint64_t counter, uint8_t flags) {
-  rows[0] = loadu((uint8_t *)&cv[0]);
-  rows[1] = loadu((uint8_t *)&cv[4]);
-  rows[2] = set4(IV[0], IV[1], IV[2], IV[3]);
-  rows[3] = set4(counter_low(counter), counter_high(counter),
-                 (uint32_t)block_len, (uint32_t)flags);
-
-  __m128i m0 = loadu(&block[sizeof(__m128i) * 0]);
-  __m128i m1 = loadu(&block[sizeof(__m128i) * 1]);
-  __m128i m2 = loadu(&block[sizeof(__m128i) * 2]);
-  __m128i m3 = loadu(&block[sizeof(__m128i) * 3]);
-
-  __m128i t0, t1, t2, t3, tt;
-
-  // Round 1. The first round permutes the message words from the original
-  // input order, into the groups that get mixed in parallel.
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(2, 0, 2, 0)); //  6  4  2  0
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 3, 1)); //  7  5  3  1
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(2, 0, 2, 0)); // 14 12 10  8
-  t2 = _mm_shuffle_epi32(t2, _MM_SHUFFLE(2, 1, 0, 3));   // 12 10  8 14
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 1, 3, 1)); // 15 13 11  9
-  t3 = _mm_shuffle_epi32(t3, _MM_SHUFFLE(2, 1, 0, 3));   // 13 11  9 15
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 2. This round and all following rounds apply a fixed permutation
-  // to the message words from the round before.
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 3
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 4
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 5
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 6
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-  m0 = t0;
-  m1 = t1;
-  m2 = t2;
-  m3 = t3;
-
-  // Round 7
-  t0 = _mm_shuffle_ps2(m0, m1, _MM_SHUFFLE(3, 1, 1, 2));
-  t0 = _mm_shuffle_epi32(t0, _MM_SHUFFLE(0, 3, 2, 1));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t0);
-  t1 = _mm_shuffle_ps2(m2, m3, _MM_SHUFFLE(3, 3, 2, 2));
-  tt = _mm_shuffle_epi32(m0, _MM_SHUFFLE(0, 0, 3, 3));
-  t1 = _mm_blend_epi16(tt, t1, 0xCC);
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t1);
-  diagonalize(&rows[0], &rows[2], &rows[3]);
-  t2 = _mm_unpacklo_epi64(m3, m1);
-  tt = _mm_blend_epi16(t2, m2, 0xC0);
-  t2 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(1, 3, 2, 0));
-  g1(&rows[0], &rows[1], &rows[2], &rows[3], t2);
-  t3 = _mm_unpackhi_epi32(m1, m3);
-  tt = _mm_unpacklo_epi32(m2, t3);
-  t3 = _mm_shuffle_epi32(tt, _MM_SHUFFLE(0, 1, 3, 2));
-  g2(&rows[0], &rows[1], &rows[2], &rows[3], t3);
-  undiagonalize(&rows[0], &rows[2], &rows[3]);
-}
-
-void blake3_compress_in_place_sse41(uint32_t cv[8],
-                                    const uint8_t block[BLAKE3_BLOCK_LEN],
-                                    uint8_t block_len, uint64_t counter,
-                                    uint8_t flags) {
-  __m128i rows[4];
-  compress_pre(rows, cv, block, block_len, counter, flags);
-  storeu(xorv(rows[0], rows[2]), (uint8_t *)&cv[0]);
-  storeu(xorv(rows[1], rows[3]), (uint8_t *)&cv[4]);
-}
-
-void blake3_compress_xof_sse41(const uint32_t cv[8],
-                               const uint8_t block[BLAKE3_BLOCK_LEN],
-                               uint8_t block_len, uint64_t counter,
-                               uint8_t flags, uint8_t out[64]) {
-  __m128i rows[4];
-  compress_pre(rows, cv, block, block_len, counter, flags);
-  storeu(xorv(rows[0], rows[2]), &out[0]);
-  storeu(xorv(rows[1], rows[3]), &out[16]);
-  storeu(xorv(rows[2], loadu((uint8_t *)&cv[0])), &out[32]);
-  storeu(xorv(rows[3], loadu((uint8_t *)&cv[4])), &out[48]);
-}
-
-INLINE void round_fn(__m128i v[16], __m128i m[16], size_t r) {
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][0]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][2]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][4]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][6]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[15] = rot16(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot12(v[4]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][1]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][3]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][5]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][7]]);
-  v[0] = addv(v[0], v[4]);
-  v[1] = addv(v[1], v[5]);
-  v[2] = addv(v[2], v[6]);
-  v[3] = addv(v[3], v[7]);
-  v[12] = xorv(v[12], v[0]);
-  v[13] = xorv(v[13], v[1]);
-  v[14] = xorv(v[14], v[2]);
-  v[15] = xorv(v[15], v[3]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[15] = rot8(v[15]);
-  v[8] = addv(v[8], v[12]);
-  v[9] = addv(v[9], v[13]);
-  v[10] = addv(v[10], v[14]);
-  v[11] = addv(v[11], v[15]);
-  v[4] = xorv(v[4], v[8]);
-  v[5] = xorv(v[5], v[9]);
-  v[6] = xorv(v[6], v[10]);
-  v[7] = xorv(v[7], v[11]);
-  v[4] = rot7(v[4]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][8]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][10]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][12]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][14]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot16(v[15]);
-  v[12] = rot16(v[12]);
-  v[13] = rot16(v[13]);
-  v[14] = rot16(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot12(v[5]);
-  v[6] = rot12(v[6]);
-  v[7] = rot12(v[7]);
-  v[4] = rot12(v[4]);
-  v[0] = addv(v[0], m[(size_t)MSG_SCHEDULE[r][9]]);
-  v[1] = addv(v[1], m[(size_t)MSG_SCHEDULE[r][11]]);
-  v[2] = addv(v[2], m[(size_t)MSG_SCHEDULE[r][13]]);
-  v[3] = addv(v[3], m[(size_t)MSG_SCHEDULE[r][15]]);
-  v[0] = addv(v[0], v[5]);
-  v[1] = addv(v[1], v[6]);
-  v[2] = addv(v[2], v[7]);
-  v[3] = addv(v[3], v[4]);
-  v[15] = xorv(v[15], v[0]);
-  v[12] = xorv(v[12], v[1]);
-  v[13] = xorv(v[13], v[2]);
-  v[14] = xorv(v[14], v[3]);
-  v[15] = rot8(v[15]);
-  v[12] = rot8(v[12]);
-  v[13] = rot8(v[13]);
-  v[14] = rot8(v[14]);
-  v[10] = addv(v[10], v[15]);
-  v[11] = addv(v[11], v[12]);
-  v[8] = addv(v[8], v[13]);
-  v[9] = addv(v[9], v[14]);
-  v[5] = xorv(v[5], v[10]);
-  v[6] = xorv(v[6], v[11]);
-  v[7] = xorv(v[7], v[8]);
-  v[4] = xorv(v[4], v[9]);
-  v[5] = rot7(v[5]);
-  v[6] = rot7(v[6]);
-  v[7] = rot7(v[7]);
-  v[4] = rot7(v[4]);
-}
-
-INLINE void transpose_vecs(__m128i vecs[DEGREE]) {
-  // Interleave 32-bit lanes. The low unpack is lanes 00/11 and the high is
-  // 22/33. Note that this doesn't split the vector into two lanes, as the
-  // AVX2 counterparts do.
-  __m128i ab_01 = _mm_unpacklo_epi32(vecs[0], vecs[1]);
-  __m128i ab_23 = _mm_unpackhi_epi32(vecs[0], vecs[1]);
-  __m128i cd_01 = _mm_unpacklo_epi32(vecs[2], vecs[3]);
-  __m128i cd_23 = _mm_unpackhi_epi32(vecs[2], vecs[3]);
-
-  // Interleave 64-bit lanes.
-  __m128i abcd_0 = _mm_unpacklo_epi64(ab_01, cd_01);
-  __m128i abcd_1 = _mm_unpackhi_epi64(ab_01, cd_01);
-  __m128i abcd_2 = _mm_unpacklo_epi64(ab_23, cd_23);
-  __m128i abcd_3 = _mm_unpackhi_epi64(ab_23, cd_23);
-
-  vecs[0] = abcd_0;
-  vecs[1] = abcd_1;
-  vecs[2] = abcd_2;
-  vecs[3] = abcd_3;
-}
-
-INLINE void transpose_msg_vecs(const uint8_t *const *inputs,
-                               size_t block_offset, __m128i out[16]) {
-  out[0] = loadu(&inputs[0][block_offset + 0 * sizeof(__m128i)]);
-  out[1] = loadu(&inputs[1][block_offset + 0 * sizeof(__m128i)]);
-  out[2] = loadu(&inputs[2][block_offset + 0 * sizeof(__m128i)]);
-  out[3] = loadu(&inputs[3][block_offset + 0 * sizeof(__m128i)]);
-  out[4] = loadu(&inputs[0][block_offset + 1 * sizeof(__m128i)]);
-  out[5] = loadu(&inputs[1][block_offset + 1 * sizeof(__m128i)]);
-  out[6] = loadu(&inputs[2][block_offset + 1 * sizeof(__m128i)]);
-  out[7] = loadu(&inputs[3][block_offset + 1 * sizeof(__m128i)]);
-  out[8] = loadu(&inputs[0][block_offset + 2 * sizeof(__m128i)]);
-  out[9] = loadu(&inputs[1][block_offset + 2 * sizeof(__m128i)]);
-  out[10] = loadu(&inputs[2][block_offset + 2 * sizeof(__m128i)]);
-  out[11] = loadu(&inputs[3][block_offset + 2 * sizeof(__m128i)]);
-  out[12] = loadu(&inputs[0][block_offset + 3 * sizeof(__m128i)]);
-  out[13] = loadu(&inputs[1][block_offset + 3 * sizeof(__m128i)]);
-  out[14] = loadu(&inputs[2][block_offset + 3 * sizeof(__m128i)]);
-  out[15] = loadu(&inputs[3][block_offset + 3 * sizeof(__m128i)]);
-  for (size_t i = 0; i < 4; ++i) {
-    _mm_prefetch((const void *)&inputs[i][block_offset + 256], _MM_HINT_T0);
-  }
-  transpose_vecs(&out[0]);
-  transpose_vecs(&out[4]);
-  transpose_vecs(&out[8]);
-  transpose_vecs(&out[12]);
-}
-
-INLINE void load_counters(uint64_t counter, bool increment_counter,
-                          __m128i *out_lo, __m128i *out_hi) {
-  const __m128i mask = _mm_set1_epi32(-(int32_t)increment_counter);
-  const __m128i add0 = _mm_set_epi32(3, 2, 1, 0);
-  const __m128i add1 = _mm_and_si128(mask, add0);
-  __m128i l = _mm_add_epi32(_mm_set1_epi32((int32_t)counter), add1);
-  __m128i carry = _mm_cmpgt_epi32(_mm_xor_si128(add1, _mm_set1_epi32(0x80000000)), 
-                                  _mm_xor_si128(   l, _mm_set1_epi32(0x80000000)));
-  __m128i h = _mm_sub_epi32(_mm_set1_epi32((int32_t)(counter >> 32)), carry);
-  *out_lo = l;
-  *out_hi = h;
-}
-
-static
-void blake3_hash4_sse41(const uint8_t *const *inputs, size_t blocks,
-                        const uint32_t key[8], uint64_t counter,
-                        bool increment_counter, uint8_t flags,
-                        uint8_t flags_start, uint8_t flags_end, uint8_t *out) {
-  __m128i h_vecs[8] = {
-      set1(key[0]), set1(key[1]), set1(key[2]), set1(key[3]),
-      set1(key[4]), set1(key[5]), set1(key[6]), set1(key[7]),
-  };
-  __m128i counter_low_vec, counter_high_vec;
-  load_counters(counter, increment_counter, &counter_low_vec,
-                &counter_high_vec);
-  uint8_t block_flags = flags | flags_start;
-
-  for (size_t block = 0; block < blocks; block++) {
-    if (block + 1 == blocks) {
-      block_flags |= flags_end;
-    }
-    __m128i block_len_vec = set1(BLAKE3_BLOCK_LEN);
-    __m128i block_flags_vec = set1(block_flags);
-    __m128i msg_vecs[16];
-    transpose_msg_vecs(inputs, block * BLAKE3_BLOCK_LEN, msg_vecs);
-
-    __m128i v[16] = {
-        h_vecs[0],       h_vecs[1],        h_vecs[2],     h_vecs[3],
-        h_vecs[4],       h_vecs[5],        h_vecs[6],     h_vecs[7],
-        set1(IV[0]),     set1(IV[1]),      set1(IV[2]),   set1(IV[3]),
-        counter_low_vec, counter_high_vec, block_len_vec, block_flags_vec,
-    };
-    round_fn(v, msg_vecs, 0);
-    round_fn(v, msg_vecs, 1);
-    round_fn(v, msg_vecs, 2);
-    round_fn(v, msg_vecs, 3);
-    round_fn(v, msg_vecs, 4);
-    round_fn(v, msg_vecs, 5);
-    round_fn(v, msg_vecs, 6);
-    h_vecs[0] = xorv(v[0], v[8]);
-    h_vecs[1] = xorv(v[1], v[9]);
-    h_vecs[2] = xorv(v[2], v[10]);
-    h_vecs[3] = xorv(v[3], v[11]);
-    h_vecs[4] = xorv(v[4], v[12]);
-    h_vecs[5] = xorv(v[5], v[13]);
-    h_vecs[6] = xorv(v[6], v[14]);
-    h_vecs[7] = xorv(v[7], v[15]);
-
-    block_flags = flags;
-  }
-
-  transpose_vecs(&h_vecs[0]);
-  transpose_vecs(&h_vecs[4]);
-  // The first four vecs now contain the first half of each output, and the
-  // second four vecs contain the second half of each output.
-  storeu(h_vecs[0], &out[0 * sizeof(__m128i)]);
-  storeu(h_vecs[4], &out[1 * sizeof(__m128i)]);
-  storeu(h_vecs[1], &out[2 * sizeof(__m128i)]);
-  storeu(h_vecs[5], &out[3 * sizeof(__m128i)]);
-  storeu(h_vecs[2], &out[4 * sizeof(__m128i)]);
-  storeu(h_vecs[6], &out[5 * sizeof(__m128i)]);
-  storeu(h_vecs[3], &out[6 * sizeof(__m128i)]);
-  storeu(h_vecs[7], &out[7 * sizeof(__m128i)]);
-}
-
-INLINE void hash_one_sse41(const uint8_t *input, size_t blocks,
-                           const uint32_t key[8], uint64_t counter,
-                           uint8_t flags, uint8_t flags_start,
-                           uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN]) {
-  uint32_t cv[8];
-  memcpy(cv, key, BLAKE3_KEY_LEN);
-  uint8_t block_flags = flags | flags_start;
-  while (blocks > 0) {
-    if (blocks == 1) {
-      block_flags |= flags_end;
-    }
-    blake3_compress_in_place_sse41(cv, input, BLAKE3_BLOCK_LEN, counter,
-                                   block_flags);
-    input = &input[BLAKE3_BLOCK_LEN];
-    blocks -= 1;
-    block_flags = flags;
-  }
-  memcpy(out, cv, BLAKE3_OUT_LEN);
-}
-
-void blake3_hash_many_sse41(const uint8_t *const *inputs, size_t num_inputs,
-                            size_t blocks, const uint32_t key[8],
-                            uint64_t counter, bool increment_counter,
-                            uint8_t flags, uint8_t flags_start,
-                            uint8_t flags_end, uint8_t *out) {
-  while (num_inputs >= DEGREE) {
-    blake3_hash4_sse41(inputs, blocks, key, counter, increment_counter, flags,
-                       flags_start, flags_end, out);
-    if (increment_counter) {
-      counter += DEGREE;
-    }
-    inputs += DEGREE;
-    num_inputs -= DEGREE;
-    out = &out[DEGREE * BLAKE3_OUT_LEN];
-  }
-  while (num_inputs > 0) {
-    hash_one_sse41(inputs[0], blocks, key, counter, flags, flags_start,
-                   flags_end, out);
-    if (increment_counter) {
-      counter += 1;
-    }
-    inputs += 1;
-    num_inputs -= 1;
-    out = &out[BLAKE3_OUT_LEN];
-  }
-}

external/blake3/blake3_tbb.cpp

@@ -1,37 +0,0 @@
-#include <cstddef>
-#include <cstdint>
-
-#include <oneapi/tbb/parallel_invoke.h>
-
-#include "blake3_impl.h"
-
-static_assert(TBB_USE_EXCEPTIONS == 0,
-              "This file should be compiled with C++ exceptions disabled.");
-
-extern "C" void blake3_compress_subtree_wide_join_tbb(
-    // shared params
-    const uint32_t key[8], uint8_t flags, bool use_tbb,
-    // left-hand side params
-    const uint8_t *l_input, size_t l_input_len, uint64_t l_chunk_counter,
-    uint8_t *l_cvs, size_t *l_n,
-    // right-hand side params
-    const uint8_t *r_input, size_t r_input_len, uint64_t r_chunk_counter,
-    uint8_t *r_cvs, size_t *r_n) noexcept {
-  if (!use_tbb) {
-    *l_n = blake3_compress_subtree_wide(l_input, l_input_len, key,
-                                        l_chunk_counter, flags, l_cvs, use_tbb);
-    *r_n = blake3_compress_subtree_wide(r_input, r_input_len, key,
-                                        r_chunk_counter, flags, r_cvs, use_tbb);
-    return;
-  }
-
-  oneapi::tbb::parallel_invoke(
-      [=]() {
-        *l_n = blake3_compress_subtree_wide(
-            l_input, l_input_len, key, l_chunk_counter, flags, l_cvs, use_tbb);
-      },
-      [=]() {
-        *r_n = blake3_compress_subtree_wide(
-            r_input, r_input_len, key, r_chunk_counter, flags, r_cvs, use_tbb);
-      });
-}

external/blake3/cmake/BLAKE3/ContinuousIntegration.cmake

@@ -1,235 +0,0 @@
-cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
-
-if(BUILD_SHARED_LIBS)
-  message(FATAL_ERROR "BUILD_SHARED_LIBS is incompatible with BLAKE3_TESTING_CI")
-endif()
-
-include(CTest)
-
-# Declare a testing specific variant of the `blake3` library target.
-#
-# We use a separate library target in order to be able to perform compilation with various
-# combinations of features which are too noisy to specify in the main CMake config as options for
-# the normal `blake3` target.
-#
-# Initially this target has no properties but eventually we will populate them by copying all of the
-# relevant properties from the normal `blake3` target.
-add_library(blake3-testing
-  blake3.c
-  blake3_dispatch.c
-  blake3_portable.c
-)
-
-if(BLAKE3_USE_TBB AND TBB_FOUND)
-  target_sources(blake3-testing
-    PRIVATE
-      blake3_tbb.cpp)
-endif()
-
-if(BLAKE3_SIMD_TYPE STREQUAL "amd64-asm")
-  # Conditionally add amd64 asm files to `blake3-testing` sources
-  if(MSVC)
-    if(NOT BLAKE3_NO_AVX2)
-      list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx2_x86-64_windows_msvc.asm)
-    endif()
-    if(NOT BLAKE3_NO_AVX512)
-      list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx512_x86-64_windows_msvc.asm)
-    endif()
-    if(NOT BLAKE3_NO_SSE2)
-      list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse2_x86-64_windows_msvc.asm)
-    endif()
-    if(NOT BLAKE3_NO_SSE41)
-      list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse41_x86-64_windows_msvc.asm)
-    endif()
-  elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU"
-        OR CMAKE_C_COMPILER_ID STREQUAL "Clang"
-        OR CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
-    if (WIN32)
-      if(NOT BLAKE3_NO_AVX2)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx2_x86-64_windows_gnu.S)
-      endif()
-      if(NOT BLAKE3_NO_AVX512)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx512_x86-64_windows_gnu.S)
-      endif()
-      if(NOT BLAKE3_NO_SSE2)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse2_x86-64_windows_gnu.S)
-      endif()
-      if(NOT BLAKE3_NO_SSE41)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse41_x86-64_windows_gnu.S)
-      endif()
-    elseif(UNIX)
-      if(NOT BLAKE3_NO_AVX2)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx2_x86-64_unix.S)
-      endif()
-      if(NOT BLAKE3_NO_AVX512)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_avx512_x86-64_unix.S)
-      endif()
-      if(NOT BLAKE3_NO_SSE2)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse2_x86-64_unix.S)
-      endif()
-      if(NOT BLAKE3_NO_SSE41)
-        list(APPEND BLAKE3_TESTING_AMD64_ASM_SOURCES blake3_sse41_x86-64_unix.S)
-      endif()
-    endif()
-  endif()
-  target_sources(blake3-testing PRIVATE ${BLAKE3_AMD64_ASM_SOURCES})
-elseif(BLAKE3_SIMD_TYPE STREQUAL "x86-intrinsics")
-  # Conditionally add amd64 C files to `blake3-testing` sources
-  if (NOT DEFINED BLAKE3_CFLAGS_SSE2
-      OR NOT DEFINED BLAKE3_CFLAGS_SSE4.1
-      OR NOT DEFINED BLAKE3_CFLAGS_AVX2
-      OR NOT DEFINED BLAKE3_CFLAGS_AVX512)
-    message(WARNING "BLAKE3_SIMD_TYPE is set to 'x86-intrinsics' but no compiler flags are available for the target architecture.")
-  else()
-    set(BLAKE3_SIMD_X86_INTRINSICS ON)
-  endif()
-
-  if(NOT BLAKE3_NO_AVX2)
-    target_sources(blake3-testing PRIVATE blake3_avx2.c)
-    set_source_files_properties(blake3_avx2.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_AVX2}")
-  endif()
-  if(NOT BLAKE3_NO_AVX512)
-    target_sources(blake3-testing PRIVATE blake3_avx512.c)
-    set_source_files_properties(blake3_avx512.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_AVX512}")
-  endif()
-  if(NOT BLAKE3_NO_SSE2)
-    target_sources(blake3-testing PRIVATE blake3_sse2.c)
-    set_source_files_properties(blake3_sse2.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_SSE2}")
-  endif()
-  if(NOT BLAKE3_NO_SSE41)
-    target_sources(blake3-testing PRIVATE blake3_sse41.c)
-    set_source_files_properties(blake3_sse41.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_SSE4.1}")
-  endif()
-
-elseif(BLAKE3_SIMD_TYPE STREQUAL "neon-intrinsics")
-  # Conditionally add neon C files to `blake3-testing` sources
-
-  target_sources(blake3-testing PRIVATE
-    blake3_neon.c
-  )
-  target_compile_definitions(blake3-testing PRIVATE
-    BLAKE3_USE_NEON=1
-  )
-
-  if (DEFINED BLAKE3_CFLAGS_NEON)
-    set_source_files_properties(blake3_neon.c PROPERTIES COMPILE_FLAGS "${BLAKE3_CFLAGS_NEON}")
-  endif()
-
-elseif(BLAKE3_SIMD_TYPE STREQUAL "none")
-  # Disable neon if simd type is "none". We check for individual amd64 features further below.
-
-  target_compile_definitions(blake3-testing PRIVATE
-    BLAKE3_USE_NEON=0
-  )
-
-endif()
-
-if(BLAKE3_NO_AVX2)
-  target_compile_definitions(blake3-testing PRIVATE BLAKE3_NO_AVX2)
-endif()
-if(BLAKE3_NO_AVX512)
-  target_compile_definitions(blake3-testing PRIVATE BLAKE3_NO_AVX512)
-endif()
-if(BLAKE3_NO_SSE2)
-  target_compile_definitions(blake3-testing PRIVATE BLAKE3_NO_SSE2)
-endif()
-if(BLAKE3_NO_SSE41)
-  target_compile_definitions(blake3-testing PRIVATE BLAKE3_NO_SSE41)
-endif()
-
-target_compile_definitions(blake3-testing PUBLIC BLAKE3_TESTING)
-
-get_target_property(BLAKE3_COMPILE_DEFINITIONS blake3 COMPILE_DEFINITIONS)
-if(BLAKE3_COMPILE_DEFINITIONS)
-  target_compile_definitions(blake3-testing PUBLIC
-    ${BLAKE3_COMPILE_DEFINITIONS})
-endif()
-
-get_target_property(BLAKE3_COMPILE_OPTIONS blake3 COMPILE_OPTIONS)
-if(BLAKE3_COMPILE_OPTIONS)
-  target_compile_options(blake3-testing PRIVATE
-    ${BLAKE3_COMPILE_OPTIONS}
-    -O3
-    -Wall
-    -Wextra
-    -pedantic
-    -fstack-protector-strong
-    -D_FORTIFY_SOURCE=2
-    -fPIE
-    -fvisibility=hidden
-    -fsanitize=address,undefined
-  )
-endif()
-
-get_target_property(BLAKE3_INCLUDE_DIRECTORIES blake3 INCLUDE_DIRECTORIES)
-if(BLAKE3_INCLUDE_DIRECTORIES)
-  target_include_directories(blake3-testing PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-  )
-endif()
-
-get_target_property(BLAKE3_LINK_LIBRARIES blake3 LINK_LIBRARIES)
-if(BLAKE3_LINK_LIBRARIES)
-  target_link_libraries(blake3-testing PRIVATE ${BLAKE3_LINK_LIBRARIES})
-endif()
-
-get_target_property(BLAKE3_LINK_OPTIONS blake3 LINK_OPTIONS)
-if(BLAKE3_LINK_OPTIONS)
-  target_link_options(blake3-testing PRIVATE
-    ${BLAKE3_LINK_OPTIONS}
-    -fsanitize=address,undefined
-    -pie
-    -Wl,-z,relro,-z,now
-  )
-endif()
-
-# test asm target
-add_executable(blake3-asm-test
-  main.c
-)
-set_target_properties(blake3-asm-test PROPERTIES
-  OUTPUT_NAME blake3
-  RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
-target_link_libraries(blake3-asm-test PRIVATE blake3-testing)
-target_compile_definitions(blake3-asm-test PRIVATE BLAKE3_TESTING)
-target_compile_options(blake3-asm-test PRIVATE
-  -O3
-  -Wall
-  -Wextra
-  -pedantic
-  -fstack-protector-strong
-  -D_FORTIFY_SOURCE=2
-  -fPIE
-  -fvisibility=hidden
-  -fsanitize=address,undefined
-)
-target_link_options(blake3-asm-test PRIVATE
-  -fsanitize=address,undefined
-  -pie
-  -Wl,-z,relro,-z,now
-)
-
-add_test(NAME blake3-testing
-  COMMAND "${CMAKE_CTEST_COMMAND}"
-    --verbose
-    --extra-verbose
-    --build-and-test "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}"
-    --build-generator "${CMAKE_GENERATOR}"
-    --build-makeprogram "${CMAKE_MAKE_PROGRAM}"
-    --build-project libblake3
-    --build-target blake3-asm-test
-    --build-options
-      --fresh
-      "-DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}"
-      "-DBLAKE3_TESTING=${BLAKE3_TESTING}"
-      "-DBLAKE3_TESTING_CI=${BLAKE3_TESTING_CI}"
-      "-DBLAKE3_USE_TBB=${BLAKE3_USE_TBB}"
-      "-DBLAKE3_SIMD_TYPE=${BLAKE3_SIMD_TYPE}"
-      "-DBLAKE3_NO_SSE2=${BLAKE3_NO_SSE2}"
-      "-DBLAKE3_NO_SSE41=${BLAKE3_NO_SSE41}"
-      "-DBLAKE3_NO_AVX2=${BLAKE3_NO_AVX2}"
-      "-DBLAKE3_NO_AVX512=${BLAKE3_NO_AVX512}"
-    --test-command
-      "${CMAKE_SOURCE_DIR}/test.py"
-  )

external/blake3/cmake/BLAKE3/Examples.cmake

@@ -1,13 +0,0 @@
-if(NOT WIN32)
-  add_executable(blake3-example
-    example.c)
-  target_link_libraries(blake3-example PRIVATE blake3)
-  install(TARGETS blake3-example)
-
-  if(BLAKE3_USE_TBB)
-    add_executable(blake3-example-tbb
-      example_tbb.c)
-    target_link_libraries(blake3-example-tbb PRIVATE blake3)
-    install(TARGETS blake3-example-tbb)
-  endif()
-endif()

external/blake3/cmake/BLAKE3/Testing.cmake

@@ -1,3 +0,0 @@
-if(BLAKE3_TESTING_CI)
-  include(BLAKE3/ContinuousIntegration)
-endif()

external/blake3/dependencies/CMakeLists.txt

@@ -1,3 +0,0 @@
-if(BLAKE3_USE_TBB)
-    add_subdirectory(tbb)
-endif()

external/blake3/dependencies/tbb/CMakeLists.txt

@@ -1,28 +0,0 @@
-find_package(TBB 2021.11.0 QUIET)
-
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.11)
-  include(FetchContent)
-
-  if(NOT TBB_FOUND AND BLAKE3_FETCH_TBB)
-    set(CMAKE_C_STANDARD 99)
-    set(CMAKE_C_EXTENSIONS OFF)
-
-    set(CMAKE_CXX_STANDARD 20)
-    set(CMAKE_CXX_EXTENSIONS ON)
-
-    option(TBB_TEST OFF "")
-    option(TBBMALLOC_BUILD OFF "")
-
-    mark_as_advanced(TBB_TEST)
-    mark_as_advanced(TBBMALLOC_BUILD)
-
-    FetchContent_Declare(
-      TBB
-      GIT_REPOSITORY https://github.com/uxlfoundation/oneTBB
-      GIT_TAG 0c0ff192a2304e114bc9e6557582dfba101360ff # v2022.0.0
-      GIT_SHALLOW TRUE
-    )
-
-    FetchContent_MakeAvailable(TBB)
-  endif()
-endif()

external/blake3/example.c

@@ -1,36 +0,0 @@
-#include "blake3.h"
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-int main(void) {
-  // Initialize the hasher.
-  blake3_hasher hasher;
-  blake3_hasher_init(&hasher);
-
-  // Read input bytes from stdin.
-  unsigned char buf[65536];
-  while (1) {
-    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf));
-    if (n > 0) {
-      blake3_hasher_update(&hasher, buf, n);
-    } else if (n == 0) {
-      break; // end of file
-    } else {
-      fprintf(stderr, "read failed: %s\n", strerror(errno));
-      return 1;
-    }
-  }
-
-  // Finalize the hash. BLAKE3_OUT_LEN is the default output length, 32 bytes.
-  uint8_t output[BLAKE3_OUT_LEN];
-  blake3_hasher_finalize(&hasher, output, BLAKE3_OUT_LEN);
-
-  // Print the hash as hexadecimal.
-  for (size_t i = 0; i < BLAKE3_OUT_LEN; i++) {
-    printf("%02x", output[i]);
-  }
-  printf("\n");
-  return 0;
-}

external/blake3/example_tbb.c

@@ -1,57 +0,0 @@
-#include "blake3.h"
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-int main(int argc, char **argv) {
-  // For each filepath argument, memory map it and hash it.
-  for (int i = 1; i < argc; i++) {
-    // Open and memory map the file.
-    int fd = open(argv[i], O_RDONLY);
-    if (fd == -1) {
-      fprintf(stderr, "open failed: %s\n", strerror(errno));
-      return 1;
-    }
-    struct stat statbuf;
-    if (fstat(fd, &statbuf) == -1) {
-      fprintf(stderr, "stat failed: %s\n", strerror(errno));
-      return 1;
-    }
-    void *mapped = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
-    if (mapped == MAP_FAILED) {
-      fprintf(stderr, "mmap failed: %s\n", strerror(errno));
-      return 1;
-    }
-
-    // Initialize the hasher.
-    blake3_hasher hasher;
-    blake3_hasher_init(&hasher);
-
-    // Hash the mapped file using multiple threads.
-    blake3_hasher_update_tbb(&hasher, mapped, statbuf.st_size);
-
-    // Unmap and close the file.
-    if (munmap(mapped, statbuf.st_size) == -1) {
-      fprintf(stderr, "munmap failed: %s\n", strerror(errno));
-      return 1;
-    }
-    if (close(fd) == -1) {
-      fprintf(stderr, "close failed: %s\n", strerror(errno));
-      return 1;
-    }
-
-    // Finalize the hash. BLAKE3_OUT_LEN is the default output length, 32 bytes.
-    uint8_t output[BLAKE3_OUT_LEN];
-    blake3_hasher_finalize(&hasher, output, BLAKE3_OUT_LEN);
-
-    // Print the hash as hexadecimal.
-    for (size_t i = 0; i < BLAKE3_OUT_LEN; i++) {
-      printf("%02x", output[i]);
-    }
-    printf("\n");
-  }
-}

external/blake3/libblake3.pc.in

@@ -1,12 +0,0 @@
-prefix="@CMAKE_INSTALL_PREFIX@"
-exec_prefix="${prefix}"
-libdir="@PKG_CONFIG_INSTALL_LIBDIR@"
-includedir="@PKG_CONFIG_INSTALL_INCLUDEDIR@"
-
-Name: @PROJECT_NAME@
-Description: @PROJECT_DESCRIPTION@
-Version: @PROJECT_VERSION@
-
-Requires: @PKG_CONFIG_REQUIRES@
-Libs: -L"${libdir}" -lblake3 @PKG_CONFIG_LIBS@
-Cflags: -I"${includedir}" @PKG_CONFIG_CFLAGS@

external/blake3/main.c

@@ -1,166 +0,0 @@
-/*
- * This main file is intended for testing via `make test`. It does not build in
- * other settings. See README.md in this directory for examples of how to build
- * C code.
- */
-
-#include <assert.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "blake3.h"
-#include "blake3_impl.h"
-
-#define HASH_MODE 0
-#define KEYED_HASH_MODE 1
-#define DERIVE_KEY_MODE 2
-
-static void hex_char_value(uint8_t c, uint8_t *value, bool *valid) {
-  if ('0' <= c && c <= '9') {
-    *value = c - '0';
-    *valid = true;
-  } else if ('a' <= c && c <= 'f') {
-    *value = 10 + c - 'a';
-    *valid = true;
-  } else {
-    *valid = false;
-  }
-}
-
-static int parse_key(char *hex_key, uint8_t out[BLAKE3_KEY_LEN]) {
-  size_t hex_len = strlen(hex_key);
-  if (hex_len != 64) {
-    fprintf(stderr, "Expected a 64-char hexadecimal key, got %zu chars.\n",
-            hex_len);
-    return 1;
-  }
-  for (size_t i = 0; i < 64; i++) {
-    uint8_t value;
-    bool valid;
-    hex_char_value(hex_key[i], &value, &valid);
-    if (!valid) {
-      fprintf(stderr, "Invalid hex char.\n");
-      return 1;
-    }
-    if (i % 2 == 0) {
-      out[i / 2] = 0;
-      value <<= 4;
-    }
-    out[i / 2] += value;
-  }
-  return 0;
-}
-
-/* A little repetition here */
-enum cpu_feature {
-  SSE2 = 1 << 0,
-  SSSE3 = 1 << 1,
-  SSE41 = 1 << 2,
-  AVX = 1 << 3,
-  AVX2 = 1 << 4,
-  AVX512F = 1 << 5,
-  AVX512VL = 1 << 6,
-  /* ... */
-  UNDEFINED = 1 << 30
-};
-
-extern enum cpu_feature g_cpu_features;
-enum cpu_feature get_cpu_features(void);
-
-int main(int argc, char **argv) {
-  size_t out_len = BLAKE3_OUT_LEN;
-  uint8_t key[BLAKE3_KEY_LEN];
-  char *context = "";
-  uint8_t mode = HASH_MODE;
-  while (argc > 1) {
-    if (argc <= 2) {
-      fprintf(stderr, "Odd number of arguments.\n");
-      return 1;
-    }
-    if (strcmp("--length", argv[1]) == 0) {
-      char *endptr = NULL;
-      errno = 0;
-      unsigned long long out_len_ll = strtoull(argv[2], &endptr, 10);
-      if (errno != 0 || out_len_ll > SIZE_MAX || endptr == argv[2] ||
-          *endptr != 0) {
-        fprintf(stderr, "Bad length argument.\n");
-        return 1;
-      }
-      out_len = (size_t)out_len_ll;
-    } else if (strcmp("--keyed", argv[1]) == 0) {
-      mode = KEYED_HASH_MODE;
-      int ret = parse_key(argv[2], key);
-      if (ret != 0) {
-        return ret;
-      }
-    } else if (strcmp("--derive-key", argv[1]) == 0) {
-      mode = DERIVE_KEY_MODE;
-      context = argv[2];
-    } else {
-      fprintf(stderr, "Unknown flag.\n");
-      return 1;
-    }
-    argc -= 2;
-    argv += 2;
-  }
-
-  /*
-   * We're going to hash the input multiple times, so we need to buffer it all.
-   * This is just for test cases, so go ahead and assume that the input is less
-   * than 1 MiB.
-   */
-  size_t buf_capacity = 1 << 20;
-  uint8_t *buf = malloc(buf_capacity);
-  assert(buf != NULL);
-  size_t buf_len = 0;
-  while (1) {
-    size_t n = fread(&buf[buf_len], 1, buf_capacity - buf_len, stdin);
-    if (n == 0) {
-      break;
-    }
-    buf_len += n;
-    assert(buf_len < buf_capacity);
-  }
-
-  const int mask = get_cpu_features();
-  int feature = 0;
-  do {
-    fprintf(stderr, "Testing 0x%08X\n", feature);
-    g_cpu_features = feature;
-    blake3_hasher hasher;
-    switch (mode) {
-    case HASH_MODE:
-      blake3_hasher_init(&hasher);
-      break;
-    case KEYED_HASH_MODE:
-      blake3_hasher_init_keyed(&hasher, key);
-      break;
-    case DERIVE_KEY_MODE:
-      blake3_hasher_init_derive_key(&hasher, context);
-      break;
-    default:
-      abort();
-    }
-
-    blake3_hasher_update(&hasher, buf, buf_len);
-
-    /* TODO: An incremental output reader API to avoid this allocation. */
-    uint8_t *out = malloc(out_len);
-    if (out_len > 0 && out == NULL) {
-      fprintf(stderr, "malloc() failed.\n");
-      return 1;
-    }
-    blake3_hasher_finalize(&hasher, out, out_len);
-    for (size_t i = 0; i < out_len; i++) {
-      printf("%02x", out[i]);
-    }
-    printf("\n");
-    free(out);
-    feature = (feature - mask) & mask;
-  } while (feature != 0);
-  free(buf);
-  return 0;
-}

external/blake3/test.py

@@ -1,97 +0,0 @@
-#! /usr/bin/env python3
-
-from binascii import hexlify
-import json
-from os import path
-import subprocess
-
-HERE = path.dirname(__file__)
-TEST_VECTORS_PATH = path.join(HERE, "..", "test_vectors", "test_vectors.json")
-TEST_VECTORS = json.load(open(TEST_VECTORS_PATH))
-
-
-def run_blake3(args, input):
-    output = subprocess.run([path.join(HERE, "blake3")] + args,
-                            input=input,
-                            stdout=subprocess.PIPE,
-                            check=True)
-    return output.stdout.decode().strip()
-
-
-# Fill the input with a repeating byte pattern. We use a cycle length of 251,
-# because that's the largest prime number less than 256. This makes it unlikely
-# to swapping any two adjacent input blocks or chunks will give the same
-# answer.
-def make_test_input(length):
-    i = 0
-    buf = bytearray()
-    while len(buf) < length:
-        buf.append(i)
-        i = (i + 1) % 251
-    return buf
-
-
-def main():
-    for case in TEST_VECTORS["cases"]:
-        input_len = case["input_len"]
-        input = make_test_input(input_len)
-        hex_key = hexlify(TEST_VECTORS["key"].encode())
-        context_string = TEST_VECTORS["context_string"]
-        expected_hash_xof = case["hash"]
-        expected_hash = expected_hash_xof[:64]
-        expected_keyed_hash_xof = case["keyed_hash"]
-        expected_keyed_hash = expected_keyed_hash_xof[:64]
-        expected_derive_key_xof = case["derive_key"]
-        expected_derive_key = expected_derive_key_xof[:64]
-
-        # Test the default hash.
-        test_hash = run_blake3([], input)
-        for line in test_hash.splitlines():
-            assert expected_hash == line, \
-                "hash({}): {} != {}".format(input_len, expected_hash, line)
-
-        # Test the extended hash.
-        xof_len = len(expected_hash_xof) // 2
-        test_hash_xof = run_blake3(["--length", str(xof_len)], input)
-        for line in test_hash_xof.splitlines():
-            assert expected_hash_xof == line, \
-                "hash_xof({}): {} != {}".format(
-                    input_len, expected_hash_xof, line)
-
-        # Test the default keyed hash.
-        test_keyed_hash = run_blake3(["--keyed", hex_key], input)
-        for line in test_keyed_hash.splitlines():
-            assert expected_keyed_hash == line, \
-                "keyed_hash({}): {} != {}".format(
-                    input_len, expected_keyed_hash, line)
-
-        # Test the extended keyed hash.
-        xof_len = len(expected_keyed_hash_xof) // 2
-        test_keyed_hash_xof = run_blake3(
-            ["--keyed", hex_key, "--length",
-             str(xof_len)], input)
-        for line in test_keyed_hash_xof.splitlines():
-            assert expected_keyed_hash_xof == line, \
-                "keyed_hash_xof({}): {} != {}".format(
-                    input_len, expected_keyed_hash_xof, line)
-
-        # Test the default derive key.
-        test_derive_key = run_blake3(["--derive-key", context_string], input)
-        for line in test_derive_key.splitlines():
-            assert expected_derive_key == line, \
-                "derive_key({}): {} != {}".format(
-                    input_len, expected_derive_key, line)
-
-        # Test the extended derive key.
-        xof_len = len(expected_derive_key_xof) // 2
-        test_derive_key_xof = run_blake3(
-            ["--derive-key", context_string, "--length",
-             str(xof_len)], input)
-        for line in test_derive_key_xof.splitlines():
-            assert expected_derive_key_xof == line, \
-                "derive_key_xof({}): {} != {}".format(
-                    input_len, expected_derive_key_xof, line)
-
-
-if __name__ == "__main__":
-    main()

external/ed25519-donna/CMakeLists.txt

@@ -17,6 +17,9 @@ add_library(ed25519 STATIC
 )
 add_library(ed25519::ed25519 ALIAS ed25519)
 target_link_libraries(ed25519 PUBLIC OpenSSL::SSL)
+if(NOT MSVC)
+  target_compile_options(ed25519 PRIVATE -Wno-implicit-fallthrough)
+endif()
 
 include(GNUInstallDirs)
 

external/nudb/conandata.yml

@@ -1,10 +0,0 @@
-sources:
-  "2.0.8":
-    url: "https://github.com/CPPAlliance/NuDB/archive/2.0.8.tar.gz"
-    sha256: "9b71903d8ba111cd893ab064b9a8b6ac4124ed8bd6b4f67250205bc43c7f13a8"
-patches:
-  "2.0.8":
-    - patch_file: "patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch"
-      patch_description: "Fix build for MSVC by including stdexcept"
-      patch_type: "portability"
-      patch_source: "https://github.com/cppalliance/NuDB/pull/100/files"

external/nudb/conanfile.py

@@ -1,72 +0,0 @@
-import os
-
-from conan import ConanFile
-from conan.tools.build import check_min_cppstd
-from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get
-from conan.tools.layout import basic_layout
-
-required_conan_version = ">=1.52.0"
-
-
-class NudbConan(ConanFile):
-    name = "nudb"
-    description = "A fast key/value insert-only database for SSD drives in C++11"
-    license = "BSL-1.0"
-    url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/CPPAlliance/NuDB"
-    topics = ("header-only", "KVS", "insert-only")
-
-    package_type = "header-library"
-    settings = "os", "arch", "compiler", "build_type"
-    no_copy_source = True
-
-    @property
-    def _min_cppstd(self):
-        return 11
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def layout(self):
-        basic_layout(self, src_folder="src")
-
-    def requirements(self):
-        self.requires("boost/1.83.0")
-
-    def package_id(self):
-        self.info.clear()
-
-    def validate(self):
-        if self.settings.compiler.cppstd:
-            check_min_cppstd(self, self._min_cppstd)
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def build(self):
-        apply_conandata_patches(self)
-
-    def package(self):
-        copy(self, "LICENSE*",
-             dst=os.path.join(self.package_folder, "licenses"),
-             src=self.source_folder)
-        copy(self, "*",
-             dst=os.path.join(self.package_folder, "include"),
-             src=os.path.join(self.source_folder, "include"))
-
-    def package_info(self):
-        self.cpp_info.bindirs = []
-        self.cpp_info.libdirs = []
-
-        self.cpp_info.set_property("cmake_target_name", "NuDB")
-        self.cpp_info.set_property("cmake_target_aliases", ["NuDB::nudb"])
-        self.cpp_info.set_property("cmake_find_mode", "both")
-
-        self.cpp_info.components["core"].set_property("cmake_target_name", "nudb")
-        self.cpp_info.components["core"].names["cmake_find_package"] = "nudb"
-        self.cpp_info.components["core"].names["cmake_find_package_multi"] = "nudb"
-        self.cpp_info.components["core"].requires = ["boost::thread", "boost::system"]
-
-        # TODO: to remove in conan v2 once cmake_find_package_* generators removed
-        self.cpp_info.names["cmake_find_package"] = "NuDB"
-        self.cpp_info.names["cmake_find_package_multi"] = "NuDB"

external/nudb/patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch

@@ -1,24 +0,0 @@
-diff --git a/include/nudb/detail/stream.hpp b/include/nudb/detail/stream.hpp
-index 6c07bf1..e0ce8ed 100644
---- a/include/nudb/detail/stream.hpp
-+++ b/include/nudb/detail/stream.hpp
-@@ -14,6 +14,7 @@
- #include <cstdint>
- #include <cstring>
- #include <memory>
-+#include <stdexcept>
- 
- namespace nudb {
- namespace detail {
-diff --git a/include/nudb/impl/context.ipp b/include/nudb/impl/context.ipp
-index beb7058..ffde0b3 100644
---- a/include/nudb/impl/context.ipp
-+++ b/include/nudb/impl/context.ipp
-@@ -9,6 +9,7 @@
- #define NUDB_IMPL_CONTEXT_IPP
- 
- #include <nudb/detail/store_base.hpp>
-+#include <stdexcept>
- 
- namespace nudb {
- 

external/rocksdb/conandata.yml

@@ -1,12 +0,0 @@
-sources:
-  "9.7.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v9.7.3.tar.gz"
-    sha256: "acfabb989cbfb5b5c4d23214819b059638193ec33dad2d88373c46448d16d38b"
-patches:
-  "9.7.3":
-    - patch_file: "patches/9.x.x-0001-exclude-thirdparty.patch"
-      patch_description: "Do not include thirdparty.inc"
-      patch_type: "portability"
-    - patch_file: "patches/9.7.3-0001-memory-leak.patch"
-      patch_description: "Fix a leak of obsolete blob files left open until DB::Close()"
-      patch_type: "portability"

external/rocksdb/conanfile.py

@@ -1,235 +0,0 @@
-import os
-import glob
-import shutil
-
-from conan import ConanFile
-from conan.errors import ConanInvalidConfiguration
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
-from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
-from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
-from conan.tools.scm import Version
-
-required_conan_version = ">=1.53.0"
-
-
-class RocksDBConan(ConanFile):
-    name = "rocksdb"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
-    license = ("GPL-2.0-only", "Apache-2.0")
-    url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/facebook/rocksdb"
-    topics = ("database", "leveldb", "facebook", "key-value")
-    package_type = "library"
-    settings = "os", "arch", "compiler", "build_type"
-    options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-        "lite": [True, False],
-        "with_gflags": [True, False],
-        "with_snappy": [True, False],
-        "with_lz4": [True, False],
-        "with_zlib": [True, False],
-        "with_zstd": [True, False],
-        "with_tbb": [True, False],
-        "with_jemalloc": [True, False],
-        "enable_sse": [False, "sse42", "avx2"],
-        "use_rtti": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "fPIC": True,
-        "lite": False,
-        "with_snappy": False,
-        "with_lz4": False,
-        "with_zlib": False,
-        "with_zstd": False,
-        "with_gflags": False,
-        "with_tbb": False,
-        "with_jemalloc": False,
-        "enable_sse": False,
-        "use_rtti": False,
-    }
-
-    @property
-    def _min_cppstd(self):
-        return "11" if Version(self.version) < "8.8.1" else "17"
-
-    @property
-    def _compilers_minimum_version(self):
-        return {} if self._min_cppstd == "11" else {
-            "apple-clang": "10",
-            "clang": "7",
-            "gcc": "7",
-            "msvc": "191",
-            "Visual Studio": "15",
-        }
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            del self.options.fPIC
-        if self.settings.arch != "x86_64":
-            del self.options.with_tbb
-        if self.settings.build_type == "Debug":
-            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
-    def requirements(self):
-        if self.options.with_gflags:
-            self.requires("gflags/2.2.2")
-        if self.options.with_snappy:
-            self.requires("snappy/1.1.10")
-        if self.options.with_lz4:
-            self.requires("lz4/1.10.0")
-        if self.options.with_zlib:
-            self.requires("zlib/[>=1.2.11 <2]")
-        if self.options.with_zstd:
-            self.requires("zstd/1.5.6")
-        if self.options.get_safe("with_tbb"):
-            self.requires("onetbb/2021.12.0")
-        if self.options.with_jemalloc:
-            self.requires("jemalloc/5.3.0")
-
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, self._min_cppstd)
-
-        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
-        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
-            raise ConanInvalidConfiguration(
-                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
-            )
-
-        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
-            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
-
-        check_min_vs(self, "191")
-
-        if self.version == "6.20.3" and \
-                self.settings.os == "Linux" and \
-                self.settings.compiler == "gcc" and \
-                Version(self.settings.compiler.version) < "5":
-            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["FAIL_ON_WARNINGS"] = False
-        tc.variables["WITH_TESTS"] = False
-        tc.variables["WITH_TOOLS"] = False
-        tc.variables["WITH_CORE_TOOLS"] = False
-        tc.variables["WITH_BENCHMARK_TOOLS"] = False
-        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
-        if is_msvc(self):
-            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
-        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
-        tc.variables["ROCKSDB_LITE"] = self.options.lite
-        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
-        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
-        tc.variables["WITH_LZ4"] = self.options.with_lz4
-        tc.variables["WITH_ZLIB"] = self.options.with_zlib
-        tc.variables["WITH_ZSTD"] = self.options.with_zstd
-        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
-        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
-        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
-        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
-        tc.variables["USE_RTTI"] = self.options.use_rtti
-        if not bool(self.options.enable_sse):
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = False
-        elif self.options.enable_sse == "sse42":
-            tc.variables["PORTABLE"] = True
-            tc.variables["FORCE_SSE42"] = True
-        elif self.options.enable_sse == "avx2":
-            tc.variables["PORTABLE"] = False
-            tc.variables["FORCE_SSE42"] = False
-        # not available yet in CCI
-        tc.variables["WITH_NUMA"] = False
-        tc.generate()
-
-        deps = CMakeDeps(self)
-        if self.options.with_jemalloc:
-            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
-            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
-        if self.options.with_zstd:
-            deps.set_property("zstd", "cmake_target_name", "zstd::zstd")
-        deps.generate()
-
-    def build(self):
-        apply_conandata_patches(self)
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def _remove_static_libraries(self):
-        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
-        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
-            if not lib.endswith(".dll.a"):
-                os.remove(lib)
-
-    def _remove_cpp_headers(self):
-        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
-            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
-                if os.path.isfile(path):
-                    os.remove(path)
-                else:
-                    shutil.rmtree(path)
-
-    def package(self):
-        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        cmake = CMake(self)
-        cmake.install()
-        if self.options.shared:
-            self._remove_static_libraries()
-            self._remove_cpp_headers() # Force stable ABI for shared libraries
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
-
-    def package_info(self):
-        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
-        self.cpp_info.set_property("cmake_file_name", "RocksDB")
-        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
-        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
-        if self.settings.os == "Windows":
-            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
-            if self.options.shared:
-                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
-        elif self.settings.os in ["Linux", "FreeBSD"]:
-            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
-        if self.options.lite:
-            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
-
-        # TODO: to remove in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.names["cmake_find_package"] = "RocksDB"
-        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
-        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
-        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
-        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
-        if self.options.with_gflags:
-            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
-        if self.options.with_snappy:
-            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
-        if self.options.with_lz4:
-            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
-        if self.options.with_zlib:
-            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
-        if self.options.with_zstd:
-            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
-        if self.options.get_safe("with_tbb"):
-            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
-        if self.options.with_jemalloc:
-            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/9.7.3-0001-memory-leak.patch

@@ -1,319 +0,0 @@
-diff --git a/HISTORY.md b/HISTORY.md
-index 36d472229..05ad1a202 100644
---- a/HISTORY.md
-+++ b/HISTORY.md
-@@ -1,6 +1,10 @@
- # Rocksdb Change Log
- > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`
- 
-+## 9.7.4 (10/31/2024)
-+### Bug Fixes
-+* Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
-+
- ## 9.7.3 (10/16/2024)
- ### Behavior Changes
- * OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
-diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc
-index 5f340aadf..1b9faa238 100644
---- a/db/blob/blob_file_cache.cc
-+++ b/db/blob/blob_file_cache.cc
-@@ -42,6 +42,7 @@ Status BlobFileCache::GetBlobFileReader(
-   assert(blob_file_reader);
-   assert(blob_file_reader->IsEmpty());
- 
-+  // NOTE: sharing same Cache with table_cache
-   const Slice key = GetSliceForKey(&blob_file_number);
- 
-   assert(cache_);
-@@ -98,4 +99,13 @@ Status BlobFileCache::GetBlobFileReader(
-   return Status::OK();
- }
- 
-+void BlobFileCache::Evict(uint64_t blob_file_number) {
-+  // NOTE: sharing same Cache with table_cache
-+  const Slice key = GetSliceForKey(&blob_file_number);
-+
-+  assert(cache_);
-+
-+  cache_.get()->Erase(key);
-+}
-+
- }  // namespace ROCKSDB_NAMESPACE
-diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h
-index 740e67ada..6858d012b 100644
---- a/db/blob/blob_file_cache.h
-+++ b/db/blob/blob_file_cache.h
-@@ -36,6 +36,15 @@ class BlobFileCache {
-                            uint64_t blob_file_number,
-                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
- 
-+  // Called when a blob file is obsolete to ensure it is removed from the cache
-+  // to avoid effectively leaking the open file and assicated memory
-+  void Evict(uint64_t blob_file_number);
-+
-+  // Used to identify cache entries for blob files (not normally useful)
-+  static const Cache::CacheItemHelper* GetHelper() {
-+    return CacheInterface::GetBasicHelper();
-+  }
-+
-  private:
-   using CacheInterface =
-       BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
-diff --git a/db/column_family.h b/db/column_family.h
-index e4b7adde8..86637736a 100644
---- a/db/column_family.h
-+++ b/db/column_family.h
-@@ -401,6 +401,7 @@ class ColumnFamilyData {
-                          SequenceNumber earliest_seq);
- 
-   TableCache* table_cache() const { return table_cache_.get(); }
-+  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
-   BlobSource* blob_source() const { return blob_source_.get(); }
- 
-   // See documentation in compaction_picker.h
-diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc
-index 261593423..06573ac2e 100644
---- a/db/db_impl/db_impl.cc
-+++ b/db/db_impl/db_impl.cc
-@@ -659,8 +659,9 @@ Status DBImpl::CloseHelper() {
-   // We need to release them before the block cache is destroyed. The block
-   // cache may be destroyed inside versions_.reset(), when column family data
-   // list is destroyed, so leaving handles in table cache after
--  // versions_.reset() may cause issues.
--  // Here we clean all unreferenced handles in table cache.
-+  // versions_.reset() may cause issues. Here we clean all unreferenced handles
-+  // in table cache, and (for certain builds/conditions) assert that no obsolete
-+  // files are hanging around unreferenced (leak) in the table/blob file cache.
-   // Now we assume all user queries have finished, so only version set itself
-   // can possibly hold the blocks from block cache. After releasing unreferenced
-   // handles here, only handles held by version set left and inside
-@@ -668,6 +669,9 @@ Status DBImpl::CloseHelper() {
-   // time a handle is released, we erase it from the cache too. By doing that,
-   // we can guarantee that after versions_.reset(), table cache is empty
-   // so the cache can be safely destroyed.
-+#ifndef NDEBUG
-+  TEST_VerifyNoObsoleteFilesCached(/*db_mutex_already_held=*/true);
-+#endif  // !NDEBUG
-   table_cache_->EraseUnRefEntries();
- 
-   for (auto& txn_entry : recovered_transactions_) {
-@@ -3227,6 +3231,8 @@ Status DBImpl::MultiGetImpl(
-       s = Status::Aborted();
-       break;
-     }
-+    // This could be a long-running operation
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   }
- 
-   // Post processing (decrement reference counts and record statistics)
-diff --git a/db/db_impl/db_impl.h b/db/db_impl/db_impl.h
-index 5e4fa310b..ccc0abfa7 100644
---- a/db/db_impl/db_impl.h
-+++ b/db/db_impl/db_impl.h
-@@ -1241,9 +1241,14 @@ class DBImpl : public DB {
-   static Status TEST_ValidateOptions(const DBOptions& db_options) {
-     return ValidateOptions(db_options);
-   }
--
- #endif  // NDEBUG
- 
-+  // In certain configurations, verify that the table/blob file cache only
-+  // contains entries for live files, to check for effective leaks of open
-+  // files. This can only be called when purging of obsolete files has
-+  // "settled," such as during parts of DB Close().
-+  void TEST_VerifyNoObsoleteFilesCached(bool db_mutex_already_held) const;
-+
-   // persist stats to column family "_persistent_stats"
-   void PersistStats();
- 
-diff --git a/db/db_impl/db_impl_debug.cc b/db/db_impl/db_impl_debug.cc
-index 790a50d7a..67f5b4aaf 100644
---- a/db/db_impl/db_impl_debug.cc
-+++ b/db/db_impl/db_impl_debug.cc
-@@ -9,6 +9,7 @@
- 
- #ifndef NDEBUG
- 
-+#include "db/blob/blob_file_cache.h"
- #include "db/column_family.h"
- #include "db/db_impl/db_impl.h"
- #include "db/error_handler.h"
-@@ -328,5 +329,49 @@ size_t DBImpl::TEST_EstimateInMemoryStatsHistorySize() const {
-   InstrumentedMutexLock l(&const_cast<DBImpl*>(this)->stats_history_mutex_);
-   return EstimateInMemoryStatsHistorySize();
- }
-+
-+void DBImpl::TEST_VerifyNoObsoleteFilesCached(
-+    bool db_mutex_already_held) const {
-+  // This check is somewhat expensive and obscure to make a part of every
-+  // unit test in every build variety. Thus, we only enable it for ASAN builds.
-+  if (!kMustFreeHeapAllocations) {
-+    return;
-+  }
-+
-+  std::optional<InstrumentedMutexLock> l;
-+  if (db_mutex_already_held) {
-+    mutex_.AssertHeld();
-+  } else {
-+    l.emplace(&mutex_);
-+  }
-+
-+  std::vector<uint64_t> live_files;
-+  for (auto cfd : *versions_->GetColumnFamilySet()) {
-+    if (cfd->IsDropped()) {
-+      continue;
-+    }
-+    // Sneakily add both SST and blob files to the same list
-+    cfd->current()->AddLiveFiles(&live_files, &live_files);
-+  }
-+  std::sort(live_files.begin(), live_files.end());
-+
-+  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
-+                          const Cache::CacheItemHelper* helper) {
-+    if (helper != BlobFileCache::GetHelper()) {
-+      // Skip non-blob files for now
-+      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
-+      // unit tests.
-+      return;
-+    }
-+    // See TableCache and BlobFileCache
-+    assert(key.size() == sizeof(uint64_t));
-+    uint64_t file_number;
-+    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
-+    // Assert file is in sorted live_files
-+    assert(
-+        std::binary_search(live_files.begin(), live_files.end(), file_number));
-+  };
-+  table_cache_->ApplyToAllEntries(fn, {});
-+}
- }  // namespace ROCKSDB_NAMESPACE
- #endif  // NDEBUG
-diff --git a/db/db_iter.cc b/db/db_iter.cc
-index e02586377..bf4749eb9 100644
---- a/db/db_iter.cc
-+++ b/db/db_iter.cc
-@@ -540,6 +540,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
-     } else {
-       iter_.Next();
-     }
-+    // This could be a long-running operation due to tombstones, etc.
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   } while (iter_.Valid());
- 
-   valid_ = false;
-diff --git a/db/table_cache.cc b/db/table_cache.cc
-index 71fc29c32..8a5be75e8 100644
---- a/db/table_cache.cc
-+++ b/db/table_cache.cc
-@@ -164,6 +164,7 @@ Status TableCache::GetTableReader(
- }
- 
- Cache::Handle* TableCache::Lookup(Cache* cache, uint64_t file_number) {
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&file_number);
-   return cache->Lookup(key);
- }
-@@ -179,6 +180,7 @@ Status TableCache::FindTable(
-     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
-   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
-   uint64_t number = file_meta.fd.GetNumber();
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&number);
-   *handle = cache_.Lookup(key);
-   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
-diff --git a/db/version_builder.cc b/db/version_builder.cc
-index ed8ab8214..c98f53f42 100644
---- a/db/version_builder.cc
-+++ b/db/version_builder.cc
-@@ -24,6 +24,7 @@
- #include <vector>
- 
- #include "cache/cache_reservation_manager.h"
-+#include "db/blob/blob_file_cache.h"
- #include "db/blob/blob_file_meta.h"
- #include "db/dbformat.h"
- #include "db/internal_stats.h"
-@@ -744,12 +745,9 @@ class VersionBuilder::Rep {
-       return Status::Corruption("VersionBuilder", oss.str());
-     }
- 
--    // Note: we use C++11 for now but in C++14, this could be done in a more
--    // elegant way using generalized lambda capture.
--    VersionSet* const vs = version_set_;
--    const ImmutableCFOptions* const ioptions = ioptions_;
--
--    auto deleter = [vs, ioptions](SharedBlobFileMetaData* shared_meta) {
-+    auto deleter = [vs = version_set_, ioptions = ioptions_,
-+                    bc = cfd_ ? cfd_->blob_file_cache()
-+                              : nullptr](SharedBlobFileMetaData* shared_meta) {
-       if (vs) {
-         assert(ioptions);
-         assert(!ioptions->cf_paths.empty());
-@@ -758,6 +756,9 @@ class VersionBuilder::Rep {
-         vs->AddObsoleteBlobFile(shared_meta->GetBlobFileNumber(),
-                                 ioptions->cf_paths.front().path);
-       }
-+      if (bc) {
-+        bc->Evict(shared_meta->GetBlobFileNumber());
-+      }
- 
-       delete shared_meta;
-     };
-@@ -766,7 +767,7 @@ class VersionBuilder::Rep {
-         blob_file_number, blob_file_addition.GetTotalBlobCount(),
-         blob_file_addition.GetTotalBlobBytes(),
-         blob_file_addition.GetChecksumMethod(),
--        blob_file_addition.GetChecksumValue(), deleter);
-+        blob_file_addition.GetChecksumValue(), std::move(deleter));
- 
-     mutable_blob_file_metas_.emplace(
-         blob_file_number, MutableBlobFileMetaData(std::move(shared_meta)));
-diff --git a/db/version_set.h b/db/version_set.h
-index 9336782b1..024f869e7 100644
---- a/db/version_set.h
-+++ b/db/version_set.h
-@@ -1514,7 +1514,6 @@ class VersionSet {
-   void GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata);
- 
-   void AddObsoleteBlobFile(uint64_t blob_file_number, std::string path) {
--    // TODO: Erase file from BlobFileCache?
-     obsolete_blob_files_.emplace_back(blob_file_number, std::move(path));
-   }
- 
-diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h
-index 2a19796b8..0afa2cab1 100644
---- a/include/rocksdb/version.h
-+++ b/include/rocksdb/version.h
-@@ -13,7 +13,7 @@
- // minor or major version number planned for release.
- #define ROCKSDB_MAJOR 9
- #define ROCKSDB_MINOR 7
--#define ROCKSDB_PATCH 3
-+#define ROCKSDB_PATCH 4
- 
- // Do not use these. We made the mistake of declaring macros starting with
- // double underscore. Now we have to live with our choice. We'll deprecate these
-diff --git a/port/port.h b/port/port.h
-index 13aa56d47..141716e5b 100644
---- a/port/port.h
-+++ b/port/port.h
-@@ -19,3 +19,19 @@
- #elif defined(OS_WIN)
- #include "port/win/port_win.h"
- #endif
-+
-+#ifdef OS_LINUX
-+// A temporary hook into long-running RocksDB threads to support modifying their
-+// priority etc. This should become a public API hook once the requirements
-+// are better understood.
-+extern "C" void RocksDbThreadYield() __attribute__((__weak__));
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {                                 \
-+    if (RocksDbThreadYield) {       \
-+      RocksDbThreadYield();         \
-+    }                               \
-+  }
-+#else
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {}
-+#endif

external/rocksdb/patches/9.x.x-0001-exclude-thirdparty.patch

@@ -1,30 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 93b884d..b715cb6 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -106,14 +106,9 @@ endif()
- include(CMakeDependentOption)
-
- if(MSVC)
--  option(WITH_GFLAGS "build with GFlags" OFF)
-   option(WITH_XPRESS "build with windows built in compression" OFF)
--  option(ROCKSDB_SKIP_THIRDPARTY "skip thirdparty.inc" OFF)
--
--  if(NOT ROCKSDB_SKIP_THIRDPARTY)
--    include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
--  endif()
--else()
-+endif()
-+if(TRUE)
-   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND NOT CMAKE_SYSTEM_NAME MATCHES "kFreeBSD")
-     # FreeBSD has jemalloc as default malloc
-     # but it does not have all the jemalloc files in include/...
-@@ -126,7 +121,7 @@ else()
-     endif()
-   endif()
-
--  if(MINGW)
-+  if(MSVC OR MINGW)
-     option(WITH_GFLAGS "build with GFlags" OFF)
-   else()
-     option(WITH_GFLAGS "build with GFlags" ON)

external/snappy/conandata.yml

@@ -1,40 +0,0 @@
-sources:
-  "1.1.10":
-    url: "https://github.com/google/snappy/archive/1.1.10.tar.gz"
-    sha256: "49d831bffcc5f3d01482340fe5af59852ca2fe76c3e05df0e67203ebbe0f1d90"
-  "1.1.9":
-    url: "https://github.com/google/snappy/archive/1.1.9.tar.gz"
-    sha256: "75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7"
-  "1.1.8":
-    url: "https://github.com/google/snappy/archive/1.1.8.tar.gz"
-    sha256: "16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f"
-  "1.1.7":
-    url: "https://github.com/google/snappy/archive/1.1.7.tar.gz"
-    sha256: "3dfa02e873ff51a11ee02b9ca391807f0c8ea0529a4924afa645fbf97163f9d4"
-patches:
-  "1.1.10":
-    - patch_file: "patches/1.1.10-0001-fix-inlining-failure.patch"
-      patch_description: "disable inlining for compilation error"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.9-0002-no-Werror.patch"
-      patch_description: "disable 'warning as error' options"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.10-0003-fix-clobber-list-older-llvm.patch"
-      patch_description: "disable inline asm on apple-clang"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.9-0004-rtti-by-default.patch"
-      patch_description: "remove 'disable rtti'"
-      patch_type: "conan"
-  "1.1.9":
-    - patch_file: "patches/1.1.9-0001-fix-inlining-failure.patch"
-      patch_description: "disable inlining for compilation error"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.9-0002-no-Werror.patch"
-      patch_description: "disable 'warning as error' options"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.9-0003-fix-clobber-list-older-llvm.patch"
-      patch_description: "disable inline asm on apple-clang"
-      patch_type: "portability"
-    - patch_file: "patches/1.1.9-0004-rtti-by-default.patch"
-      patch_description: "remove 'disable rtti'"
-      patch_type: "conan"

external/snappy/conanfile.py

@@ -1,89 +0,0 @@
-from conan import ConanFile
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
-from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get, rmdir
-from conan.tools.scm import Version
-import os
-
-required_conan_version = ">=1.54.0"
-
-
-class SnappyConan(ConanFile):
-    name = "snappy"
-    description = "A fast compressor/decompressor"
-    topics = ("google", "compressor", "decompressor")
-    url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/google/snappy"
-    license = "BSD-3-Clause"
-
-    package_type = "library"
-    settings = "os", "arch", "compiler", "build_type"
-    options = {
-        "shared": [True, False],
-        "fPIC": [True, False],
-    }
-    default_options = {
-        "shared": False,
-        "fPIC": True,
-    }
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def config_options(self):
-        if self.settings.os == 'Windows':
-            del self.options.fPIC
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, 11)
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-        tc.variables["SNAPPY_BUILD_TESTS"] = False
-        if Version(self.version) >= "1.1.8":
-            tc.variables["SNAPPY_FUZZING_BUILD"] = False
-            tc.variables["SNAPPY_REQUIRE_AVX"] = False
-            tc.variables["SNAPPY_REQUIRE_AVX2"] = False
-            tc.variables["SNAPPY_INSTALL"] = True
-        if Version(self.version) >= "1.1.9":
-            tc.variables["SNAPPY_BUILD_BENCHMARKS"] = False
-        tc.generate()
-
-    def build(self):
-        apply_conandata_patches(self)
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def package(self):
-        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
-        cmake = CMake(self)
-        cmake.install()
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_file_name", "Snappy")
-        self.cpp_info.set_property("cmake_target_name", "Snappy::snappy")
-        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.components["snappylib"].libs = ["snappy"]
-        if not self.options.shared:
-            if self.settings.os in ["Linux", "FreeBSD"]:
-                self.cpp_info.components["snappylib"].system_libs.append("m")
-
-        # TODO: to remove in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.names["cmake_find_package"] = "Snappy"
-        self.cpp_info.names["cmake_find_package_multi"] = "Snappy"
-        self.cpp_info.components["snappylib"].names["cmake_find_package"] = "snappy"
-        self.cpp_info.components["snappylib"].names["cmake_find_package_multi"] = "snappy"
-        self.cpp_info.components["snappylib"].set_property("cmake_target_name", "Snappy::snappy")

external/snappy/patches/1.1.10-0001-fix-inlining-failure.patch

@@ -1,13 +0,0 @@
-diff --git a/snappy-stubs-internal.h b/snappy-stubs-internal.h
-index 1548ed7..3b4a9f3 100644
---- a/snappy-stubs-internal.h
-+++ b/snappy-stubs-internal.h
-@@ -100,7 +100,7 @@
- 
- // Inlining hints.
- #if HAVE_ATTRIBUTE_ALWAYS_INLINE
--#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-+#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
- #else
- #define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
- #endif  // HAVE_ATTRIBUTE_ALWAYS_INLINE

external/snappy/patches/1.1.10-0003-fix-clobber-list-older-llvm.patch

@@ -1,13 +0,0 @@
-diff --git a/snappy.cc b/snappy.cc
-index d414718..e4efb59 100644
---- a/snappy.cc
-+++ b/snappy.cc
-@@ -1132,7 +1132,7 @@ inline size_t AdvanceToNextTagX86Optimized(const uint8_t** ip_p, size_t* tag) {
-   size_t literal_len = *tag >> 2;
-   size_t tag_type = *tag;
-   bool is_literal;
--#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__)
-+#if defined(__GCC_ASM_FLAG_OUTPUTS__) && defined(__x86_64__) && ( (!defined(__clang__) && !defined(__APPLE__)) || (!defined(__APPLE__) && defined(__clang__) && (__clang_major__ >= 9)) || (defined(__APPLE__) && defined(__clang__) && (__clang_major__ > 11)) )
-   // TODO clang misses the fact that the (c & 3) already correctly
-   // sets the zero flag.
-   asm("and $3, %k[tag_type]\n\t"

external/snappy/patches/1.1.9-0001-fix-inlining-failure.patch

@@ -1,14 +0,0 @@
-Fixes the following error:
-error: inlining failed in call to ‘always_inline’ ‘size_t snappy::AdvanceToNextTag(const uint8_t**, size_t*)’: function body can be overwritten at link time
-
---- snappy-stubs-internal.h
-+++ snappy-stubs-internal.h
-@@ -100,7 +100,7 @@
- 
- // Inlining hints.
- #ifdef HAVE_ATTRIBUTE_ALWAYS_INLINE
--#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-+#define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
- #else
- #define SNAPPY_ATTRIBUTE_ALWAYS_INLINE
- #endif

external/snappy/patches/1.1.9-0002-no-Werror.patch

@@ -1,12 +0,0 @@
---- CMakeLists.txt
-+++ CMakeLists.txt
-@@ -69,7 +69,7 @@
--  # Use -Werror for clang only.
-+if(0)
-   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-     if(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
-       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-     endif(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
-   endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
--
-+endif()

external/snappy/patches/1.1.9-0003-fix-clobber-list-older-llvm.patch

@@ -1,12 +0,0 @@
-asm clobbers do not work for clang < 9 and apple-clang < 11 (found by SpaceIm)
---- snappy.cc
-+++ snappy.cc
-@@ -1026,7 +1026,7 @@
-   size_t literal_len = *tag >> 2;
-   size_t tag_type = *tag;
-   bool is_literal;
--#if defined(__GNUC__) && defined(__x86_64__)
-+#if defined(__GNUC__) && defined(__x86_64__) && ( (!defined(__clang__) && !defined(__APPLE__)) || (!defined(__APPLE__) && defined(__clang__) && (__clang_major__ >= 9)) || (defined(__APPLE__) && defined(__clang__) && (__clang_major__ > 11)) )
-   // TODO clang misses the fact that the (c & 3) already correctly
-   // sets the zero flag.
-   asm("and $3, %k[tag_type]\n\t"

external/snappy/patches/1.1.9-0004-rtti-by-default.patch

@@ -1,20 +0,0 @@
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -53,8 +53,6 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-   add_definitions(-D_HAS_EXCEPTIONS=0)
- 
-   # Disable RTTI.
--  string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
--  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
- else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-   # Use -Wall for clang and gcc.
-   if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
-@@ -78,8 +76,6 @@ endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
- 
-   # Disable RTTI.
--  string(REGEX REPLACE "-frtti" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
--  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
- endif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
- 
- # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make

external/soci/conandata.yml

@@ -1,12 +0,0 @@
-sources:
-  "4.0.3":
-    url: "https://github.com/SOCI/soci/archive/v4.0.3.tar.gz"
-    sha256: "4b1ff9c8545c5d802fbe06ee6cd2886630e5c03bf740e269bb625b45cf934928"
-patches:
-  "4.0.3":
-    - patch_file: "patches/0001-Remove-hardcoded-INSTALL_NAME_DIR-for-relocatable-li.patch"
-      patch_description: "Generate relocatable libraries on MacOS"
-      patch_type: "portability"
-    - patch_file: "patches/0002-Fix-soci_backend.patch"
-      patch_description: "Fix variable names for dependencies"
-      patch_type: "conan"

external/soci/conanfile.py

@@ -1,212 +0,0 @@
-from conan import ConanFile
-from conan.tools.build import check_min_cppstd
-from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
-from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get, rmdir
-from conan.tools.microsoft import is_msvc
-from conan.tools.scm import Version
-from conan.errors import ConanInvalidConfiguration
-import os
-
-required_conan_version = ">=1.55.0"
-
-
-class SociConan(ConanFile):
-    name = "soci"
-    homepage = "https://github.com/SOCI/soci"
-    url = "https://github.com/conan-io/conan-center-index"
-    description = "The C++ Database Access Library "
-    topics = ("mysql", "odbc", "postgresql", "sqlite3")
-    license = "BSL-1.0"
-
-    settings = "os", "arch", "compiler", "build_type"
-    options = {
-        "shared":           [True, False],
-        "fPIC":             [True, False],
-        "empty":            [True, False],
-        "with_sqlite3":     [True, False],
-        "with_db2":         [True, False],
-        "with_odbc":        [True, False],
-        "with_oracle":      [True, False],
-        "with_firebird":    [True, False],
-        "with_mysql":       [True, False],
-        "with_postgresql":  [True, False],
-        "with_boost":       [True, False],
-    }
-    default_options = {
-        "shared":           False,
-        "fPIC":             True,
-        "empty":            False,
-        "with_sqlite3":     False,
-        "with_db2":         False,
-        "with_odbc":        False,
-        "with_oracle":      False,
-        "with_firebird":    False,
-        "with_mysql":       False,
-        "with_postgresql":  False,
-        "with_boost":       False,
-    }
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def layout(self):
-        cmake_layout(self, src_folder="src")
-
-    def config_options(self):
-        if self.settings.os == "Windows":
-            self.options.rm_safe("fPIC")
-
-    def configure(self):
-        if self.options.shared:
-            self.options.rm_safe("fPIC")
-
-    def requirements(self):
-        if self.options.with_sqlite3:
-            self.requires("sqlite3/3.47.0")
-        if self.options.with_odbc and self.settings.os != "Windows":
-            self.requires("odbc/2.3.11")
-        if self.options.with_mysql:
-            self.requires("libmysqlclient/8.1.0")
-        if self.options.with_postgresql:
-            self.requires("libpq/15.5")
-        if self.options.with_boost:
-            self.requires("boost/1.83.0")
-
-    @property
-    def _minimum_compilers_version(self):
-        return {
-            "Visual Studio": "14",
-            "gcc": "4.8",
-            "clang": "3.8",
-            "apple-clang": "8.0"
-        }
-
-    def validate(self):
-        if self.settings.compiler.get_safe("cppstd"):
-            check_min_cppstd(self, 11)
-
-        compiler = str(self.settings.compiler)
-        compiler_version = Version(self.settings.compiler.version.value)
-        if compiler not in self._minimum_compilers_version:
-            self.output.warning("{} recipe lacks information about the {} compiler support.".format(self.name, self.settings.compiler))
-        elif compiler_version < self._minimum_compilers_version[compiler]:
-            raise ConanInvalidConfiguration("{} requires a {} version >= {}".format(self.name, compiler, compiler_version))
-
-        prefix  = "Dependencies for"
-        message = "not configured in this conan package."
-        if self.options.with_db2:
-            # self.requires("db2/0.0.0") # TODO add support for db2
-            raise ConanInvalidConfiguration("{} DB2 {} ".format(prefix, message))
-        if self.options.with_oracle:
-            # self.requires("oracle_db/0.0.0") # TODO add support for oracle
-            raise ConanInvalidConfiguration("{} ORACLE {} ".format(prefix, message))
-        if self.options.with_firebird:
-            # self.requires("firebird/0.0.0") # TODO add support for firebird
-            raise ConanInvalidConfiguration("{} firebird {} ".format(prefix, message))
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def generate(self):
-        tc = CMakeToolchain(self)
-
-        tc.variables["SOCI_SHARED"] = self.options.shared
-        tc.variables["SOCI_STATIC"] = not self.options.shared
-        tc.variables["SOCI_TESTS"] = False
-        tc.variables["SOCI_CXX11"] = True
-        tc.variables["SOCI_EMPTY"] = self.options.empty
-        tc.variables["WITH_SQLITE3"] = self.options.with_sqlite3
-        tc.variables["WITH_DB2"] = self.options.with_db2
-        tc.variables["WITH_ODBC"] = self.options.with_odbc
-        tc.variables["WITH_ORACLE"] = self.options.with_oracle
-        tc.variables["WITH_FIREBIRD"] = self.options.with_firebird
-        tc.variables["WITH_MYSQL"] = self.options.with_mysql
-        tc.variables["WITH_POSTGRESQL"] = self.options.with_postgresql
-        tc.variables["WITH_BOOST"] = self.options.with_boost
-        tc.generate()
-
-        deps = CMakeDeps(self)
-        deps.generate()
-
-    def build(self):
-        apply_conandata_patches(self)
-        cmake = CMake(self)
-        cmake.configure()
-        cmake.build()
-
-    def package(self):
-        copy(self, "LICENSE_1_0.txt", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
-
-        cmake = CMake(self)
-        cmake.install()
-
-        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
-
-    def package_info(self):
-        self.cpp_info.set_property("cmake_file_name", "SOCI")
-
-        target_suffix = "" if self.options.shared else "_static"
-        lib_prefix = "lib" if is_msvc(self) and not self.options.shared else ""
-        version = Version(self.version)
-        lib_suffix = "_{}_{}".format(version.major, version.minor) if self.settings.os == "Windows" else ""
-
-        # soci_core
-        self.cpp_info.components["soci_core"].set_property("cmake_target_name", "SOCI::soci_core{}".format(target_suffix))
-        self.cpp_info.components["soci_core"].libs = ["{}soci_core{}".format(lib_prefix, lib_suffix)]
-        if self.options.with_boost:
-            self.cpp_info.components["soci_core"].requires.append("boost::boost")
-
-        # soci_empty
-        if self.options.empty:
-            self.cpp_info.components["soci_empty"].set_property("cmake_target_name", "SOCI::soci_empty{}".format(target_suffix))
-            self.cpp_info.components["soci_empty"].libs = ["{}soci_empty{}".format(lib_prefix, lib_suffix)]
-            self.cpp_info.components["soci_empty"].requires = ["soci_core"]
-
-        # soci_sqlite3
-        if self.options.with_sqlite3:
-            self.cpp_info.components["soci_sqlite3"].set_property("cmake_target_name", "SOCI::soci_sqlite3{}".format(target_suffix))
-            self.cpp_info.components["soci_sqlite3"].libs = ["{}soci_sqlite3{}".format(lib_prefix, lib_suffix)]
-            self.cpp_info.components["soci_sqlite3"].requires = ["soci_core", "sqlite3::sqlite3"]
-
-        # soci_odbc
-        if self.options.with_odbc:
-            self.cpp_info.components["soci_odbc"].set_property("cmake_target_name", "SOCI::soci_odbc{}".format(target_suffix))
-            self.cpp_info.components["soci_odbc"].libs = ["{}soci_odbc{}".format(lib_prefix, lib_suffix)]
-            self.cpp_info.components["soci_odbc"].requires = ["soci_core"]
-            if self.settings.os == "Windows":
-                self.cpp_info.components["soci_odbc"].system_libs.append("odbc32")
-            else:
-                self.cpp_info.components["soci_odbc"].requires.append("odbc::odbc")
-
-        # soci_mysql
-        if self.options.with_mysql:
-            self.cpp_info.components["soci_mysql"].set_property("cmake_target_name", "SOCI::soci_mysql{}".format(target_suffix))
-            self.cpp_info.components["soci_mysql"].libs = ["{}soci_mysql{}".format(lib_prefix, lib_suffix)]
-            self.cpp_info.components["soci_mysql"].requires = ["soci_core", "libmysqlclient::libmysqlclient"]
-
-        # soci_postgresql
-        if self.options.with_postgresql:
-            self.cpp_info.components["soci_postgresql"].set_property("cmake_target_name", "SOCI::soci_postgresql{}".format(target_suffix))
-            self.cpp_info.components["soci_postgresql"].libs = ["{}soci_postgresql{}".format(lib_prefix, lib_suffix)]
-            self.cpp_info.components["soci_postgresql"].requires = ["soci_core", "libpq::libpq"]
-
-        # TODO: to remove in conan v2 once cmake_find_package* generators removed
-        self.cpp_info.names["cmake_find_package"] = "SOCI"
-        self.cpp_info.names["cmake_find_package_multi"] = "SOCI"
-        self.cpp_info.components["soci_core"].names["cmake_find_package"] = "soci_core{}".format(target_suffix)
-        self.cpp_info.components["soci_core"].names["cmake_find_package_multi"] = "soci_core{}".format(target_suffix)
-        if self.options.empty:
-            self.cpp_info.components["soci_empty"].names["cmake_find_package"] = "soci_empty{}".format(target_suffix)
-            self.cpp_info.components["soci_empty"].names["cmake_find_package_multi"] = "soci_empty{}".format(target_suffix)
-        if self.options.with_sqlite3:
-            self.cpp_info.components["soci_sqlite3"].names["cmake_find_package"] = "soci_sqlite3{}".format(target_suffix)
-            self.cpp_info.components["soci_sqlite3"].names["cmake_find_package_multi"] = "soci_sqlite3{}".format(target_suffix)
-        if self.options.with_odbc:
-            self.cpp_info.components["soci_odbc"].names["cmake_find_package"] = "soci_odbc{}".format(target_suffix)
-            self.cpp_info.components["soci_odbc"].names["cmake_find_package_multi"] = "soci_odbc{}".format(target_suffix)
-        if self.options.with_mysql:
-            self.cpp_info.components["soci_mysql"].names["cmake_find_package"] = "soci_mysql{}".format(target_suffix)
-            self.cpp_info.components["soci_mysql"].names["cmake_find_package_multi"] = "soci_mysql{}".format(target_suffix)
-        if self.options.with_postgresql:
-            self.cpp_info.components["soci_postgresql"].names["cmake_find_package"] = "soci_postgresql{}".format(target_suffix)
-            self.cpp_info.components["soci_postgresql"].names["cmake_find_package_multi"] = "soci_postgresql{}".format(target_suffix)

external/soci/patches/0001-Remove-hardcoded-INSTALL_NAME_DIR-for-relocatable-li.patch

@@ -1,39 +0,0 @@
-From d491bf7b5040d314ffd0c6310ba01f78ff44c85e Mon Sep 17 00:00:00 2001
-From: Rasmus Thomsen <rasmus.thomsen@dampsoft.de>
-Date: Fri, 14 Apr 2023 09:16:29 +0200
-Subject: [PATCH] Remove hardcoded INSTALL_NAME_DIR for relocatable libraries
- on MacOS
-
----
- cmake/SociBackend.cmake | 2 +-
- src/core/CMakeLists.txt | 1 -
- 2 files changed, 1 insertion(+), 2 deletions(-)
-
-diff --git a/cmake/SociBackend.cmake b/cmake/SociBackend.cmake
-index 5d4ef0df..39fe1f77 100644
---- a/cmake/SociBackend.cmake
-+++ b/cmake/SociBackend.cmake
-@@ -171,7 +171,7 @@ macro(soci_backend NAME)
-           set_target_properties(${THIS_BACKEND_TARGET}
-             PROPERTIES
-             SOVERSION ${${PROJECT_NAME}_SOVERSION}
--            INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib)
-+          )
- 
-           if(APPLE)
-             set_target_properties(${THIS_BACKEND_TARGET}
-diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
-index 3e7deeae..f9eae564 100644
---- a/src/core/CMakeLists.txt
-+++ b/src/core/CMakeLists.txt
-@@ -59,7 +59,6 @@ if (SOCI_SHARED)
-       PROPERTIES
-       VERSION ${SOCI_VERSION}
-       SOVERSION ${SOCI_SOVERSION}
--      INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib
-       CLEAN_DIRECT_OUTPUT 1)
-   endif()
- 
--- 
-2.25.1
-

external/soci/patches/0002-Fix-soci_backend.patch

@@ -1,24 +0,0 @@
-diff --git a/cmake/SociBackend.cmake b/cmake/SociBackend.cmake
-index 0a664667..3fa2ed95 100644
---- a/cmake/SociBackend.cmake
-+++ b/cmake/SociBackend.cmake
-@@ -31,14 +31,13 @@ macro(soci_backend_deps_found NAME DEPS SUCCESS)
-     if(NOT DEPEND_FOUND)
-       list(APPEND DEPS_NOT_FOUND ${dep})
-     else()
--      string(TOUPPER "${dep}" DEPU)
--      if( ${DEPU}_INCLUDE_DIR )
--        list(APPEND DEPS_INCLUDE_DIRS ${${DEPU}_INCLUDE_DIR})
-+      if( ${dep}_INCLUDE_DIR )
-+        list(APPEND DEPS_INCLUDE_DIRS ${${dep}_INCLUDE_DIR})
-       endif()
--      if( ${DEPU}_INCLUDE_DIRS )
--        list(APPEND DEPS_INCLUDE_DIRS ${${DEPU}_INCLUDE_DIRS})
-+      if( ${dep}_INCLUDE_DIRS )
-+        list(APPEND DEPS_INCLUDE_DIRS ${${dep}_INCLUDE_DIRS})
-       endif()
--      list(APPEND DEPS_LIBRARIES ${${DEPU}_LIBRARIES})
-+      list(APPEND DEPS_LIBRARIES ${${dep}_LIBRARIES})
-     endif()
-   endforeach()
- 

include/xrpl/basics/Buffer.h

@@ -25,6 +25,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <memory>
 
 namespace ripple {
 

include/xrpl/basics/Expected.h

@@ -22,8 +22,18 @@
 
 #include <xrpl/basics/contract.h>
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 #include <boost/outcome.hpp>
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 #include <stdexcept>
 
 namespace ripple {

include/xrpl/basics/Log.h

@@ -26,6 +26,7 @@
 #include <boost/beast/core/string.hpp>
 #include <boost/filesystem.hpp>
 
+#include <fstream>
 #include <map>
 #include <memory>
 #include <mutex>

include/xrpl/basics/SHAMapHash.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_SHAMAP_HASH_H_INCLUDED
 
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/partitioned_unordered_map.h>
 
 #include <ostream>
 

include/xrpl/basics/StringUtilities.h

@@ -29,7 +29,6 @@
 #include <array>
 #include <cstdint>
 #include <optional>
-#include <sstream>
 #include <string>
 
 namespace ripple {

include/xrpl/basics/TaggedCache.h

@@ -90,9 +90,6 @@ public:
     int
     getCacheSize() const;
 
-    int
-    getTrackSize() const;
-
     float
     getHitRate();
 
@@ -170,9 +167,6 @@ public:
     bool
     retrieve(key_type const& key, T& data);
 
-    mutex_type&
-    peekMutex();
-
     std::vector<key_type>
     getKeys() const;
 
@@ -193,11 +187,14 @@ public:
 
 private:
     SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    initialFetch(key_type const& key);
 
     void
     collect_metrics();
 
+    Mutex&
+    lockPartition(key_type const& key) const;
+
 private:
     struct Stats
     {
@@ -300,8 +297,8 @@ private:
         [[maybe_unused]] clock_type::time_point const& now,
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
-        std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::atomic<int>& allRemoval,
+        Mutex& partitionLock);
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -310,14 +307,12 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        Mutex& partitionLock);
 
     beast::Journal m_journal;
     clock_type& m_clock;
     Stats m_stats;
 
-    mutex_type mutable m_mutex;
-
     // Used for logging
     std::string m_name;
 
@@ -328,10 +323,11 @@ private:
     clock_type::duration const m_target_age;
 
     // Number of items cached
-    int m_cache_count;
+    std::atomic<int> m_cache_count;
     cache_type m_cache;  // Hold strong reference to recent objects
-    std::uint64_t m_hits;
-    std::uint64_t m_misses;
+    std::atomic<std::uint64_t> m_hits;
+    std::atomic<std::uint64_t> m_misses;
+    mutable std::vector<mutex_type> partitionLocks_;
 };
 
 }  // namespace ripple

include/xrpl/basics/TaggedCache.ipp

@@ -22,6 +22,7 @@
 
 #include <xrpl/basics/IntrusivePointer.ipp>
 #include <xrpl/basics/TaggedCache.h>
+#include <xrpl/beast/core/CurrentThreadName.h>
 
 namespace ripple {
 
@@ -60,6 +61,7 @@ inline TaggedCache<
     , m_hits(0)
     , m_misses(0)
 {
+    partitionLocks_ = std::vector<mutex_type>(m_cache.partitions());
 }
 
 template <
@@ -105,8 +107,13 @@ TaggedCache<
     KeyEqual,
     Mutex>::size() const
 {
-    std::lock_guard lock(m_mutex);
-    return m_cache.size();
+    std::size_t totalSize = 0;
+    for (size_t i = 0; i < partitionLocks_.size(); ++i)
+    {
+        std::lock_guard<Mutex> lock(partitionLocks_[i]);
+        totalSize += m_cache.map()[i].size();
+    }
+    return totalSize;
 }
 
 template <
@@ -129,32 +136,7 @@ TaggedCache<
     KeyEqual,
     Mutex>::getCacheSize() const
 {
-    std::lock_guard lock(m_mutex);
-    return m_cache_count;
-}
-
-template <
-    class Key,
-    class T,
-    bool IsKeyCache,
-    class SharedWeakUnionPointer,
-    class SharedPointerType,
-    class Hash,
-    class KeyEqual,
-    class Mutex>
-inline int
-TaggedCache<
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::getTrackSize() const
-{
-    std::lock_guard lock(m_mutex);
-    return m_cache.size();
+    return m_cache_count.load(std::memory_order_relaxed);
 }
 
 template <
@@ -177,9 +159,10 @@ TaggedCache<
     KeyEqual,
     Mutex>::getHitRate()
 {
-    std::lock_guard lock(m_mutex);
-    auto const total = static_cast<float>(m_hits + m_misses);
-    return m_hits * (100.0f / std::max(1.0f, total));
+    auto const hits = m_hits.load(std::memory_order_relaxed);
+    auto const misses = m_misses.load(std::memory_order_relaxed);
+    float const total = float(hits + misses);
+    return hits * (100.0f / std::max(1.0f, total));
 }
 
 template <
@@ -202,9 +185,12 @@ TaggedCache<
     KeyEqual,
     Mutex>::clear()
 {
-    std::lock_guard lock(m_mutex);
+    for (auto& mutex : partitionLocks_)
+        mutex.lock();
     m_cache.clear();
-    m_cache_count = 0;
+    for (auto& mutex : partitionLocks_)
+        mutex.unlock();
+    m_cache_count.store(0, std::memory_order_relaxed);
 }
 
 template <
@@ -227,11 +213,9 @@ TaggedCache<
     KeyEqual,
     Mutex>::reset()
 {
-    std::lock_guard lock(m_mutex);
-    m_cache.clear();
-    m_cache_count = 0;
-    m_hits = 0;
-    m_misses = 0;
+    clear();
+    m_hits.store(0, std::memory_order_relaxed);
+    m_misses.store(0, std::memory_order_relaxed);
 }
 
 template <
@@ -255,7 +239,7 @@ TaggedCache<
     KeyEqual,
     Mutex>::touch_if_exists(KeyComparable const& key)
 {
-    std::lock_guard lock(m_mutex);
+    std::lock_guard<Mutex> lock(lockPartition(key));
     auto const iter(m_cache.find(key));
     if (iter == m_cache.end())
     {
@@ -297,8 +281,6 @@ TaggedCache<
 
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard lock(m_mutex);
-
         if (m_target_size == 0 ||
             (static_cast<int>(m_cache.size()) <= m_target_size))
         {
@@ -330,12 +312,13 @@ TaggedCache<
                 m_cache.map()[p],
                 allStuffToSweep[p],
                 allRemovals,
-                lock));
+                partitionLocks_[p]));
         }
         for (std::thread& worker : workers)
             worker.join();
 
-        m_cache_count -= allRemovals;
+        int removals = allRemovals.load(std::memory_order_relaxed);
+        m_cache_count.fetch_sub(removals, std::memory_order_relaxed);
     }
     // At this point allStuffToSweep will go out of scope outside the lock
     // and decrement the reference count on each strong pointer.
@@ -369,7 +352,8 @@ TaggedCache<
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
-    std::lock_guard lock(m_mutex);
+
+    std::lock_guard<Mutex> lock(lockPartition(key));
 
     auto cit = m_cache.find(key);
 
@@ -382,7 +366,7 @@ TaggedCache<
 
     if (entry.isCached())
     {
-        --m_cache_count;
+        m_cache_count.fetch_sub(1, std::memory_order_relaxed);
         entry.ptr.convertToWeak();
         ret = true;
     }
@@ -420,17 +404,16 @@ TaggedCache<
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
-    std::lock_guard lock(m_mutex);
 
+    std::lock_guard<Mutex> lock(lockPartition(key));
     auto cit = m_cache.find(key);
-
     if (cit == m_cache.end())
     {
         m_cache.emplace(
             std::piecewise_construct,
             std::forward_as_tuple(key),
             std::forward_as_tuple(m_clock.now(), data));
-        ++m_cache_count;
+        m_cache_count.fetch_add(1, std::memory_order_relaxed);
         return false;
     }
 
@@ -479,12 +462,12 @@ TaggedCache<
             data = cachedData;
         }
 
-        ++m_cache_count;
+        m_cache_count.fetch_add(1, std::memory_order_relaxed);
         return true;
     }
 
     entry.ptr = data;
-    ++m_cache_count;
+    m_cache_count.fetch_add(1, std::memory_order_relaxed);
 
     return false;
 }
@@ -560,10 +543,11 @@ TaggedCache<
     KeyEqual,
     Mutex>::fetch(key_type const& key)
 {
-    std::lock_guard<mutex_type> l(m_mutex);
-    auto ret = initialFetch(key, l);
+    std::lock_guard<Mutex> lock(lockPartition(key));
+
+    auto ret = initialFetch(key);
     if (!ret)
-        ++m_misses;
+        m_misses.fetch_add(1, std::memory_order_relaxed);
     return ret;
 }
 
@@ -627,8 +611,8 @@ TaggedCache<
     Mutex>::insert(key_type const& key)
     -> std::enable_if_t<IsKeyCache, ReturnType>
 {
-    std::lock_guard lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
+    std::lock_guard<Mutex> lock(lockPartition(key));
     auto [it, inserted] = m_cache.emplace(
         std::piecewise_construct,
         std::forward_as_tuple(key),
@@ -668,29 +652,6 @@ TaggedCache<
     return true;
 }
 
-template <
-    class Key,
-    class T,
-    bool IsKeyCache,
-    class SharedWeakUnionPointer,
-    class SharedPointerType,
-    class Hash,
-    class KeyEqual,
-    class Mutex>
-inline auto
-TaggedCache<
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::peekMutex() -> mutex_type&
-{
-    return m_mutex;
-}
-
 template <
     class Key,
     class T,
@@ -714,10 +675,13 @@ TaggedCache<
     std::vector<key_type> v;
 
     {
-        std::lock_guard lock(m_mutex);
         v.reserve(m_cache.size());
-        for (auto const& _ : m_cache)
-            v.push_back(_.first);
+        for (std::size_t i = 0; i < partitionLocks_.size(); ++i)
+        {
+            std::lock_guard<Mutex> lock(partitionLocks_[i]);
+            for (auto const& entry : m_cache.map()[i])
+                v.push_back(entry.first);
+        }
     }
 
     return v;
@@ -743,11 +707,12 @@ TaggedCache<
     KeyEqual,
     Mutex>::rate() const
 {
-    std::lock_guard lock(m_mutex);
-    auto const tot = m_hits + m_misses;
+    auto const hits = m_hits.load(std::memory_order_relaxed);
+    auto const misses = m_misses.load(std::memory_order_relaxed);
+    auto const tot = hits + misses;
     if (tot == 0)
-        return 0;
-    return double(m_hits) / tot;
+        return 0.0;
+    return double(hits) / tot;
 }
 
 template <
@@ -771,18 +736,16 @@ TaggedCache<
     KeyEqual,
     Mutex>::fetch(key_type const& digest, Handler const& h)
 {
-    {
-        std::lock_guard l(m_mutex);
-        if (auto ret = initialFetch(digest, l))
-            return ret;
-    }
+    std::lock_guard<Mutex> lock(lockPartition(digest));
+
+    if (auto ret = initialFetch(digest))
+        return ret;
 
     auto sle = h();
     if (!sle)
         return {};
 
-    std::lock_guard l(m_mutex);
-    ++m_misses;
+    m_misses.fetch_add(1, std::memory_order_relaxed);
     auto const [it, inserted] =
         m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
     if (!inserted)
@@ -809,9 +772,10 @@ TaggedCache<
     SharedPointerType,
     Hash,
     KeyEqual,
-    Mutex>::
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    Mutex>::initialFetch(key_type const& key)
 {
+    std::lock_guard<Mutex> lock(lockPartition(key));
+
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
         return {};
@@ -819,7 +783,7 @@ TaggedCache<
     Entry& entry = cit->second;
     if (entry.isCached())
     {
-        ++m_hits;
+        m_hits.fetch_add(1, std::memory_order_relaxed);
         entry.touch(m_clock.now());
         return entry.ptr.getStrong();
     }
@@ -827,12 +791,13 @@ TaggedCache<
     if (entry.isCached())
     {
         // independent of cache size, so not counted as a hit
-        ++m_cache_count;
+        m_cache_count.fetch_add(1, std::memory_order_relaxed);
         entry.touch(m_clock.now());
         return entry.ptr.getStrong();
     }
 
     m_cache.erase(cit);
+
     return {};
 }
 
@@ -861,10 +826,11 @@ TaggedCache<
     {
         beast::insight::Gauge::value_type hit_rate(0);
         {
-            std::lock_guard lock(m_mutex);
-            auto const total(m_hits + m_misses);
+            auto const hits = m_hits.load(std::memory_order_relaxed);
+            auto const misses = m_misses.load(std::memory_order_relaxed);
+            auto const total = hits + misses;
             if (total != 0)
-                hit_rate = (m_hits * 100) / total;
+                hit_rate = (hits * 100) / total;
         }
         m_stats.hit_rate.set(hit_rate);
     }
@@ -895,12 +861,16 @@ TaggedCache<
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        Mutex& partitionLock)
 {
     return std::thread([&, this]() {
+        beast::setCurrentThreadName("sweep-KVCache");
+
         int cacheRemovals = 0;
         int mapRemovals = 0;
 
+        std::lock_guard<Mutex> lock(partitionLock);
+
         // Keep references to all the stuff we sweep
         // so that we can destroy them outside the lock.
         stuffToSweep.reserve(partition.size());
@@ -984,12 +954,16 @@ TaggedCache<
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        Mutex& partitionLock)
 {
     return std::thread([&, this]() {
+        beast::setCurrentThreadName("sweep-KCache");
+
         int cacheRemovals = 0;
         int mapRemovals = 0;
 
+        std::lock_guard<Mutex> lock(partitionLock);
+
         // Keep references to all the stuff we sweep
         // so that we can destroy them outside the lock.
         {
@@ -1024,6 +998,29 @@ TaggedCache<
     });
 }
 
+template <
+    class Key,
+    class T,
+    bool IsKeyCache,
+    class SharedWeakUnionPointer,
+    class SharedPointerType,
+    class Hash,
+    class KeyEqual,
+    class Mutex>
+inline Mutex&
+TaggedCache<
+    Key,
+    T,
+    IsKeyCache,
+    SharedWeakUnionPointer,
+    SharedPointerType,
+    Hash,
+    KeyEqual,
+    Mutex>::lockPartition(key_type const& key) const
+{
+    return partitionLocks_[m_cache.partition_index(key)];
+}
+
 }  // namespace ripple
 
 #endif

include/xrpl/basics/algorithm.h

@@ -20,7 +20,6 @@
 #ifndef RIPPLE_ALGORITHM_H_INCLUDED
 #define RIPPLE_ALGORITHM_H_INCLUDED
 
-#include <iterator>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/hardened_hash.h

@@ -24,12 +24,8 @@
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>
-#include <functional>
 #include <mutex>
 #include <random>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/mulDiv.h

@@ -23,7 +23,6 @@
 #include <cstdint>
 #include <limits>
 #include <optional>
-#include <utility>
 
 namespace ripple {
 auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();

include/xrpl/basics/partitioned_unordered_map.h

@@ -277,6 +277,12 @@ public:
         return map_;
     }
 
+    partition_map_type const&
+    map() const
+    {
+        return map_;
+    }
+
     iterator
     begin()
     {
@@ -321,6 +327,12 @@ public:
         return cend();
     }
 
+    std::size_t
+    partition_index(key_type const& key) const
+    {
+        return partitioner(key);
+    }
+
 private:
     template <class T>
     void

include/xrpl/basics/tagged_integer.h

@@ -24,10 +24,8 @@
 
 #include <boost/operators.hpp>
 
-#include <functional>
 #include <iostream>
 #include <type_traits>
-#include <utility>
 
 namespace ripple {
 

include/xrpl/beast/clock/abstract_clock.h

@@ -20,9 +20,6 @@
 #ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
-#include <chrono>
-#include <string>
-
 namespace beast {
 
 /** Abstract interface to a clock.

include/xrpl/beast/clock/manual_clock.h

@@ -23,6 +23,8 @@
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
+#include <chrono>
+
 namespace beast {
 
 /** Manual clock implementation.

include/xrpl/beast/container/aged_container_utility.h

@@ -22,6 +22,7 @@
 
 #include <xrpl/beast/container/aged_container.h>
 
+#include <chrono>
 #include <type_traits>
 
 namespace beast {

include/xrpl/beast/container/detail/aged_associative_container.h

@@ -20,8 +20,6 @@
 #ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 #define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
-#include <type_traits>
-
 namespace beast {
 namespace detail {