Merge branch 'master' into sf-ankerl

wip
2024-06-26 18:39:02 +02:00 · 2024-06-26 18:10:53 +02:00 · 2024-06-26 18:10:19 +02:00 · 2024-06-25 18:58:48 +02:00 · 2024-06-25 18:27:53 +02:00 · 2024-06-25 17:53:09 +02:00
582 changed files with 34232 additions and 21219 deletions
@@ -13,6 +13,10 @@ Checks: >
    -bugprone-forward-declaration-namespace,
    -bugprone-sizeof-expression,
    -bugprone-throw-keyword-missing,
+    -bugprone-chained-comparison,
+    -bugprone-incorrect-enable-if,
+    -bugprone-switch-missing-default-case,
+    -bugprone-empty-catch,
    -clang-analyzer-*,
    -clang-diagnostic-deprecated-declarations,
    -clang-diagnostic-constant-conversion,
@@ -49,11 +53,13 @@ Checks: >
    -misc-misplaced-const,
    -misc-definitions-in-headers,
    -misc-unused-parameters,
+    -misc-include-cleaner,
    modernize-concat-nested-namespaces,
    modernize-use-using,
    performance-*,
-    -performance-noexcept-move-constructor,
    -performance-no-int-to-ptr,
+    -performance-enum-size,
+    -performance-avoid-endl,
    readability-*,
    -readability-avoid-const-params-in-decls,
    -readability-braces-around-statements,
@@ -82,6 +88,10 @@ Checks: >
    -readability-make-member-function-const,
    -readability-redundant-string-init,
    -readability-non-const-parameter,
+    -readability-redundant-inline-specifier,
+    -readability-avoid-nested-conditional-operator,
+    -readability-avoid-return-with-void-value,
+    -readability-redundant-casting,
    -readability-static-accessed-through-instance
    
 WarningsAsErrors: '*'
@@ -6,6 +6,9 @@ on:

 jobs:
  publish:
+    strategy:
+      matrix:
+        docker-base-image: ["debian", "alpine"]
    runs-on: ubuntu-latest
    steps:       
      - name: Check out the repo
@@ -53,10 +56,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.metadebug.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}-${{ matrix.docker-base-image }}


      - name: Build container image - assertions
@@ -64,10 +67,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.metaassertions.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}-${{ matrix.docker-base-image }}

      # build and publish "normal" image as last to get it listed on top
      - name: Build container image - normal
@@ -75,10 +78,7 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile
-          tags:  ${{ steps.meta.outputs.tags  }}
+          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          tags: ${{ steps.meta.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
-
-
-            
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
@@ -15,7 +15,6 @@ env:
  CCACHE_TEMPDIR: /tmp/.ccache-temp
  CCACHE_COMPRESS: 1
  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
-  CCACHE_VERSION: 3.3.1
  CMAKE_VERSION: 3.21.2
  ENABLE_NODE_BINDINGS: "ON"

@@ -31,11 +30,11 @@ jobs:
    env:
      BUILD_TYPE: Release
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - run: pip install "conan<2.0.0"
    - run: conan --version
    - run: cmake --version
-    - uses: actions/setup-node@v3
+    - uses: actions/setup-node@v4
      with:
        node-version: 18
    - run: node --version
@@ -47,15 +46,32 @@ jobs:
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
    - run: npm install --ignore-scripts
    - run: npm link --ignore-scripts
-    - uses: microsoft/setup-msbuild@v1.1
    - name: Build
-      run: |
-        .\scripts\ci\windows-build.bat
-    - name: Run node tests
      shell: bash
      run: |
-        ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-        node test/nodejs/index.js
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
+        cmake --build . --config Release
+        
+    # TODO: MSVC goes out of memory when building our tests
+    # - name: Run tests
+    #   shell: bash
+    #   run: |
+    #     cd build
+    #     cmake --build . --config Release --target tests
+    #     # TODO: run tests
+    # - name: Run node tests
+    #   shell: bash
+    #   run: |
+    #     ./lib/binding/osrm-extract.exe -p profiles/car.lua test/data/monaco.osm.pbf
+
+    #     mkdir -p test/data/ch
+    #     cp test/data/monaco.osrm* test/data/ch/
+    #     ./lib/binding/osrm-contract.exe test/data/ch/monaco.osrm
+
+    #     ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
+    #     node test/nodejs/index.js
    - name: Build Node package
      shell: bash
      run: ./scripts/ci/node_package.sh
@@ -76,13 +92,13 @@ jobs:
  format-taginfo-docs:
    runs-on: ubuntu-22.04
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: Use Node.js
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 18
    - name: Enable Node.js cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@@ -100,15 +116,18 @@ jobs:
        npm run docs && ./scripts/error_on_dirty.sh
        npm audit --production

-  docker-image:
+  docker-image-matrix:
+    strategy:
+      matrix:
+        docker-base-image: ["debian", "alpine"]
    needs: format-taginfo-docs
    runs-on: ubuntu-22.04
    continue-on-error: false
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
      - name: Enable osm.pbf cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        with:
          path: berlin-latest.osm.pbf
          key: v1-berlin-osm-pbf
@@ -116,7 +135,7 @@ jobs:
            v1-berlin-osm-pbf
      - name: Docker build
        run: |
-          docker build -t osrm-backend-local -f docker/Dockerfile .
+          docker build -t osrm-backend-local -f docker/Dockerfile-${{ matrix.docker-base-image }} .
      - name: Test Docker image
        run: |
          if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
@@ -133,7 +152,6 @@ jobs:
            >&2 echo "No berlin-latest.geojson found"
            exit 1
          fi
-
          # removing `.osrm.nbg` to check that whole pipeline works without it
          rm -rf "${PWD}/berlin-latest.osrm.nbg"

@@ -151,7 +169,7 @@ jobs:
          - name: gcc-13-debug-cov
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
            CCOMPILER: gcc-13
@@ -193,17 +211,18 @@ jobs:
            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000

-          - name: clang-15-debug-clang-tidy
+          - name: clang-18-debug-clang-tidy
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+            CCOMPILER: clang-18
+            CXXCOMPILER: clang++-18
            CUCUMBER_TIMEOUT: 60000
            ENABLE_CLANG_TIDY: ON

+
          - name: clang-14-release
            continue-on-error: false
            node: 18
@@ -229,7 +248,7 @@ jobs:
            node: 18
            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
+            BUILD_TYPE: Release
            CCOMPILER: clang-15
            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON
@@ -245,25 +264,24 @@ jobs:
            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON

-          - name: conan-linux-debug
+          - name: gcc-14-release
            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-22.04
+            node: 20
+            runs-on: ubuntu-24.04
            BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
-            ENABLE_CONAN: ON
-          
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-14
+            CXXCOMPILER: g++-14
+            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
+
          - name: gcc-13-release
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-22.04
+            runs-on: ubuntu-24.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-13
            CXXCOMPILER: g++-13
-            ENABLE_BENCHMARKS: ON
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

          - name: gcc-12-release
@@ -274,19 +292,8 @@ jobs:
            BUILD_TYPE: Release
            CCOMPILER: gcc-12
            CXXCOMPILER: g++-12
-            ENABLE_BENCHMARKS: ON
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'

-          - name: gcc-11-release
-            continue-on-error: false
-            node: 20
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-11
-            CXXCOMPILER: g++-11
-            ENABLE_BENCHMARKS: ON
-
          - name: conan-linux-release-node
            build_node_package: true
            continue-on-error: false
@@ -355,44 +362,46 @@ jobs:
      OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
      OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
    - name: Build machine architecture
      run: uname -m
    - name: Use Node.js
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node }}
    - name: Enable Node.js cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-
    - name: Enable compiler cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.ccache
        key: ccache-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          ccache-${{ matrix.name }}-
    - name: Enable Conan cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ~/.conan
        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v9-conan-${{ matrix.name }}-
    - name: Enable test cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
      with:
        path: ${{github.workspace}}/test/cache
        key: v4-test-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v4-test-${{ matrix.name }}-
-
    - name: Prepare environment
      run: |
+        echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+        mkdir -p $HOME/.ccache
+
        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
@@ -409,7 +418,36 @@ jobs:
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
        fi
+    # See: https://github.com/actions/toolkit/issues/946#issuecomment-1590016041
+    # We need it to be able to access system folders while restoring cached Boost below
+    - name: Give tar root ownership 
+      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      run: sudo chown root /bin/tar && sudo chmod u+s /bin/tar
+    - name: Cache Boost
+      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      id: cache-boost
+      uses: actions/cache@v4
+      with:
+        path: |
+          /usr/local/include/boost
+          /usr/local/lib/libboost*
+        key: v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
+        restore-keys: |
+          v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}

+    - name: Install Boost
+      if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
+      run: |
+        BOOST_VERSION="1.85.0"
+        BOOST_VERSION_UNDERSCORE="${BOOST_VERSION//./_}"
+        wget -q https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        tar xzf boost_${BOOST_VERSION_UNDERSCORE}.tar.gz
+        cd boost_${BOOST_VERSION_UNDERSCORE}
+        sudo ./bootstrap.sh
+        sudo ./b2 install
+        cd ..
+        sudo rm -rf boost_${BOOST_VERSION_UNDERSCORE}*
+    
    - name: Install dev dependencies
      run: |
        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
@@ -430,7 +468,7 @@ jobs:
        # Linux dev packages
        if [ "${ENABLE_CONAN}" != "ON" ]; then
          sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev
          if [[ "${CCOMPILER}" != clang-* ]]; then
            sudo apt-get install -y ${CXXCOMPILER}
          fi
@@ -440,7 +478,7 @@ jobs:
        fi

        # TBB
-        TBB_VERSION=2021.3.0
+        TBB_VERSION=2021.12.0
        if [[ "${RUNNER_OS}" == "Linux" ]]; then
          TBB_URL="https://github.com/oneapi-src/oneTBB/releases/download/v${TBB_VERSION}/oneapi-tbb-${TBB_VERSION}-lin.tgz"
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
@@ -471,8 +509,8 @@ jobs:
      run: |
        echo "Using ${JOBS} jobs"
        pushd ${OSRM_BUILD_DIR}
-
-
+        
+        ccache --zero-stats
        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                 -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
@@ -489,7 +527,7 @@ jobs:
        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
          make tests --jobs=${JOBS}
          make benchmarks --jobs=${JOBS}
-          ccache -s
+
          sudo make install
          if [[ "${RUNNER_OS}" == "Linux" ]]; then
            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
@@ -521,22 +559,10 @@ jobs:
        fi
        popd
        npm test
-    - name: Run benchmarks
-      if: ${{ matrix.ENABLE_BENCHMARKS == 'ON' }}
-      run: |
-        pushd ${OSRM_BUILD_DIR}
-        make --jobs=${JOBS} benchmarks
-        ./src/benchmarks/alias-bench
-        ./src/benchmarks/json-render-bench ../src/benchmarks/portugal_to_korea.json
-        ./src/benchmarks/match-bench ../test/data/ch/monaco.osrm ch
-        ./src/benchmarks/match-bench ../test/data/mld/monaco.osrm mld
-        ./src/benchmarks/packedvector-bench
-        ./src/benchmarks/rtree-bench ../test/data/monaco.osrm.ramIndex ../test/data/monaco.osrm.fileIndex ../test/data/monaco.osrm.nbg_nodes
-        popd

    - name: Use Node 18
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 18
    - name: Run Node package tests on Node 18
@@ -546,7 +572,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node 20
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: 20
    - name: Run Node package tests on Node 20
@@ -556,7 +582,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node latest
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
      with:
        node-version: latest
    - name: Run Node package tests on Node-latest
@@ -566,7 +592,7 @@ jobs:
        npm run nodejs-tests

    - name: Upload test logs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: failure()
      with:
        name: logs
@@ -582,7 +608,7 @@ jobs:
    # # Uploading report to CodeCov
    # - name: Upload code coverage
    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   uses: codecov/codecov-action@v1
+    #   uses: codecov/codecov-action@v4
    #   with:
    #     files: coverage.info
    #     name: codecov-osrm-backend
@@ -604,9 +630,138 @@ jobs:
        omitNameDuringUpdate: true
        replacesArtifacts: true
        token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Show CCache statistics
+      run: |
+        ccache -p
+        ccache -s
+
+  benchmarks:
+    if: github.event_name == 'pull_request'
+    needs: [format-taginfo-docs]
+    runs-on: ubuntu-22.04
+    env:
+      CCOMPILER: clang-13
+      CXXCOMPILER: clang++-13
+      CC: clang-13
+      CXX: clang++-13
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      PR_NUMBER: ${{ github.event.pull_request.number }}
+      GITHUB_REPOSITORY: ${{ github.repository }}
+      RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
+    steps: 
+      - name: Enable data.osm.pbf cache
+        if: ${{ ! env.RUN_BIG_BENCHMARK }}        
+        uses: actions/cache@v4
+        with:
+          path: ~/data.osm.pbf
+          key: v1-data-osm-pbf
+          restore-keys: |
+            v1-data-osm-pbf
+      - name: Enable compiler cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.ccache
+          key: v1-ccache-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-ccache-benchmarks-
+      - name: Enable Conan cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.conan
+          key: v1-conan-benchmarks-${{ github.sha }}
+          restore-keys: |
+            v1-conan-benchmarks-
+      - name: Checkout PR Branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          path: pr
+      - name: Install dependencies
+        run: | 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          sudo apt-get update -y && sudo apt-get install ccache
+      - name: Prepare data
+        run: |
+          if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
+              rm -rf ~/data.osm.pbf
+              wget http://download.geofabrik.de/europe/poland-latest.osm.pbf -O ~/data.osm.pbf --quiet
+              gunzip -c ./pr/test/data/poland_gps_traces.csv.gz > ~/gps_traces.csv
+          else
+              if [ ! -f "~/data.osm.pbf" ]; then
+                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf --quiet
+              else
+                echo "Using cached data.osm.pbf"
+              fi
+              gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
+          fi
+      - name: Prepare environment
+        run: |
+          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+          mkdir -p $HOME/.ccache
+          ccache --zero-stats
+          ccache --max-size=256M
+      - name: Checkout Base Branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.base.ref }}
+          path: base
+      - name: Build Base Branch
+        run: |
+          mkdir base/build
+          cd base/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc)
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
+      - name: Build PR Branch
+        run: |
+          mkdir -p pr/build
+          cd pr/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc) 
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
+      # we run benchmarks in tmpfs to avoid impact of disk IO
+      - name: Create folder for tmpfs 
+        run: mkdir -p /opt/benchmarks
+      - name: Run PR Benchmarks 
+        run: |
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          cp -rf pr/build /opt/benchmarks/build
+          mkdir -p /opt/benchmarks/test
+          cp -rf pr/test/data /opt/benchmarks/test/data
+          cp -rf pr/profiles /opt/benchmarks/profiles
+
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
+      - name: Run Base Benchmarks
+        run: |
+          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
+          cp -rf base/build /opt/benchmarks/build
+          mkdir -p /opt/benchmarks/test
+          cp -rf base/test/data /opt/benchmarks/test/data
+          cp -rf base/profiles /opt/benchmarks/profiles
+
+          # TODO: remove it when base branch will have this file at needed location
+          if [ ! -f /opt/benchmarks/test/data/portugal_to_korea.json ]; then
+            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
+          fi
+          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
+          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount /opt/benchmarks
+      - name: Post Benchmark Results
+        run: |
+          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
+      - name: Show CCache statistics
+        run: |
+          ccache -p
+          ccache -s

  ci-complete:
    runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image, windows-release-node]
+    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
    steps:
    - run: echo "CI complete"
+
@@ -0,0 +1,24 @@
+name: 'Close stale issues'
+on:
+  schedule:
+    - cron: '30 1 * * *' # every day at 1:30am
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/stale@v9
+        with:
+          stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
+          stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
+          days-before-issue-stale: 180 # 6 months
+          days-before-issue-close: 30 # 1 month
+          days-before-pr-stale: 180 # 6 months
+          days-before-pr-close: -1 # never close PRs
+          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
+
+  
+
@@ -1,12 +1,17 @@
 # Unreleased
  - Changes from 5.27.1
    - Features
+      - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
      - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
      - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
      - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
      - ADDED: Add support for opposite approach request parameter. [#6842](https://github.com/Project-OSRM/osrm-backend/pull/6842)
      - ADDED: Add support for accessing edge flags in `process_segment` [#6658](https://github.com/Project-OSRM/osrm-backend/pull/6658)
    - Build:
+      - CHANGED: Upgrade clang-format to version 15. [#6919](https://github.com/Project-OSRM/osrm-backend/pull/6919)
+      - CHANGED: Use Debian Bookworm as base Docker image [#6904](https://github.com/Project-OSRM/osrm-backend/pull/6904)
+      - CHANGED: Upgrade CI actions to latest versions [#6893](https://github.com/Project-OSRM/osrm-backend/pull/6893)
+      - CHANGED:  Remove outdated warnings #6894 [#6894](https://github.com/Project-OSRM/osrm-backend/pull/6894)
      - ADDED: Add CI job which builds OSRM with gcc 12. [#6455](https://github.com/Project-OSRM/osrm-backend/pull/6455)
      - CHANGED: Upgrade to clang-tidy 15. [#6439](https://github.com/Project-OSRM/osrm-backend/pull/6439)
      - CHANGED: Update actions/cache to v3. [#6420](https://github.com/Project-OSRM/osrm-backend/pull/6420)
@@ -19,6 +24,31 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
+      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
+      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
+      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
+      - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
+      - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
+      - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)
+      - CHANGED: Apply micro-optimisation for Match API. [#6945](https://github.com/Project-OSRM/osrm-backend/pull/6945)
+      - CHANGED: Apply micro-optimisation for Nearest API. [#6944](https://github.com/Project-OSRM/osrm-backend/pull/6944)
+      - CHANGED: Avoid copy of intersection in totalTurnAngle. [#6938](https://github.com/Project-OSRM/osrm-backend/pull/6938)
+      - CHANGED: Use std::unordered_map::emplace instead of operator[] when producing JSONs. [#6936](https://github.com/Project-OSRM/osrm-backend/pull/6936)
+      - CHANGED: Avoid copy of vectors in MakeRoute function. [#6939](https://github.com/Project-OSRM/osrm-backend/pull/6939)
+      - FIXED: Fix bugprone-unused-return-value clang-tidy warning. [#6934](https://github.com/Project-OSRM/osrm-backend/pull/6934)
+      - FIXED: Fix performance-noexcept-move-constructor clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6933)
+      - FIXED: Fix performance-noexcept-swap clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6931)
+      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
+      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
+      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
+      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
+      - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
+      - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
+      - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)
+      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
+      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
+      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
+      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
      - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@@ -48,7 +78,9 @@
      - FIXED: Remove force-loop checks for routes with u-turns [#6858](https://github.com/Project-OSRM/osrm-backend/pull/6858)
      - FIXED: Correctly check runtime search conditions for forcing routing steps [#6866](https://github.com/Project-OSRM/osrm-backend/pull/6866)
    - Map Matching:
+      - CHANGED: Optimise path distance calculation in MLD map matching even more. [#6884](https://github.com/Project-OSRM/osrm-backend/pull/6884)
      - CHANGED: Optimise path distance calculation in MLD map matching. [#6876](https://github.com/Project-OSRM/osrm-backend/pull/6876)
+      - CHANGED: Optimise R-tree queries in the case of map matching. [#6881](https://github.com/Project-OSRM/osrm-backend/pull/6876)
    - Debug tiles:
      - FIXED: Ensure speed layer features have unique ids. [#6726](https://github.com/Project-OSRM/osrm-backend/pull/6726)

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)

-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)

@@ -120,10 +120,9 @@ endif()

 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2-3.3.0/include)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)

-set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
+set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)

 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@@ -267,7 +266,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
  add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
  add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
  add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
-  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
  add_dependency_defines(-D_WIN32_WINNT=0x0501)
  add_dependency_defines(-DXML_STATIC)
  find_library(ws2_32_LIBRARY_PATH ws2_32)
@@ -301,6 +299,10 @@ include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
 set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
 include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})

+set(ANKERL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/unordered_dense/include")
+include_directories(SYSTEM ${ANKERL_INCLUDE_DIR})
+
+
 set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "Disable the build of Flatbuffers tests and samples.")
 set(FLATBUFFERS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers")
 set(FLATBUFFERS_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers/include")
@@ -332,20 +334,12 @@ if(ENABLE_CONAN)

  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.3.0@#507ec17cbd51a84167e143b20d170eea")
+  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
+  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
+  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")

  set(CONAN_SYSTEM_INCLUDES ON)

-  # TODO:
-  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol
-  # with exit code = -1073741515, which means that program cannot load required DLL.
-  if (MSVC)
-    set(TBB_SHARED False)
-  else()
-    set(TBB_SHARED True)
-  endif()

  set(CONAN_ARGS
    REQUIRES
@@ -358,9 +352,7 @@ if(ENABLE_CONAN)
    GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
    KEEP_RPATHS
    NO_OUTPUT_DIRS
-    OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
-            onetbb:shared=${TBB_SHARED}
-            boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
+    OPTIONS boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
    BUILD missing
  )

@@ -389,14 +381,10 @@ if(ENABLE_CONAN)
  set(Boost_USE_STATIC_LIBS ON)
  find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
-  set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
-  set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
-  set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
-  set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")


@@ -469,7 +457,6 @@ add_dependency_includes(${ZLIB_INCLUDE_DIRS})

 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
-add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)

 # Workaround for https://github.com/boostorg/phoenix/issues/111
 add_dependency_defines(-DBOOST_PHOENIX_STL_TUPLE_H_)
@@ -479,11 +466,8 @@ include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})

 set(BOOST_BASE_LIBRARIES
   ${Boost_DATE_TIME_LIBRARY}
-   ${Boost_CHRONO_LIBRARY}
-   ${Boost_FILESYSTEM_LIBRARY}
   ${Boost_IOSTREAMS_LIBRARY}
-   ${Boost_THREAD_LIBRARY}
-   ${Boost_SYSTEM_LIBRARY})
+   ${Boost_THREAD_LIBRARY})

 set(BOOST_ENGINE_LIBRARIES
  ${Boost_ZLIB_LIBRARY}
@@ -502,7 +486,6 @@ endif()

 set(EXTRACTOR_LIBRARIES
    ${BZIP2_LIBRARIES}
-    ${Boost_REGEX_LIBRARY}
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${EXPAT_LIBRARIES}
@@ -607,7 +590,6 @@ if (BUILD_ROUTED)
  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 endif()

-file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
 file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
@@ -627,7 +609,6 @@ install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
 install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
-install(FILES ${VariantGlob} DESTINATION include/mapbox)
 install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
@@ -15,7 +15,7 @@ The following services are available via HTTP API, C++ library interface and Nod

 To quickly try OSRM use our [demo server](http://map.project-osrm.org) which comes with both the backend and a frontend on top.

-For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [this guide about mapping for navigation](https://www.mapbox.com/mapping/mapping-for-navigation/).
+For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [the OSM wiki on routing](https://wiki.openstreetmap.org/wiki/Routing) or [this guide about mapping for navigation](https://web.archive.org/web/20221206013651/https://labs.mapbox.com/mapping/mapping-for-navigation/).

 Related [Project-OSRM](https://github.com/Project-OSRM) repositories:
 - [osrm-frontend](https://github.com/Project-OSRM/osrm-frontend) - User-facing frontend with map. The demo server runs this on top of the backend
@@ -55,7 +55,7 @@ function(_get_msvc_ide_version result)
        set(${result} 15 PARENT_SCOPE)
    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
        set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1950)
        set(${result} 17 PARENT_SCOPE)
    else()
        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
@@ -50,9 +50,7 @@ add_warning(all)
 add_warning(extra)
 add_warning(pedantic)
 add_warning(error) # treat all warnings as errors
-if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    add_warning(strict-overflow=2)
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    add_warning(strict-overflow=1)
 endif()
 add_warning(suggest-override)
@@ -79,15 +77,10 @@ add_warning(sizeof-array-argument)
 add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
-no_warning(c++17-extensions)
-# TODO: these warnings are not enabled by default, but we consider them as useful and good to enable in the future
-no_warning(implicit-int-conversion)
-no_warning(implicit-float-conversion)
-no_warning(unused-member-function)
-no_warning(old-style-cast)
-no_warning(non-virtual-dtor)
-no_warning(float-conversion)
-no_warning(sign-conversion)
-no_warning(shorten-64-to-32)
-no_warning(padded)
-no_warning(missing-noreturn)
+# these warnings are not enabled by default
+# no_warning(name-of-warning)
+no_warning(deprecated-comma-subscript)
+no_warning(comma-subscript)
+no_warning(ambiguous-reversed-operator)
+no_warning(restrict)
+no_warning(free-nonheap-object)
@@ -1,67 +0,0 @@
-FROM debian:bullseye-slim as builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-RUN mkdir -p /src  && mkdir -p /opt
-
-RUN apt-get update && \
-    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
-    libzip-dev libboost1.74-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    ldconfig /usr/local/lib && \
-    git clone --branch v2021.3.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
-    cd oneTBB && \
-    mkdir build && \
-    cd build && \
-    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
-    cmake --build . && \
-    cmake --install .
-
-COPY . /src
-WORKDIR /src
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bullseye-slim as runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends libboost-program-options1.74.0 libboost-regex1.74.0 \
-        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
-        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
-        expat liblua5.4-0 && \
-    rm -rf /var/lib/apt/lists/* && \
-# add /usr/local/lib to ldconfig to allow loading libraries from there
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
@@ -0,0 +1 @@
+Dockerfile-debian
@@ -0,0 +1,62 @@
+FROM alpine:3.20.0 as alpine-mimalloc
+
+RUN apk add --no-cache mimalloc
+
+ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
+ENV MIMALLOC_LARGE_OS_PAGES=1
+
+
+FROM alpine-mimalloc as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apk add --no-cache \
+    cmake make git clang libbz2 libxml2 \
+    boost-dev boost-program_options boost-filesystem boost-iostreams boost-thread \
+    lua5.4-dev onetbb-dev expat-dev
+
+COPY . /src
+WORKDIR /src
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
+# Only the content below ends up in the image, this helps remove /src from the image (which is large)
+FROM alpine-mimalloc as runstage
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apk add --no-cache \
+    boost-program_options boost-date_time boost-iostreams boost-thread \
+    expat lua5.4 onetbb && \
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
@@ -0,0 +1,67 @@
+FROM debian:bookworm-slim as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
+    libzip-dev libboost1.81-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    ldconfig /usr/local/lib && \
+    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    cd oneTBB && \
+    mkdir build && \
+    cd build && \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
+    cmake --build . && \
+    cmake --install .
+
+COPY . /src
+WORKDIR /src
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
+# Only the content below ends up in the image, this helps remove /src from the image (which is large)
+FROM debian:bookworm-slim as runstage
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        libboost-program-options1.81.0 libboost-date-time1.81.0 libboost-iostreams1.81.0 libboost-thread1.81.0 \
+        expat liblua5.4-0 && \
+    rm -rf /var/lib/apt/lists/* && \
+# add /usr/local/lib to ldconfig to allow loading libraries from there
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
@@ -6,4 +6,8 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
+
+DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
+
+$DOCKER_BUILD Dockerfile ..
+$DOCKER_BUILD Dockerfile-alpine ..
@@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**

 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
               Make sure you prepared the dataset with the correct toolchain.
    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
               This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
@@ -57,15 +57,15 @@ int main(int argc, const char *argv[])
    // Execute routing request, this does the heavy lifting
    const auto status = osrm.Route(params, result);

-    auto &json_result = result.get<json::Object>();
+    auto &json_result = std::get<json::Object>(result);
    if (status == Status::Ok)
    {
-        auto &routes = json_result.values["routes"].get<json::Array>();
+        auto &routes = std::get<json::Array>(json_result.values["routes"]);

        // Let's just use the first route
-        auto &route = routes.values.at(0).get<json::Object>();
-        const auto distance = route.values["distance"].get<json::Number>().value;
-        const auto duration = route.values["duration"].get<json::Number>().value;
+        auto &route = std::get<json::Object>(routes.values.at(0));
+        const auto distance = std::get<json::Number>(route.values["distance"]).value;
+        const auto duration = std::get<json::Number>(route.values["duration"]).value;

        // Warn users if extract does not contain the default coordinates from above
        if (distance == 0 || duration == 0)
@@ -80,8 +80,8 @@ int main(int argc, const char *argv[])
    }
    else if (status == Status::Error)
    {
-        const auto code = json_result.values["code"].get<json::String>().value;
-        const auto message = json_result.values["message"].get<json::String>().value;
+        const auto code = std::get<json::String>(json_result.values["code"]).value;
+        const auto message = std::get<json::String>(json_result.values["message"]).value;

        std::cout << "Code: " << code << "\n";
        std::cout << "Message: " << code << "\n";
@@ -42,7 +42,7 @@ module.exports = function () {
        this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;

        this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;

@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <string>

 namespace osrm::contractor
@@ -47,7 +46,7 @@ struct ContractorConfig final : storage::IOConfig
    }

    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
@@ -1,128 +0,0 @@
-#ifndef ITERATOR_BASED_CRC32_H
-#define ITERATOR_BASED_CRC32_H
-
-#if defined(__x86_64__) && !defined(__MINGW64__)
-#include <cpuid.h>
-#endif
-
-#include <boost/crc.hpp> // for boost::crc_32_type
-
-#include <iterator>
-
-namespace osrm::contractor
-{
-
-class IteratorbasedCRC32
-{
-  public:
-    bool UsingHardware() const { return use_hardware_implementation; }
-
-    IteratorbasedCRC32() : crc(0) { use_hardware_implementation = DetectHardwareSupport(); }
-
-    template <class Iterator> unsigned operator()(Iterator iter, const Iterator end)
-    {
-        unsigned crc = 0;
-        while (iter != end)
-        {
-            using value_type = typename std::iterator_traits<Iterator>::value_type;
-            const char *data = reinterpret_cast<const char *>(&(*iter));
-
-            if (use_hardware_implementation)
-            {
-                crc = ComputeInHardware(data, sizeof(value_type));
-            }
-            else
-            {
-                crc = ComputeInSoftware(data, sizeof(value_type));
-            }
-            ++iter;
-        }
-        return crc;
-    }
-
-  private:
-    bool DetectHardwareSupport() const
-    {
-        static const int sse42_bit = 0x00100000;
-        const unsigned ecx = cpuid();
-        const bool sse42_found = (ecx & sse42_bit) != 0;
-        return sse42_found;
-    }
-
-    unsigned ComputeInSoftware(const char *str, unsigned len)
-    {
-        crc_processor.process_bytes(str, len);
-        return crc_processor.checksum();
-    }
-
-    // adapted from http://byteworm.com/2010/10/13/crc32/
-    unsigned ComputeInHardware(const char *str, unsigned len)
-    {
-#if defined(__x86_64__)
-        unsigned q = len / sizeof(unsigned);
-        unsigned r = len % sizeof(unsigned);
-        unsigned *p = (unsigned *)str;
-
-        // crc=0;
-        while (q--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*p));
-            ++p;
-        }
-
-        str = reinterpret_cast<char *>(p);
-        while (r--)
-        {
-            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                                 : "=S"(crc)
-                                 : "0"(crc), "c"(*str));
-            ++str;
-        }
-#else
-        (void)str;
-        (void)len;
-#endif
-        return crc;
-    }
-
-    inline unsigned cpuid() const
-    {
-        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
-        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
-        __get_cpuid(1, &eax, &ebx, &ecx, &edx);
-        return ecx;
-    }
-
-#if defined(__MINGW64__) || defined(_MSC_VER) || !defined(__x86_64__)
-    inline void __get_cpuid(int /*param*/,
-                            unsigned * /*eax*/,
-                            unsigned * /*ebx*/,
-                            unsigned *ecx,
-                            unsigned * /*edx*/) const
-    {
-        *ecx = 0;
-    }
-#endif
-
-    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> crc_processor;
-    unsigned crc;
-    bool use_hardware_implementation;
-};
-
-struct RangebasedCRC32
-{
-    template <typename Iteratable> unsigned operator()(const Iteratable &iterable)
-    {
-        return crc32(std::begin(iterable), std::end(iterable));
-    }
-
-    bool UsingHardware() const { return crc32.UsingHardware(); }
-
-  private:
-    IteratorbasedCRC32 crc32;
-};
-} // namespace osrm::contractor
-
-#endif /* ITERATOR_BASED_CRC32_H */
@@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                      std::uint32_t &connectivity_checksum)
 {
@@ -30,7 +30,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
                       const std::uint32_t connectivity_checksum)
 {
@@ -1,9 +1,8 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>

 #include "storage/io_config.hpp"
@@ -27,7 +26,7 @@ struct CustomizationConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
@@ -9,7 +9,7 @@

 #include "storage/shared_memory_ownership.hpp"

-#include <boost/filesystem/path.hpp>
+#include <filesystem>

 namespace osrm::customizer
 {
@@ -14,7 +14,7 @@ namespace osrm::customizer::files

 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const boost::filesystem::path &path,
+inline void readCellMetrics(const std::filesystem::path &path,
                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -44,7 +44,7 @@ inline void readCellMetrics(const boost::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const boost::filesystem::path &path,
+writeCellMetrics(const std::filesystem::path &path,
                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@@ -72,7 +72,7 @@ writeCellMetrics(const boost::filesystem::path &path,

 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@@ -88,7 +88,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
@@ -2,7 +2,7 @@
 #define ENGINE_API_BASE_RESULT_HPP

 #include <flatbuffers/flatbuffers.h>
-#include <mapbox/variant.hpp>
+#include <variant>

 #include <string>

@@ -10,8 +10,7 @@

 namespace osrm::engine::api
 {
-using ResultT =
-    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api

 #endif
@@ -41,7 +41,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
    return intersection.lanes.lanes_in_turn > 0;
 }

-util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);
+util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);

 /**
 * Ensures that a bearing value is a whole number, and clamped to the range 0-359
@@ -79,7 +79,7 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
        coordinates.values.push_back(location);
        coordinates.values.push_back(location);
    }
-    geojson.values["coordinates"] = std::move(coordinates);
+    geojson.values["coordinates"] = util::json::Value{std::move(coordinates)};

    return geojson;
 }
@@ -30,14 +30,14 @@ class MatchAPI final : public RouteAPI
                      osrm::engine::api::ResultT &response) const
    {
        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(sub_matchings, sub_routes, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(sub_matchings, sub_routes, json_result);
        }
    }
@@ -77,19 +77,19 @@ class MatchAPI final : public RouteAPI
                                   sub_routes[index].unpacked_path_segments,
                                   sub_routes[index].source_traversed_in_reverse,
                                   sub_routes[index].target_traversed_in_reverse);
-            route.values["confidence"] = sub_matchings[index].confidence;
-            routes.values.push_back(std::move(route));
+            route.values.emplace("confidence", sub_matchings[index].confidence);
+            routes.values.emplace_back(std::move(route));
        }
        if (!parameters.skip_waypoints)
        {
-            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
+            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
        }
-        response.values["matchings"] = std::move(routes);
-        response.values["code"] = "Ok";
+        response.values.emplace("matchings", std::move(routes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -132,13 +132,13 @@ class MatchAPI final : public RouteAPI

            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            const auto &phantom =
@@ -165,7 +165,7 @@ class MatchAPI final : public RouteAPI
            {
                waypoint->add_waypoint_index(matching_index.point_index);
            }
-            waypoints.push_back(waypoint->Finish());
+            waypoints.emplace_back(waypoint->Finish());
        }

        return fb_result.CreateVector(waypoints);
@@ -186,23 +186,23 @@ class MatchAPI final : public RouteAPI
        {
            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.values.push_back(util::json::Null());
+                waypoints.values.emplace_back(util::json::Null());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.values.push_back(util::json::Null());
+                waypoints.values.emplace_back(util::json::Null());
                continue;
            }
            const auto &phantom =
                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
            auto waypoint = BaseAPI::MakeWaypoint({phantom});
-            waypoint.values["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values["waypoint_index"] = matching_index.point_index;
-            waypoint.values["alternatives_count"] =
-                sub_matchings[matching_index.sub_matching_index]
-                    .alternatives_count[matching_index.point_index];
+            waypoint.values.emplace("matchings_index", matching_index.sub_matching_index);
+            waypoint.values.emplace("waypoint_index", matching_index.point_index);
+            waypoint.values.emplace("alternatives_count",
+                                    sub_matchings[matching_index.sub_matching_index]
+                                        .alternatives_count[matching_index.point_index]);
            // waypoint indices need to be adjusted if route legs were collapsed
            // waypoint parameter assumes there is only one match object
            if (!parameters.waypoints.empty())
@@ -217,7 +217,7 @@ class MatchAPI final : public RouteAPI
                    waypoint.values["waypoint_index"] = util::json::Null();
                }
            }
-            waypoints.values.push_back(std::move(waypoint));
+            waypoints.values.emplace_back(std::move(waypoint));
        }

        return waypoints;
@@ -29,14 +29,14 @@ class NearestAPI final : public BaseAPI
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(phantom_nodes, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(phantom_nodes, json_result);
        }
    }
@@ -100,23 +100,23 @@ class NearestAPI final : public BaseAPI
                               auto waypoint = MakeWaypoint({phantom_node});

                               util::json::Array nodes;
+                               nodes.values.reserve(2);

                               auto node_values = MakeNodes(phantom_node);

-                               nodes.values.push_back(node_values.first);
-                               nodes.values.push_back(node_values.second);
-                               waypoint.values["nodes"] = std::move(nodes);
-
+                               nodes.values.emplace_back(node_values.first);
+                               nodes.values.emplace_back(node_values.second);
+                               waypoint.values.emplace("nodes", std::move(nodes));
                               return waypoint;
                           });
-            response.values["waypoints"] = std::move(waypoints);
+            response.values.emplace("waypoints", std::move(waypoints));
        }

-        response.values["code"] = "Ok";
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -50,14 +50,14 @@ class RouteAPI : public BaseAPI
    {
        BOOST_ASSERT(!raw_routes.routes.empty());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(raw_routes, waypoint_candidates, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(raw_routes, waypoint_candidates, json_result);
        }
    }
@@ -110,14 +110,14 @@ class RouteAPI : public BaseAPI

        if (!parameters.skip_waypoints)
        {
-            response.values["waypoints"] = BaseAPI::MakeWaypoints(waypoint_candidates);
+            response.values.emplace("waypoints", BaseAPI::MakeWaypoints(waypoint_candidates));
        }
-        response.values["routes"] = std::move(jsRoutes);
-        response.values["code"] = "Ok";
+        response.values.emplace("routes", std::move(jsRoutes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -158,8 +158,8 @@ class RouteAPI : public BaseAPI
    }

    template <typename ForwardIter>
-    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+    std::variant<flatbuffers::Offset<flatbuffers::String>,
+                 flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
    MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
    {
        if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
@@ -340,8 +340,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);

        // Fill legs
@@ -408,8 +408,8 @@ class RouteAPI : public BaseAPI

        // Fill geometry
        auto overview = MakeOverview(leg_geometries);
-        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+        std::variant<flatbuffers::Offset<flatbuffers::String>,
+                     flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
            geometry;
        if (overview)
        {
@@ -426,8 +426,7 @@ class RouteAPI : public BaseAPI
        routeObject.add_legs(legs_vector);
        if (overview)
        {
-            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
-                                        geometry);
+            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
        }

        return routeObject.Finish();
@@ -443,23 +442,22 @@ class RouteAPI : public BaseAPI
        if (requested_annotations & RouteParameters::AnnotationsType::Speed)
        {
            double prev_speed = 0;
-            speed =
-                GetAnnotations<float>(fb_result,
-                                      leg_geometry,
-                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                      {
-                                          if (anno.duration < std::numeric_limits<float>::min())
-                                          {
-                                              return prev_speed;
-                                          }
-                                          else
-                                          {
-                                              auto speed =
-                                                  round(anno.distance / anno.duration * 10.) / 10.;
-                                              prev_speed = speed;
-                                              return util::json::clamp_float(speed);
-                                          }
-                                      });
+            speed = GetAnnotations<float>(
+                fb_result,
+                leg_geometry,
+                [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                {
+                    if (anno.duration < std::numeric_limits<float>::min())
+                    {
+                        return prev_speed;
+                    }
+                    else
+                    {
+                        auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                        prev_speed = speed;
+                        return util::json::clamp_float(speed);
+                    }
+                });
        }

        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
@@ -645,7 +643,7 @@ class RouteAPI : public BaseAPI
        stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
        stepBuilder.add_intersections(intersections_vector);
        stepBuilder.add_maneuver(maneuver_buffer);
-        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
+        std::visit(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
        return stepBuilder.Finish();
    };

@@ -718,8 +716,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;

        auto route = guidance::assembleRoute(legs);
        boost::optional<util::json::Value> json_overview =
@@ -786,49 +784,57 @@ class RouteAPI : public BaseAPI
                if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                {
                    double prev_speed = 0;
-                    annotation.values["speed"] = GetAnnotations(
-                        leg_geometry,
-                        [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                        {
-                            if (anno.duration < std::numeric_limits<double>::min())
-                            {
-                                return prev_speed;
-                            }
-                            else
-                            {
-                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                                prev_speed = speed;
-                                return util::json::clamp_float(speed);
-                            }
-                        });
+                    annotation.values.emplace(
+                        "speed",
+                        GetAnnotations(leg_geometry,
+                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                                       {
+                                           if (anno.duration < std::numeric_limits<double>::min())
+                                           {
+                                               return prev_speed;
+                                           }
+                                           else
+                                           {
+                                               auto speed =
+                                                   std::round(anno.distance / anno.duration * 10.) /
+                                                   10.;
+                                               prev_speed = speed;
+                                               return util::json::clamp_float(speed);
+                                           }
+                                       }));
                }

                if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                {
-                    annotation.values["duration"] =
+                    annotation.values.emplace(
+                        "duration",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; });
+                                       { return anno.duration; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                {
-                    annotation.values["distance"] =
+                    annotation.values.emplace(
+                        "distance",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; });
+                                       { return anno.distance; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                {
-                    annotation.values["weight"] = GetAnnotations(
-                        leg_geometry,
-                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
+                    annotation.values.emplace(
+                        "weight",
+                        GetAnnotations(leg_geometry,
+                                       [](const guidance::LegGeometry::Annotation &anno)
+                                       { return anno.weight; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                {
-                    annotation.values["datasources"] =
+                    annotation.values.emplace(
+                        "datasources",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; });
+                                       { return anno.datasource; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                {
@@ -839,7 +845,7 @@ class RouteAPI : public BaseAPI
                        nodes.values.push_back(
                            static_cast<std::uint64_t>(facade.GetOSMNodeIDOfNode(node_id)));
                    }
-                    annotation.values["nodes"] = std::move(nodes);
+                    annotation.values.emplace("nodes", std::move(nodes));
                }
                // Add any supporting metadata, if needed
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
@@ -855,8 +861,8 @@ class RouteAPI : public BaseAPI
                            break;
                        datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                    }
-                    metadata.values["datasource_names"] = datasource_names;
-                    annotation.values["metadata"] = metadata;
+                    metadata.values.emplace("datasource_names", datasource_names);
+                    annotation.values.emplace("metadata", metadata);
                }

                annotations.push_back(std::move(annotation));
@@ -50,14 +50,14 @@ class TableAPI final : public BaseAPI
                 const std::vector<TableCellRef> &fallback_speed_cells,
                 osrm::engine::api::ResultT &response) const
    {
-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(tables, candidates, fallback_speed_cells, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(tables, candidates, fallback_speed_cells, json_result);
        }
    }
@@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["sources"] = MakeWaypoints(candidates);
+                response.values.emplace("sources", MakeWaypoints(candidates));
            }
            number_of_sources = candidates.size();
        }
@@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
+                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
            }
        }

@@ -195,7 +195,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["destinations"] = MakeWaypoints(candidates);
+                response.values.emplace("destinations", MakeWaypoints(candidates));
            }
            number_of_destinations = candidates.size();
        }
@@ -203,34 +203,37 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values["destinations"] =
-                    MakeWaypoints(candidates, parameters.destinations);
+                response.values.emplace("destinations",
+                                        MakeWaypoints(candidates, parameters.destinations));
            }
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
        {
-            response.values["durations"] =
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
+            response.values.emplace(
+                "durations",
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
        {
-            response.values["distances"] =
-                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
+            response.values.emplace(
+                "distances",
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations));
        }

        if (parameters.fallback_speed != from_alias<double>(INVALID_FALLBACK_SPEED) &&
            parameters.fallback_speed > 0)
        {
-            response.values["fallback_speed_cells"] = MakeEstimatesTable(fallback_speed_cells);
+            response.values.emplace("fallback_speed_cells",
+                                    MakeEstimatesTable(fallback_speed_cells));
        }

-        response.values["code"] = "Ok";
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -377,7 +380,8 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(
                                   util::json::Number(from_alias<double>(duration) / 10.));
                           });
-            json_table.values.push_back(std::move(json_row));
+
+            json_table.values.push_back(util::json::Value{json_row});
        }
        return json_table;
    }
@@ -406,7 +410,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(util::json::Number(
                                   std::round(from_alias<double>(distance) * 10) / 10.));
                           });
-            json_table.values.push_back(std::move(json_row));
+            json_table.values.push_back(util::json::Value{json_row});
        }
        return json_table;
    }
@@ -415,15 +419,18 @@ class TableAPI final : public BaseAPI
    MakeEstimatesTable(const std::vector<TableCellRef> &fallback_speed_cells) const
    {
        util::json::Array json_table;
-        std::for_each(fallback_speed_cells.begin(),
-                      fallback_speed_cells.end(),
-                      [&](const auto &cell)
-                      {
-                          util::json::Array row;
-                          row.values.push_back(util::json::Number(cell.row));
-                          row.values.push_back(util::json::Number(cell.column));
-                          json_table.values.push_back(std::move(row));
-                      });
+        std::for_each(
+            fallback_speed_cells.begin(),
+            fallback_speed_cells.end(),
+            [&](const auto &cell)
+            {
+                util::json::Array row;
+                util::json::Value jCellRow{util::json::Number(static_cast<double>(cell.row))};
+                util::json::Value jCellColumn{util::json::Number(static_cast<double>(cell.column))};
+                row.values.push_back(jCellRow);
+                row.values.push_back(jCellColumn);
+                json_table.values.push_back(util::json::Value{row});
+            });
        return json_table;
    }

@@ -27,14 +27,14 @@ class TripAPI final : public RouteAPI
    {
        BOOST_ASSERT(sub_trips.size() == sub_routes.size());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
+        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
+            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
            MakeResponse(sub_trips, sub_routes, candidates, fb_result);
        }
        else
        {
-            auto &json_result = response.get<util::json::Object>();
+            auto &json_result = std::get<util::json::Object>(response);
            MakeResponse(sub_trips, sub_routes, candidates, json_result);
        }
    }
@@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
        }
        if (!parameters.skip_waypoints)
        {
-            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
+            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
        }
-        response.values["trips"] = std::move(routes);
-        response.values["code"] = "Ok";
+        response.values.emplace("trips", std::move(routes));
+        response.values.emplace("code", "Ok");
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values["data_version"] = data_timestamp;
+            response.values.emplace("data_version", data_timestamp);
        }
    }

@@ -151,8 +151,8 @@ class TripAPI final : public RouteAPI
            BOOST_ASSERT(!trip_index.NotUsed());

            auto waypoint = BaseAPI::MakeWaypoint(candidates[input_index]);
-            waypoint.values["trips_index"] = trip_index.sub_trip_index;
-            waypoint.values["waypoint_index"] = trip_index.point_index;
+            waypoint.values.emplace("trips_index", trip_index.sub_trip_index);
+            waypoint.values.emplace("waypoint_index", trip_index.point_index);
            waypoints.values.push_back(std::move(waypoint));
        }

@@ -47,24 +47,29 @@ namespace engine
 // Encodes a chunk of memory to Base64.
 inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 {
-    std::vector<unsigned char> bytes{first, first + size};
-    BOOST_ASSERT(!bytes.empty());
+    BOOST_ASSERT(size > 0);

-    std::size_t bytes_to_pad{0};
+    std::string encoded;
+    encoded.reserve(((size + 2) / 3) * 4);

-    while (bytes.size() % 3 != 0)
+    auto padding = (3 - size % 3) % 3;
+
+    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
+
+    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
+         ++itr)
    {
-        bytes_to_pad += 1;
-        bytes.push_back(0);
+        encoded.push_back(*itr);
    }

-    BOOST_ASSERT(bytes_to_pad == 0 || bytes_to_pad == 1 || bytes_to_pad == 2);
-    BOOST_ASSERT_MSG(0 == bytes.size() % 3, "base64 input data size is not a multiple of 3");
+    for (size_t index = 0; index < padding; ++index)
+    {
+        encoded.push_back('=');
+    }

-    std::string encoded{detail::Base64FromBinary{bytes.data()},
-                        detail::Base64FromBinary{bytes.data() + (bytes.size() - bytes_to_pad)}};
+    BOOST_ASSERT(encoded.size() == (size + 2) / 3 * 4);

-    return encoded.append(bytes_to_pad, '=');
+    return encoded;
 }

 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types
@@ -55,7 +55,7 @@ template <> class AlgorithmDataFacade<CH>

    virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
                                    const NodeID edge_based_node_to,
-                                    const std::function<bool(EdgeData)> filter) const = 0;
+                                    const std::function<bool(const EdgeData &)> &filter) const = 0;
 };

 template <> class AlgorithmDataFacade<MLD>
@@ -130,9 +130,10 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
            edge_based_node_from, edge_based_node_to, result);
    }

-    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
-                            const NodeID edge_based_node_to,
-                            std::function<bool(EdgeData)> filter) const override final
+    EdgeID
+    FindSmallestEdge(const NodeID edge_based_node_from,
+                     const NodeID edge_based_node_to,
+                     const std::function<bool(const EdgeData &)> &filter) const override final
    {
        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
    }
@@ -176,7 +177,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

    SharedRTree m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    boost::filesystem::path file_index_path;
+    std::filesystem::path file_index_path;

    std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;

@@ -375,7 +376,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, boost::none, max_distance, bearing, use_all_edges);
+            input_coordinate, approach, max_distance, bearing, use_all_edges);
    }

    std::vector<PhantomNodeWithDistance>
@@ -31,8 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <set>
 #include <string>

@@ -54,14 +53,10 @@ namespace osrm::engine
 *
 * In addition, shared memory can be used for datasets loaded with osrm-datastore.
 *
- * You can chose between three algorithms:
+ * You can chose between two algorithms:
 *  - Algorithm::CH
 *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
 * now.
- *  - Algorithm::CoreCH
- *      Deprecated, to be removed in v6.0
- *      Contraction Hierachies with partial contraction for faster pre-processing but slower
- * queries.
 *  - Algorithm::MLD
 *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
 *
@@ -74,7 +69,6 @@ struct EngineConfig final
    enum class Algorithm
    {
        CH,
-        CoreCH, // Deprecated, will be removed in v6.0
        MLD
    };

@@ -88,7 +82,7 @@ struct EngineConfig final
    boost::optional<double> default_radius = -1.0;
    int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
    bool use_shared_memory = true;
-    boost::filesystem::path memory_file;
+    std::filesystem::path memory_file;
    bool use_mmap = true;
    Algorithm algorithm = Algorithm::CH;
    std::vector<storage::FeatureDataset> disable_feature_dataset;
@@ -12,6 +12,8 @@

 #include "osrm/coordinate.hpp"

+#include <boost/optional.hpp>
+
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@@ -47,12 +49,42 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        return rtree.SearchInBox(bbox);
    }

+    std::vector<PhantomNodeWithDistance>
+    NearestPhantomNodes(const util::Coordinate input_coordinate,
+                        const Approach approach,
+                        const double max_distance,
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::optional<bool> use_all_edges) const
+    {
+        auto results = rtree.SearchInRange(
+            input_coordinate,
+            max_distance,
+            [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges, max_distance](
+                const CandidateSegment &segment)
+            {
+                auto invalidDistance =
+                    CheckSegmentDistance(input_coordinate, segment, max_distance);
+                if (invalidDistance)
+                {
+                    return std::make_pair(false, false);
+                }
+                auto valid = CheckSegmentExclude(segment) &&
+                             CheckApproach(input_coordinate, segment, approach) &&
+                             (use_all_edges ? HasValidEdge(segment, *use_all_edges)
+                                            : HasValidEdge(segment)) &&
+                             (bearing_with_range ? CheckSegmentBearing(segment, *bearing_with_range)
+                                                 : std::make_pair(true, true));
+                return valid;
+            });
+        return MakePhantomNodes(input_coordinate, results);
+    }
+
    // Returns max_results nearest PhantomNodes that are valid within the provided parameters.
    // Does not filter by small/big component!
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
-                        const boost::optional<size_t> max_results,
+                        const size_t max_results,
                        const boost::optional<double> max_distance,
                        const boost::optional<Bearing> bearing_with_range,
                        const boost::optional<bool> use_all_edges) const
@@ -70,10 +102,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                 : std::make_pair(true, true));
                return valid;
            },
-            [this, &max_distance, &max_results, input_coordinate](const std::size_t num_results,
-                                                                  const CandidateSegment &segment)
+            [this, &max_distance, max_results, input_coordinate](const std::size_t num_results,
+                                                                 const CandidateSegment &segment)
            {
-                return (max_results && num_results >= *max_results) ||
+                return (num_results >= max_results) ||
                       (max_distance && max_distance != -1.0 &&
                        CheckSegmentDistance(input_coordinate, segment, *max_distance));
            });
@@ -1,7 +1,6 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP

 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"

 #include <type_traits>
 #include <vector>
@@ -12,16 +11,15 @@ namespace osrm::engine::guidance
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);

 // Multiple possible reasons can result in unnecessary/confusing instructions
 // A prime example would be a segregated intersection. Turning around at this
 // intersection would result in two instructions to turn left.
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep>
+collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);

 // A combined turn is a set of two instructions that actually form a single turn, as far as we
 // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots
@@ -3,7 +3,6 @@

 #include "guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"
 #include "util/bearing.hpp"
 #include "util/guidance/name_announcements.hpp"

@@ -166,8 +165,7 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 }

 // do this after invalidating any steps to compress the step array again
-OSRM_ATTR_WARN_UNUSED
-inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
+[[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
 {
    // finally clean up the post-processed instructions.
    // Remove all invalid instructions from the set of instructions.
@@ -204,8 +202,8 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
    if (entry_step.geometry_begin > exit_step.geometry_begin)
        return totalTurnAngle(exit_step, entry_step);

-    const auto exit_intersection = exit_step.intersections.front();
-    const auto entry_intersection = entry_step.intersections.front();
+    const auto &exit_intersection = exit_step.intersections.front();
+    const auto &entry_intersection = entry_step.intersections.front();
    if ((exit_intersection.out >= exit_intersection.bearings.size()) ||
        (entry_intersection.in >= entry_intersection.bearings.size()))
        return entry_intersection.bearings[entry_intersection.out];
@@ -1,10 +1,9 @@
 #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_

-#include <vector>
-
 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"
+
+#include <vector>

 namespace osrm::engine::guidance
 {
@@ -14,9 +13,9 @@ namespace osrm::engine::guidance
 // we anticipate lane changes emitting only matching lanes early on.
 // the second parameter describes the duration that we feel two segments need to be apart to count
 // as separate maneuvers.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
-                                            const double min_distance_needed_for_lane_change = 200);
+[[nodiscard]] std::vector<RouteStep>
+anticipateLaneChange(std::vector<RouteStep> steps,
+                     const double min_distance_needed_for_lane_change = 200);

 } // namespace osrm::engine::guidance

@@ -5,7 +5,6 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
-#include "util/attributes.hpp"

 #include <vector>

@@ -13,8 +12,7 @@ namespace osrm::engine::guidance
 {

 // passed as none-reference to modify in-place and move out again
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);

 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.
@@ -24,23 +22,21 @@ std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
 void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);

 // assign relative locations to depart/arrive instructions
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
-                                               const LegGeometry &geometry,
-                                               const PhantomNode &source_node,
-                                               const PhantomNode &target_node);
+[[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
+                                                             const LegGeometry &geometry,
+                                                             const PhantomNode &source_node,
+                                                             const PhantomNode &target_node);

 // collapse suppressed instructions remaining into intersections array
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);

 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.
 // If required, we can get both in sync again using this function.
 // Move in LegGeometry for modification in place.
-OSRM_ATTR_WARN_UNUSED
-LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
+[[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
+                                         const std::vector<RouteStep> &steps);

 /**
 * Apply maneuver override relations to the selected route.
@@ -2,7 +2,6 @@
 #define OSRM_ENGINE_GUIDANCE_VERBOSITY_REDUCTION_HPP_

 #include "engine/guidance/route_step.hpp"
-#include "util/attributes.hpp"

 #include <vector>

@@ -13,8 +12,7 @@ namespace osrm::engine::guidance
 // to announce them. All these that are not collapsed into a single turn (think segregated
 // intersection) have to be checked for the length they are active in. If they are active for a
 // short distance only, we don't announce them
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
+[[nodiscard]] std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);

 } // namespace osrm::engine::guidance

@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>

-#include <boost/math/constants/constants.hpp>
+#include <numbers>

 namespace osrm::engine::map_matching
 {
@@ -21,10 +21,8 @@ struct NormalDistribution
    // FIXME implement log-probability version since it's faster
    double Density(const double val) const
    {
-        using namespace boost::math::constants;
-
        const double x = val - mean;
-        return 1.0 / (std::sqrt(two_pi<double>()) * standard_deviation) *
+        return 1.0 / (std::sqrt(2 * std::numbers::pi) * standard_deviation) *
               std::exp(-x * x / (standard_deviation * standard_deviation));
    }

@@ -4,7 +4,7 @@
 #include "util/integer_range.hpp"

 #include <boost/assert.hpp>
-#include <boost/math/constants/constants.hpp>
+#include <numbers>

 #include <cmath>

@@ -14,7 +14,7 @@
 namespace osrm::engine::map_matching
 {

-static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
+static const double log_2_pi = std::log(2. * std::numbers::pi);
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();
@@ -2,7 +2,7 @@
 #define ENGINE_MAP_MATCHING_CONFIDENCE_HPP

 #include "engine/map_matching/bayes_classifier.hpp"
-
+#include <boost/assert.hpp>
 #include <cmath>

 namespace osrm::engine::map_matching
@@ -95,7 +95,7 @@ class BasePlugin
                 const std::string &message,
                 osrm::engine::api::ResultT &result) const
    {
-        mapbox::util::apply_visitor(ErrorRenderer(code, message), result);
+        std::visit(ErrorRenderer(code, message), result);
        return Status::Error;
    }

@@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-std::string encode(std::vector<int> &numbers);
+void encode(int number_to_encode, std::string &output);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                     std::string::const_iterator last);
 } // namespace detail
@@ -30,27 +30,24 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
        return {};
    }

-    std::vector<int> delta_numbers;
-    BOOST_ASSERT(size > 0);
-    delta_numbers.reserve((size - 1) * 2);
+    std::string output;
+    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
+    output.reserve(size * 4);
+
    int current_lat = 0;
    int current_lon = 0;
-    std::for_each(
-        begin,
-        end,
-        [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-            const util::Coordinate loc)
-        {
-            const int lat_diff =
-                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
-            const int lon_diff =
-                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
-            delta_numbers.emplace_back(lat_diff);
-            delta_numbers.emplace_back(lon_diff);
-            current_lat += lat_diff;
-            current_lon += lon_diff;
-        });
-    return detail::encode(delta_numbers);
+    for (auto it = begin; it != end; ++it)
+    {
+        const int lat_diff =
+            std::round(static_cast<int>(it->lat) * coordinate_to_polyline) - current_lat;
+        const int lon_diff =
+            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
+        detail::encode(lat_diff, output);
+        detail::encode(lon_diff, output);
+        current_lat += lat_diff;
+        current_lon += lon_diff;
+    }
+    return output;
 }

 // Decodes geometry from polyline format
@@ -122,7 +122,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
        const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
        if (new_weight < upper_bound)
        {
-            if (shouldForceStep(force_step_nodes, heapNode, reverseHeapNode.get()) ||
+            if (shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) ||
                // in this case we are looking at a bi-directional way where the source
                // and target phantom are on the same edge based node
                new_weight < EdgeWeight{0})
@@ -11,6 +11,7 @@
 #include <boost/assert.hpp>

 #include <algorithm>
+#include <boost/core/ignore_unused.hpp>
 #include <iterator>
 #include <limits>
 #include <tuple>
@@ -269,10 +270,29 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
    return packed_path;
 }

-template <bool DIRECTION, typename Algorithm, typename... Args>
+template <typename Heap>
+void insertOrUpdate(Heap &heap,
+                    const NodeID node,
+                    const EdgeWeight weight,
+                    const typename Heap::DataType &data)
+{
+    const auto heapNode = heap.GetHeapNodeIfWasInserted(node);
+    if (!heapNode)
+    {
+        heap.Insert(node, weight, data);
+    }
+    else if (weight < heapNode->weight)
+    {
+        heapNode->data = data;
+        heapNode->weight = weight;
+        heap.DecreaseKey(*heapNode);
+    }
+}
+
+template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
+                        Heap &forward_heap,
+                        const typename Heap::HeapNode &heapNode,
                        const Args &...args)
 {
    const auto &partition = facade.GetMultiLevelPartition();
@@ -281,14 +301,31 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,

    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);

+    static constexpr auto IS_MAP_MATCHING =
+        std::is_same_v<typename SearchEngineData<mld::Algorithm>::MapMatchingQueryHeap, Heap>;
+
    if (level >= 1 && !heapNode.data.from_clique_arc)
    {
-        if (DIRECTION == FORWARD_DIRECTION)
+        if constexpr (DIRECTION == FORWARD_DIRECTION)
        {
            // Shortcuts in forward direction
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto destination = cell.GetDestinationNodes().begin();
+            auto distance = [&cell, node = heapNode.node ]() -> auto
+            {
+                if constexpr (IS_MAP_MATCHING)
+                {
+
+                    return cell.GetOutDistance(node).begin();
+                }
+                else
+                {
+                    boost::ignore_unused(cell, node);
+                    return 0;
+                }
+            }
+            ();
            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
            {
                BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
@@ -298,19 +335,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if (!toHeapNode)
+
+                    if constexpr (IS_MAP_MATCHING)
                    {
-                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
+                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        insertOrUpdate(
+                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else if (to_weight < toHeapNode->weight)
+                    else
                    {
-                        toHeapNode->data = {heapNode.node, true};
-                        toHeapNode->weight = to_weight;
-                        forward_heap.DecreaseKey(*toHeapNode);
+                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
                    }
                }
                ++destination;
+                if constexpr (IS_MAP_MATCHING)
+                {
+                    ++distance;
+                }
            }
        }
        else
@@ -319,6 +360,20 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto source = cell.GetSourceNodes().begin();
+            auto distance = [&cell, node = heapNode.node ]() -> auto
+            {
+                if constexpr (IS_MAP_MATCHING)
+                {
+
+                    return cell.GetInDistance(node).begin();
+                }
+                else
+                {
+                    boost::ignore_unused(cell, node);
+                    return 0;
+                }
+            }
+            ();
            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
            {
                BOOST_ASSERT(source != cell.GetSourceNodes().end());
@@ -328,19 +383,22 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if (!toHeapNode)
+                    if constexpr (IS_MAP_MATCHING)
                    {
-                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
+                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        insertOrUpdate(
+                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else if (to_weight < toHeapNode->weight)
+                    else
                    {
-                        toHeapNode->data = {heapNode.node, true};
-                        toHeapNode->weight = to_weight;
-                        forward_heap.DecreaseKey(*toHeapNode);
+                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
                    }
                }
                ++source;
+                if constexpr (IS_MAP_MATCHING)
+                {
+                    ++distance;
+                }
            }
        }
    }
@@ -367,26 +425,28 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                const EdgeWeight to_weight =
                    heapNode.weight + node_weight + alias_cast<EdgeWeight>(turn_penalty);

-                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                if (!toHeapNode)
+                if constexpr (IS_MAP_MATCHING)
                {
-                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
+                    const auto node_distance =
+                        facade.GetNodeDistance(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
+
+                    const EdgeDistance to_distance = heapNode.data.distance + node_distance;
+                    insertOrUpdate(
+                        forward_heap, to, to_weight, {heapNode.node, false, to_distance});
                }
-                else if (to_weight < toHeapNode->weight)
+                else
                {
-                    toHeapNode->data = {heapNode.node, false};
-                    toHeapNode->weight = to_weight;
-                    forward_heap.DecreaseKey(*toHeapNode);
+                    insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, false});
                }
            }
        }
    }
 }

-template <bool DIRECTION, typename Algorithm, typename... Args>
+template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void routingStep(const DataFacade<Algorithm> &facade,
-                 typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                 Heap &forward_heap,
+                 Heap &reverse_heap,
                 NodeID &middle_node,
                 EdgeWeight &path_upper_bound,
                 const std::vector<NodeID> &force_step_nodes,
@@ -408,7 +468,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
        auto reverse_weight = reverseHeapNode->weight;
        auto path_weight = weight + reverse_weight;

-        if (!shouldForceStep(force_step_nodes, heapNode, reverseHeapNode.get()) &&
+        if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
            (path_weight >= EdgeWeight{0}) && (path_weight < path_upper_bound))
        {
            middle_node = heapNode.node;
@@ -429,22 +489,19 @@ using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
 using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;

-template <typename Algorithm, typename... Args>
-UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-                    const DataFacade<Algorithm> &facade,
-                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                    const std::vector<NodeID> &force_step_nodes,
-                    EdgeWeight weight_upper_bound,
-                    const Args &...args)
+template <typename Algorithm, typename Heap, typename... Args>
+std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
+                                                       Heap &forward_heap,
+                                                       Heap &reverse_heap,
+                                                       const std::vector<NodeID> &force_step_nodes,
+                                                       EdgeWeight weight_upper_bound,
+                                                       const Args &...args)
 {
    if (forward_heap.Empty() || reverse_heap.Empty())
    {
-        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
+        return {};
    }

-    const auto &partition = facade.GetMultiLevelPartition();
-
    BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
    BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);

@@ -474,10 +531,33 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,

    // No path found for both target nodes?
    if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
+    {
+        return {};
+    }
+
+    return {{middle, weight}};
+}
+
+template <typename Algorithm, typename... Args>
+UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
+                    const DataFacade<Algorithm> &facade,
+                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                    const std::vector<NodeID> &force_step_nodes,
+                    EdgeWeight weight_upper_bound,
+                    const Args &...args)
+{
+    auto searchResult = runSearch(
+        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
+    if (!searchResult)
    {
        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
    }

+    auto [middle, weight] = *searchResult;
+
+    const auto &partition = facade.GetMultiLevelPartition();
+
    // Get packed path as edges {from node ID, to node ID, from_clique_arc}
    auto packed_path = retrievePackedPathFromHeap(forward_heap, reverse_heap, middle);

@@ -536,6 +616,31 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }

+template <typename Algorithm, typename... Args>
+EdgeDistance
+searchDistance(SearchEngineData<Algorithm> &,
+               const DataFacade<Algorithm> &facade,
+               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
+               const std::vector<NodeID> &force_step_nodes,
+               EdgeWeight weight_upper_bound,
+               const Args &...args)
+{
+
+    auto searchResult = runSearch(
+        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
+    if (!searchResult)
+    {
+        return INVALID_EDGE_DISTANCE;
+    }
+
+    auto [middle, _] = *searchResult;
+
+    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
+
+    return distance;
+}
+
 // Alias to be compatible with the CH-based search
 template <typename Algorithm, typename PhantomEndpointT>
 inline void search(SearchEngineData<Algorithm> &engine_working_data,
@@ -593,8 +698,8 @@ void unpackPath(const FacadeT &facade,
 template <typename Algorithm>
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                          const DataFacade<Algorithm> &facade,
-                          typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                          typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
                          const PhantomNode &source_phantom,
                          const PhantomNode &target_phantom,
                          EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
@@ -602,48 +707,49 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
    forward_heap.Clear();
    reverse_heap.Clear();

-    const PhantomEndpoints endpoints{source_phantom, target_phantom};
-    insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
+    if (source_phantom.IsValidForwardSource())
+    {
+        forward_heap.Insert(source_phantom.forward_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
+                            {source_phantom.forward_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetForwardDistance()});
+    }

-    auto [weight, unpacked_nodes, unpacked_edges] = search(
+    if (source_phantom.IsValidReverseSource())
+    {
+        forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
+                            {source_phantom.reverse_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetReverseDistance()});
+    }
+
+    if (target_phantom.IsValidForwardTarget())
+    {
+        reverse_heap.Insert(
+            target_phantom.forward_segment_id.id,
+            target_phantom.GetForwardWeightPlusOffset(),
+            {target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
+    }
+
+    if (target_phantom.IsValidReverseTarget())
+    {
+        reverse_heap.Insert(
+            target_phantom.reverse_segment_id.id,
+            target_phantom.GetReverseWeightPlusOffset(),
+            {target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
+    }
+
+    const PhantomEndpoints endpoints{source_phantom, target_phantom};
+
+    auto distance = searchDistance(
        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);

-    if (weight == INVALID_EDGE_WEIGHT)
+    if (distance == INVALID_EDGE_DISTANCE)
    {
        return std::numeric_limits<double>::max();
    }
-
-    BOOST_ASSERT(unpacked_nodes.size() >= 1);
-
-    EdgeDistance distance = {0.0};
-
-    if (source_phantom.forward_segment_id.id == unpacked_nodes.front())
-    {
-        BOOST_ASSERT(source_phantom.forward_segment_id.enabled);
-        distance = EdgeDistance{0} - source_phantom.GetForwardDistance();
-    }
-    else if (source_phantom.reverse_segment_id.id == unpacked_nodes.front())
-    {
-        BOOST_ASSERT(source_phantom.reverse_segment_id.enabled);
-        distance = EdgeDistance{0} - source_phantom.GetReverseDistance();
-    }
-
-    for (size_t index = 0; index < unpacked_nodes.size() - 1; ++index)
-    {
-        distance += facade.GetNodeDistance(unpacked_nodes[index]);
-    }
-
-    if (target_phantom.forward_segment_id.id == unpacked_nodes.back())
-    {
-        BOOST_ASSERT(target_phantom.forward_segment_id.enabled);
-        distance += target_phantom.GetForwardDistance();
-    }
-    else if (target_phantom.reverse_segment_id.id == unpacked_nodes.back())
-    {
-        BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
-        distance += target_phantom.GetReverseDistance();
-    }
-
    return from_alias<double>(distance);
 }

@@ -12,7 +12,6 @@ namespace osrm::engine

 // Algorithm-dependent heaps
 // - CH algorithms use CH heaps
-// - CoreCH algorithms use CH
 // - MLD algorithms use MLD heaps

 template <typename Algorithm> struct SearchEngineData
@@ -47,6 +46,7 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                util::UnorderedMapStorage<NodeID, int>>;

    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
+
    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;

    static SearchEngineHeapPtr forward_heap_1;
@@ -56,6 +56,10 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
    static SearchEngineHeapPtr forward_heap_3;
    static SearchEngineHeapPtr reverse_heap_3;
    static ManyToManyHeapPtr many_to_many_heap;
+    static SearchEngineHeapPtr map_matching_forward_heap_1;
+    static SearchEngineHeapPtr map_matching_reverse_heap_1;
+
+    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes);

    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);

@@ -74,6 +78,19 @@ struct MultiLayerDijkstraHeapData
    MultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
 };

+struct MapMatchingMultiLayerDijkstraHeapData
+{
+    NodeID parent;
+    bool from_clique_arc;
+    EdgeDistance distance = {0};
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p) : parent(p), from_clique_arc(false) {}
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
+    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from, EdgeDistance d)
+        : parent(p), from_clique_arc(from), distance(d)
+    {
+    }
+};
+
 struct ManyToManyMultiLayerDijkstraHeapData : MultiLayerDijkstraHeapData
 {
    EdgeDuration duration;
@@ -104,16 +121,27 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                EdgeWeight,
                                                ManyToManyMultiLayerDijkstraHeapData,
                                                util::TwoLevelStorage<NodeID, int>>;
+    using MapMatchingQueryHeap = util::QueryHeap<NodeID,
+                                                 NodeID,
+                                                 EdgeWeight,
+                                                 MapMatchingMultiLayerDijkstraHeapData,
+                                                 util::TwoLevelStorage<NodeID, int>>;

    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
+    using MapMatchingHeapPtr = boost::thread_specific_ptr<MapMatchingQueryHeap>;

    static SearchEngineHeapPtr forward_heap_1;
    static SearchEngineHeapPtr reverse_heap_1;
+    static MapMatchingHeapPtr map_matching_forward_heap_1;
+    static MapMatchingHeapPtr map_matching_reverse_heap_1;
+
    static ManyToManyHeapPtr many_to_many_heap;

    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes,
                                                  unsigned number_of_boundary_nodes);
+    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes,
+                                                        unsigned number_of_boundary_nodes);

    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                       unsigned number_of_boundary_nodes);
@@ -3,11 +3,9 @@

 #include "extractor/class_data.hpp"
 #include "extractor/turn_lane_types.hpp"
+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
-#include <boost/optional/optional_fwd.hpp>
-
 #include <string>
 #include <unordered_map>

@@ -18,25 +16,6 @@ class Way;
 class Relation;
 } // namespace osmium

-namespace std
-{
-template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
-{
-    std::size_t operator()(
-        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
-        const noexcept
-    {
-        std::size_t seed = 0;
-        boost::hash_combine(seed, std::get<0>(mk));
-        boost::hash_combine(seed, std::get<1>(mk));
-        boost::hash_combine(seed, std::get<2>(mk));
-        boost::hash_combine(seed, std::get<3>(mk));
-        boost::hash_combine(seed, std::get<4>(mk));
-        return seed;
-    }
-};
-} // namespace std
-
 namespace osrm::extractor
 {

@@ -28,13 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
+#include "storage/io_config.hpp"

 #include <array>
+#include <filesystem>
 #include <string>

-#include "storage/io_config.hpp"
-
 namespace osrm::extractor
 {

@@ -71,14 +70,14 @@ struct ExtractorConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }

-    boost::filesystem::path input_path;
-    boost::filesystem::path profile_path;
-    std::vector<boost::filesystem::path> location_dependent_data_paths;
+    std::filesystem::path input_path;
+    std::filesystem::path profile_path;
+    std::vector<std::filesystem::path> location_dependent_data_paths;
    std::string data_version;

    unsigned requested_num_threads = 0;
@@ -23,9 +23,9 @@ namespace osrm::extractor::files

 // writes the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void writeIntersections(const boost::filesystem::path &path,
-                               const IntersectionBearingsT &intersection_bearings,
-                               const EntryClassVectorT &entry_classes)
+void writeIntersections(const std::filesystem::path &path,
+                        const IntersectionBearingsT &intersection_bearings,
+                        const EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -39,9 +39,9 @@ inline void writeIntersections(const boost::filesystem::path &path,

 // read the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-inline void readIntersections(const boost::filesystem::path &path,
-                              IntersectionBearingsT &intersection_bearings,
-                              EntryClassVectorT &entry_classes)
+void readIntersections(const std::filesystem::path &path,
+                       IntersectionBearingsT &intersection_bearings,
+                       EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@@ -54,8 +54,7 @@ inline void readIntersections(const boost::filesystem::path &path,
 }

 // reads .osrm.properties
-inline void readProfileProperties(const boost::filesystem::path &path,
-                                  ProfileProperties &properties)
+inline void readProfileProperties(const std::filesystem::path &path, ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -64,7 +63,7 @@ inline void readProfileProperties(const boost::filesystem::path &path,
 }

 // writes .osrm.properties
-inline void writeProfileProperties(const boost::filesystem::path &path,
+inline void writeProfileProperties(const std::filesystem::path &path,
                                   const ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -74,7 +73,7 @@ inline void writeProfileProperties(const boost::filesystem::path &path,
 }

 template <typename EdgeBasedEdgeVector>
-void writeEdgeBasedGraph(const boost::filesystem::path &path,
+void writeEdgeBasedGraph(const std::filesystem::path &path,
                         EdgeID const number_of_edge_based_nodes,
                         const EdgeBasedEdgeVector &edge_based_edge_list,
                         const std::uint32_t connectivity_checksum)
@@ -92,7 +91,7 @@ void writeEdgeBasedGraph(const boost::filesystem::path &path,

 // reads .osrm.ebg file
 template <typename EdgeBasedEdgeVector>
-void readEdgeBasedGraph(const boost::filesystem::path &path,
+void readEdgeBasedGraph(const std::filesystem::path &path,
                        EdgeID &number_of_edge_based_nodes,
                        EdgeBasedEdgeVector &edge_based_edge_list,
                        std::uint32_t &connectivity_checksum)
@@ -108,9 +107,9 @@ void readEdgeBasedGraph(const boost::filesystem::path &path,

 // reads .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void readNodes(const boost::filesystem::path &path,
-                      CoordinatesT &coordinates,
-                      PackedOSMIDsT &osm_node_ids)
+void readNodes(const std::filesystem::path &path,
+               CoordinatesT &coordinates,
+               PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -124,7 +123,7 @@ inline void readNodes(const boost::filesystem::path &path,

 // reads only coordinates from .osrm.nbg_nodes
 template <typename CoordinatesT>
-inline void readNodeCoordinates(const boost::filesystem::path &path, CoordinatesT &coordinates)
+void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordinates)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");

@@ -136,9 +135,9 @@ inline void readNodeCoordinates(const boost::filesystem::path &path, Coordinates

 // writes .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-inline void writeNodes(const boost::filesystem::path &path,
-                       const CoordinatesT &coordinates,
-                       const PackedOSMIDsT &osm_node_ids)
+void writeNodes(const std::filesystem::path &path,
+                const CoordinatesT &coordinates,
+                const PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@@ -151,7 +150,7 @@ inline void writeNodes(const boost::filesystem::path &path,
 }

 // reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -160,8 +159,7 @@ inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGT
 }

 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const boost::filesystem::path &path,
-                            const std::vector<NBGToEBG> &mapping)
+inline void writeNBGMapping(const std::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -170,7 +168,7 @@ inline void writeNBGMapping(const boost::filesystem::path &path,
 }

 // reads .osrm.datasource_names
-inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void readDatasources(const std::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -179,7 +177,7 @@ inline void readDatasources(const boost::filesystem::path &path, Datasources &so
 }

 // writes .osrm.datasource_names
-inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
+inline void writeDatasources(const std::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -189,7 +187,7 @@ inline void writeDatasources(const boost::filesystem::path &path, Datasources &s

 // reads .osrm.geometry
 template <typename SegmentDataT>
-inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
+void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -202,7 +200,7 @@ inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &s

 // writes .osrm.geometry
 template <typename SegmentDataT>
-inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
+void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@@ -215,7 +213,7 @@ inline void writeSegmentData(const boost::filesystem::path &path, const SegmentD

 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
+inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -229,7 +227,7 @@ inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_da

 // writes .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
+inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@@ -243,7 +241,7 @@ inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &

 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void readTurnLaneDescriptions(const std::filesystem::path &path,
                                     OffsetsT &turn_offsets,
                                     MaskT &turn_masks)
 {
@@ -260,7 +258,7 @@ inline void readTurnLaneDescriptions(const boost::filesystem::path &path,

 // writes .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
+inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
                                      const OffsetsT &turn_offsets,
                                      const MaskT &turn_masks)
 {
@@ -277,7 +275,7 @@ inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,

 // reads .osrm.tld
 template <typename TurnLaneDataT>
-inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
+inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &turn_lane_data)
 {
    static_assert(
        std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
@@ -291,7 +289,7 @@ inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT

 // writes .osrm.tld
 template <typename TurnLaneDataT>
-inline void writeTurnLaneData(const boost::filesystem::path &path,
+inline void writeTurnLaneData(const std::filesystem::path &path,
                              const TurnLaneDataT &turn_lane_data)
 {
    static_assert(
@@ -306,7 +304,7 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,

 // reads .osrm.timestamp
 template <typename TimestampDataT>
-inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
+inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -316,7 +314,7 @@ inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &t

 // writes .osrm.timestamp
 template <typename TimestampDataT>
-inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
+inline void writeTimestamp(const std::filesystem::path &path, const TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -326,7 +324,7 @@ inline void writeTimestamp(const boost::filesystem::path &path, const TimestampD

 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const boost::filesystem::path &path,
+inline void readManeuverOverrides(const std::filesystem::path &path,
                                  StorageManeuverOverrideT &maneuver_overrides,
                                  NodeSequencesT &node_sequences)
 {
@@ -340,7 +338,7 @@ inline void readManeuverOverrides(const boost::filesystem::path &path,
 }

 // writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const boost::filesystem::path &path,
+inline void writeManeuverOverrides(const std::filesystem::path &path,
                                   const std::vector<StorageManeuverOverride> &maneuver_overrides,
                                   const std::vector<NodeID> &node_sequences)
 {
@@ -355,7 +353,7 @@ inline void writeManeuverOverrides(const boost::filesystem::path &path,

 // writes .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
+inline void writeTurnWeightPenalty(const std::filesystem::path &path,
                                   const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -366,7 +364,7 @@ inline void writeTurnWeightPenalty(const boost::filesystem::path &path,

 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -376,7 +374,7 @@ inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenal

 // writes .osrm.turn_duration_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
+inline void writeTurnDurationPenalty(const std::filesystem::path &path,
                                     const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -387,7 +385,7 @@ inline void writeTurnDurationPenalty(const boost::filesystem::path &path,

 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -397,7 +395,7 @@ inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPen

 // writes .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
                                    const TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -408,7 +406,7 @@ inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,

 // read .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
+inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
                                   TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -419,7 +417,7 @@ inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,

 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void writeConditionalRestrictions(const boost::filesystem::path &path,
+inline void writeConditionalRestrictions(const std::filesystem::path &path,
                                         const ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@@ -430,7 +428,7 @@ inline void writeConditionalRestrictions(const boost::filesystem::path &path,

 // read .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void readConditionalRestrictions(const boost::filesystem::path &path,
+inline void readConditionalRestrictions(const std::filesystem::path &path,
                                        ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@@ -441,7 +439,7 @@ inline void readConditionalRestrictions(const boost::filesystem::path &path,

 // reads .osrm file which is a temporary file of osrm-extract
 template <typename PackedOSMIDsT>
-void readRawNBGraph(const boost::filesystem::path &path,
+void readRawNBGraph(const std::filesystem::path &path,
                    std::vector<util::Coordinate> &coordinates,
                    PackedOSMIDsT &osm_node_ids,
                    std::vector<extractor::NodeBasedEdge> &edge_list)
@@ -466,8 +464,7 @@ void readRawNBGraph(const boost::filesystem::path &path,
    storage::serialization::read(reader, "/extractor/edges", edge_list);
 }

-template <typename NameTableT>
-void readNames(const boost::filesystem::path &path, NameTableT &table)
+template <typename NameTableT> void readNames(const std::filesystem::path &path, NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -476,7 +473,7 @@ void readNames(const boost::filesystem::path &path, NameTableT &table)
 }

 template <typename NameTableT>
-void writeNames(const boost::filesystem::path &path, const NameTableT &table)
+void writeNames(const std::filesystem::path &path, const NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -485,7 +482,7 @@ void writeNames(const boost::filesystem::path &path, const NameTableT &table)
 }

 template <typename NodeWeightsVectorT>
-void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVectorT &weights)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -494,8 +491,7 @@ void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVe
 }

 template <typename NodeDistancesVectorT>
-void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
-                                NodeDistancesVectorT &distances)
+void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistancesVectorT &distances)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -504,7 +500,7 @@ void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
-void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &path,
                                                 const NodeWeightsVectorT &weights,
                                                 const NodeDurationsVectorT &durations,
                                                 const NodeDistancesVectorT &distances)
@@ -518,7 +514,7 @@ void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                       NodeWeightsVectorT &weights,
                                       NodeDurationsVectorT &durations)
 {
@@ -530,7 +526,7 @@ void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }

 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
                                        const NodeWeightsVectorT &weights,
                                        const NodeDurationsVectorT &durations)
 {
@@ -542,7 +538,7 @@ void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
 }

 template <typename RTreeT>
-void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
+void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -550,7 +546,7 @@ void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
    util::serialization::write(writer, "/common/rtree", rtree);
 }

-template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path, RTreeT &rtree)
+template <typename RTreeT> void readRamIndex(const std::filesystem::path &path, RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -559,7 +555,7 @@ template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path
 }

 template <typename EdgeListT>
-void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const EdgeListT &edge_list)
+void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@@ -568,7 +564,7 @@ void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const Ed
 }

 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -7,8 +7,8 @@
 #include "util/typedefs.hpp"

 #include <boost/assert.hpp>
-#include <mapbox/variant.hpp>
 #include <utility>
+#include <variant>

 namespace osrm::extractor
 {
@@ -1,16 +1,15 @@
 #ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
 #define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_

-#include <utility>
-#include <vector>
-
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/query_node.hpp"

-#include "util/attributes.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"

+#include <utility>
+#include <vector>
+
 namespace osrm::extractor::intersection
 {

@@ -27,17 +26,16 @@ class CoordinateExtractor
     * Note: The segment between intersection and turn coordinate can be zero, if the OSM modelling
     * is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470
     */
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node,
-                                            const EdgeID turn_edge,
-                                            const bool traversed_in_reverse,
-                                            const NodeID to_node,
-                                            const std::uint8_t number_of_in_lanes) const;
+    [[nodiscard]] util::Coordinate
+    GetCoordinateAlongRoad(const NodeID intersection_node,
+                           const EdgeID turn_edge,
+                           const bool traversed_in_reverse,
+                           const NodeID to_node,
+                           const std::uint8_t number_of_in_lanes) const;

    // Given a set of precomputed coordinates, select the representative coordinate along the road
    // that best describes the turn
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate
+    [[nodiscard]] util::Coordinate
    ExtractRepresentativeCoordinate(const NodeID intersection_node,
                                    const EdgeID turn_edge,
                                    const bool traversed_in_reverse,
@@ -47,7 +45,7 @@ class CoordinateExtractor

    // instead of finding only a single coordinate, we can also list all coordinates along a
    // road.
-    OSRM_ATTR_WARN_UNUSED std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    GetCoordinatesAlongRoad(const NodeID intersection_node,
                            const EdgeID turn_edge,
                            const bool traversed_in_reverse,
@@ -55,20 +53,18 @@ class CoordinateExtractor

    // wrapper in case of normal forward edges (traversed_in_reverse = false, to_node =
    // node_based_graph.GetTarget(turn_edge)
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from,
-                                                                 const EdgeID turn_edge) const;
+    [[nodiscard]] std::vector<util::Coordinate>
+    GetForwardCoordinatesAlongRoad(const NodeID from, const EdgeID turn_edge) const;

    // a less precise way to compute coordinates along a route. Due to the heavy interaction of
    // graph traversal and turn instructions, we often don't care for high precision. We only want
    // to check for available connections in order, or find (with room for error) the straightmost
    // turn. This function will offer a bit more error potential but allow for much higher
    // performance
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
-                                              const EdgeID turn_edge,
-                                              const bool traversed_in_reverse,
-                                              const NodeID to_node) const;
+    [[nodiscard]] util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
+                                                            const EdgeID turn_edge,
+                                                            const bool traversed_in_reverse,
+                                                            const NodeID to_node) const;

    /* When extracting the coordinates, we first extract all coordinates. We don't care about most
     * of them, though.
@@ -90,22 +86,19 @@ class CoordinateExtractor
     * The optional length cache needs to store the accumulated distance up to the respective
     * coordinate index [0,d(0,1),...]
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates,
                            const double desired_length,
                            const std::vector<double> &length_cache = {}) const;

-    OSRM_ATTR_WARN_UNUSED
-    std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates,
-                                           const double limit) const;
+    [[nodiscard]] std::vector<double>
+    PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, const double limit) const;

    /* when looking at a set of coordinates, this function allows trimming the vector to a smaller,
     * only containing coordinates up to a given distance along the path. The last coordinate might
     * be interpolated
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates,
                                 const double desired_length) const;

@@ -130,10 +123,9 @@ class CoordinateExtractor
     *
     * for fixpoint `b`, vector_base `d` and vector_head `e`
     */
-    OSRM_ATTR_WARN_UNUSED
-    util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
-                                            const util::Coordinate vector_base,
-                                            const util::Coordinate vector_head) const;
+    [[nodiscard]] util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
+                                                          const util::Coordinate vector_base,
+                                                          const util::Coordinate vector_head) const;

    /* generate a uniform vector of coordinates in same range distances
     *
@@ -143,8 +135,7 @@ class CoordinateExtractor
     * Into:
     * x -- x -- x -- x -- x - x
     */
-    OSRM_ATTR_WARN_UNUSED
-    std::vector<util::Coordinate>
+    [[nodiscard]] std::vector<util::Coordinate>
    SampleCoordinates(const std::vector<util::Coordinate> &coordinates,
                      const double length,
                      const double rate) const;
@@ -11,8 +11,8 @@
 #include "util/typedefs.hpp"

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
 #include <cstdint>
+#include <optional>
 #include <utility>

 namespace osrm::extractor::intersection
@@ -42,10 +42,10 @@ class NodeBasedGraphWalker
     * selector not provinding any further edge to traverse)
     */
    template <class accumulator_type, class selector_type>
-    boost::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
-                                                            EdgeID following_edge_id,
-                                                            accumulator_type &accumulator,
-                                                            const selector_type &selector) const;
+    std::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
+                                                          EdgeID following_edge_id,
+                                                          accumulator_type &accumulator,
+                                                          const selector_type &selector) const;

  private:
    const util::NodeBasedDynamicGraph &node_based_graph;
@@ -111,11 +111,11 @@ struct SelectRoadByNameOnlyChoiceAndStraightness
     * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
     * form of obious turn to follow.
     */
-    boost::optional<EdgeID> operator()(const NodeID nid,
-                                       const EdgeID via_edge_id,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                       const EdgeBasedNodeDataContainer &node_data_container) const;
+    std::optional<EdgeID> operator()(const NodeID nid,
+                                     const EdgeID via_edge_id,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                     const EdgeBasedNodeDataContainer &node_data_container) const;

  private:
    const NameID desired_name_id;
@@ -138,11 +138,11 @@ struct SelectStraightmostRoadByNameAndOnlyChoice
     * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
     * form of obious turn to follow.
     */
-    boost::optional<EdgeID> operator()(const NodeID nid,
-                                       const EdgeID via_edge_id,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                       const EdgeBasedNodeDataContainer &node_data_container) const;
+    std::optional<EdgeID> operator()(const NodeID nid,
+                                     const EdgeID via_edge_id,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                     const EdgeBasedNodeDataContainer &node_data_container) const;

  private:
    const NameID desired_name_id;
@@ -187,7 +187,7 @@ struct IntersectionFinderAccumulator
 };

 template <class accumulator_type, class selector_type>
-boost::optional<std::pair<NodeID, EdgeID>>
+std::optional<std::pair<NodeID, EdgeID>>
 NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
                                   EdgeID current_edge_id,
                                   accumulator_type &accumulator,
@@ -254,19 +254,19 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,

 struct SkipTrafficSignalBarrierRoadSelector
 {
-    boost::optional<EdgeID> operator()(const NodeID,
-                                       const EdgeID,
-                                       const IntersectionView &intersection,
-                                       const util::NodeBasedDynamicGraph &,
-                                       const EdgeBasedNodeDataContainer &) const
+    std::optional<EdgeID> operator()(const NodeID,
+                                     const EdgeID,
+                                     const IntersectionView &intersection,
+                                     const util::NodeBasedDynamicGraph &,
+                                     const EdgeBasedNodeDataContainer &) const
    {
        if (intersection.isTrafficSignalOrBarrier())
        {
-            return boost::make_optional(intersection[1].eid);
+            return std::make_optional(intersection[1].eid);
        }
        else
        {
-            return boost::none;
+            return std::nullopt;
        }
    }
 };
@@ -1,13 +1,13 @@
 #ifndef OSRM_LOCATION_DEPENDENT_DATA_HPP
 #define OSRM_LOCATION_DEPENDENT_DATA_HPP

-#include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/index/rtree.hpp>

 #include <osmium/osm/way.hpp>

+#include <filesystem>
 #include <string>
 #include <unordered_map>

@@ -30,7 +30,7 @@ struct LocationDependentData
    using property_t = boost::variant<boost::blank, double, std::string, bool>;
    using properties_t = std::unordered_map<std::string, property_t>;

-    LocationDependentData(const std::vector<boost::filesystem::path> &file_paths);
+    LocationDependentData(const std::vector<std::filesystem::path> &file_paths);

    bool empty() const { return rtree.empty(); }

@@ -39,7 +39,7 @@ struct LocationDependentData
    property_t FindByKey(const std::vector<std::size_t> &property_indexes, const char *key) const;

  private:
-    void loadLocationDependentData(const boost::filesystem::path &file_path,
+    void loadLocationDependentData(const std::filesystem::path &file_path,
                                   std::vector<rtree_t::value_type> &bounding_boxes);

    rtree_t rtree;
@@ -8,10 +8,12 @@
 #include "turn_path.hpp"
 #include "util/integer_range.hpp"
 #include "util/log.hpp"
+#include "util/std_hash.hpp"
 #include "util/vector_view.hpp"
+
+#include <variant>
+
 #include <algorithm>
-#include <boost/functional/hash.hpp>
-#include <mapbox/variant.hpp>

 namespace osrm::extractor
 {
@@ -147,7 +149,6 @@ struct UnresolvedManeuverOverride
 namespace std
 {
 template <> struct hash<osrm::extractor::NodeBasedTurn>
-
 {
    using argument_type = osrm::extractor::NodeBasedTurn;
    using result_type = std::size_t;
@@ -155,9 +156,9 @@ template <> struct hash<osrm::extractor::NodeBasedTurn>
    {

        std::size_t seed = 0;
-        boost::hash_combine(seed, s.from);
-        boost::hash_combine(seed, s.via);
-        boost::hash_combine(seed, s.to);
+        hash_combine(seed, s.from);
+        hash_combine(seed, s.via);
+        hash_combine(seed, s.to);

        return seed;
    }
@@ -3,7 +3,7 @@

 #include "maneuver_override.hpp"

-#include <boost/optional.hpp>
+#include <optional>
 #include <string>
 #include <vector>

@@ -55,7 +55,7 @@ class ManeuverOverrideRelationParser
 {
  public:
    ManeuverOverrideRelationParser();
-    boost::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
+    std::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
 };
 } // namespace osrm::extractor

@@ -12,8 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -7,11 +7,11 @@

 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/optional.hpp>

 #include <algorithm>
 #include <array>
 #include <cstdint>
+#include <optional>

 namespace osrm::extractor
 {
@@ -80,7 +80,7 @@ struct ProfileProperties
    }

    // Check if this classes are excludable
-    boost::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
+    std::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
    {
        auto iter = std::find(excludable_classes.begin(), excludable_classes.end(), classes);
        if (iter != excludable_classes.end())
@@ -7,14 +7,13 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/foreach.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/qi_int.hpp>

 #include <storage/io.hpp>

+#include <filesystem>
 #include <iterator>
 #include <string>
 #include <unordered_map>
@@ -40,7 +39,7 @@ struct RasterDatum
 class RasterGrid
 {
  public:
-    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    RasterGrid(const std::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
    {
        xdim = _xdim;
        ydim = _ydim;
@@ -1,12 +1,10 @@
 #ifndef RESTRICTION_HPP
 #define RESTRICTION_HPP

+#include "turn_path.hpp"
 #include "util/coordinate.hpp"
 #include "util/opening_hours.hpp"
 #include "util/typedefs.hpp"
-
-#include "mapbox/variant.hpp"
-#include "turn_path.hpp"
 #include <limits>

 namespace osrm::extractor
@@ -70,7 +70,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment

    explicit Sol2ScriptingEnvironment(
        const std::string &file_name,
-        const std::vector<boost::filesystem::path> &location_dependent_data_paths);
+        const std::vector<std::filesystem::path> &location_dependent_data_paths);
    ~Sol2ScriptingEnvironment() override = default;

    const ProfileProperties &GetProfileProperties() override;
@@ -8,13 +8,12 @@
 #include "storage/shared_memory_ownership.hpp"
 #include "storage/tar_fwd.hpp"

-#include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/iterator_range.hpp>

-#include <unordered_map>
-
+#include <filesystem>
 #include <string>
+#include <unordered_map>
 #include <vector>

 namespace osrm::extractor
@@ -215,7 +215,6 @@ inline void read(storage::tar::FileReader &reader,
                 const std::string &name,
                 detail::NameTableImpl<Ownership> &name_table)
 {
-    std::string buffer;
    util::serialization::read(reader, name, name_table.indexed_data);
 }
 } // namespace osrm::extractor::serialization
@@ -1,10 +1,11 @@
 #ifndef OSRM_EXTRACTOR_TRAFFIC_SIGNALS_HPP
 #define OSRM_EXTRACTOR_TRAFFIC_SIGNALS_HPP

+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
 #include <unordered_set>
+#include <utility>

 namespace osrm::extractor
 {
@@ -12,23 +13,22 @@ namespace osrm::extractor
 struct TrafficSignals
 {
    std::unordered_set<NodeID> bidirectional_nodes;
-    std::unordered_set<std::pair<NodeID, NodeID>, boost::hash<std::pair<NodeID, NodeID>>>
-        unidirectional_segments;
+    std::unordered_set<std::pair<NodeID, NodeID>> unidirectional_segments;

    inline bool HasSignal(NodeID from, NodeID to) const
    {
-        return bidirectional_nodes.count(to) > 0 || unidirectional_segments.count({from, to}) > 0;
+        return bidirectional_nodes.contains(to) || unidirectional_segments.contains({from, to});
    }

    void Compress(NodeID from, NodeID via, NodeID to)
    {
        bidirectional_nodes.erase(via);
-        if (unidirectional_segments.count({via, to}))
+        if (unidirectional_segments.contains({via, to}))
        {
            unidirectional_segments.erase({via, to});
            unidirectional_segments.insert({from, to});
        }
-        if (unidirectional_segments.count({via, from}))
+        if (unidirectional_segments.contains({via, from}))
        {
            unidirectional_segments.erase({via, from});
            unidirectional_segments.insert({to, from});
@@ -3,10 +3,9 @@

 #include "util/concurrent_id_map.hpp"
 #include "util/integer_range.hpp"
+#include "util/std_hash.hpp"
 #include "util/typedefs.hpp"

-#include <boost/functional/hash.hpp>
-
 #include <bitset>
 #include <cstddef>
 #include <cstdint>
@@ -54,19 +53,7 @@ const constexpr Mask merge_to_right = 1u << 10u;

 using TurnLaneDescription = std::vector<TurnLaneType::Mask>;

-// hash function for TurnLaneDescription
-struct TurnLaneDescription_hash
-{
-    std::size_t operator()(const TurnLaneDescription &lane_description) const
-    {
-        std::size_t seed = 0;
-        boost::hash_range(seed, lane_description.begin(), lane_description.end());
-        return seed;
-    }
-};
-
-using LaneDescriptionMap =
-    util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID, TurnLaneDescription_hash>;
+using LaneDescriptionMap = util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID>;

 using TurnLanesIndexedArray =
    std::tuple<std::vector<std::uint32_t>, std::vector<TurnLaneType::Mask>>;
@@ -4,7 +4,7 @@
 #include "util/typedefs.hpp"

 #include <algorithm>
-#include <mapbox/variant.hpp>
+#include <variant>
 #include <vector>

 namespace osrm::extractor
@@ -61,50 +61,50 @@ struct InputViaWayPath

 struct InputTurnPath
 {
-    mapbox::util::variant<InputViaNodePath, InputViaWayPath> node_or_way;
+    std::variant<InputViaNodePath, InputViaWayPath> node_or_way;

    TurnPathType Type() const
    {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
    }

    OSMWayID From() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).from
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).from
+                   : std::get<InputViaWayPath>(node_or_way).from;
    }

    OSMWayID To() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).to
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).to
+                   : std::get<InputViaWayPath>(node_or_way).to;
    }

    InputViaWayPath &AsViaWayPath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
    }

    const InputViaWayPath &AsViaWayPath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
    }

    InputViaNodePath &AsViaNodePath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
    }

    const InputViaNodePath &AsViaNodePath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
    }
 };

@@ -175,63 +175,63 @@ struct ViaWayPath
 // between node/way paths
 struct TurnPath
 {
-    mapbox::util::variant<ViaNodePath, ViaWayPath> node_or_way;
+    std::variant<ViaNodePath, ViaWayPath> node_or_way;

    NodeID To() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).to
-                   : mapbox::util::get<ViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).to
+                   : std::get<ViaWayPath>(node_or_way).to;
    }

    NodeID From() const
    {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).from
-                   : mapbox::util::get<ViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).from
+                   : std::get<ViaWayPath>(node_or_way).from;
    }

    NodeID FirstVia() const
    {
-        if (node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH)
+        if (node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH)
        {
-            return mapbox::util::get<ViaNodePath>(node_or_way).via;
+            return std::get<ViaNodePath>(node_or_way).via;
        }
        else
        {
-            BOOST_ASSERT(!mapbox::util::get<ViaWayPath>(node_or_way).via.empty());
-            return mapbox::util::get<ViaWayPath>(node_or_way).via[0];
+            BOOST_ASSERT(!std::get<ViaWayPath>(node_or_way).via.empty());
+            return std::get<ViaWayPath>(node_or_way).via[0];
        }
    }

    ViaWayPath &AsViaWayPath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
    }

    const ViaWayPath &AsViaWayPath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
    }

    ViaNodePath &AsViaNodePath()
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
    }

    const ViaNodePath &AsViaNodePath() const
    {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
    }

    TurnPathType Type() const
    {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
    }

    bool operator==(const TurnPath &other) const
@@ -10,12 +10,16 @@

 #include <boost/assert.hpp>

+#include <cstdint>
+#include <filesystem>
+#include <type_traits>
+
 namespace osrm::guidance::files
 {

 // reads .osrm.edges
 template <typename TurnDataT>
-inline void readTurnData(const boost::filesystem::path &path,
+inline void readTurnData(const std::filesystem::path &path,
                         TurnDataT &turn_data,
                         std::uint32_t &connectivity_checksum)
 {
@@ -32,7 +36,7 @@ inline void readTurnData(const boost::filesystem::path &path,

 // writes .osrm.edges
 template <typename TurnDataT>
-inline void writeTurnData(const boost::filesystem::path &path,
+inline void writeTurnData(const std::filesystem::path &path,
                          const TurnDataT &turn_data,
                          const std::uint32_t connectivity_checksum)
 {
@@ -15,11 +15,10 @@

 #include <algorithm>
 #include <cstddef>
+#include <optional>
 #include <utility>
 #include <vector>

-#include <boost/optional.hpp>
-
 namespace osrm::guidance
 {

@@ -129,7 +128,7 @@ class IntersectionHandler
    //     ^ via
    //
    // For this scenario returns intersection at `b` and `b`.
-    boost::optional<IntersectionHandler::IntersectionViewAndNode>
+    std::optional<IntersectionHandler::IntersectionViewAndNode>
    getNextIntersection(const NodeID at, const EdgeID via) const;

    bool isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const;
@@ -7,7 +7,6 @@
 #include "guidance/intersection_handler.hpp"
 #include "guidance/is_through_street.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

 #include <vector>
@@ -42,18 +41,14 @@ class MotorwayHandler final : public IntersectionHandler
                            Intersection intersection) const override final;

  private:
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleSliproads(const NodeID intersection_node_id,
-                                 Intersection intersection) const;
+    [[nodiscard]] Intersection handleSliproads(const NodeID intersection_node_id,
+                                               Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection fallback(Intersection intersection) const;
+    [[nodiscard]] Intersection fallback(Intersection intersection) const;
 };

 } // namespace osrm::guidance
@@ -7,8 +7,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/tokenizer.hpp>

-#include "util/attributes.hpp"
-
 namespace osrm::extractor::guidance
 {

@@ -21,8 +19,7 @@ namespace osrm::extractor::guidance
 // will be corrected to left|throught, since the final lane is not drivable.
 // This is in contrast to a situation with lanes:psv:forward=0 (or not set) where left|through|
 // represents left|through|through
-OSRM_ATTR_WARN_UNUSED
-inline std::string
+[[nodiscard]] inline std::string
 trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right)
 {
    if (count_left)
@@ -68,8 +65,8 @@ trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t co
 // turn:lanes=left|through|through|right
 // vehicle:lanes=yes|yes|no|yes
 // bicycle:lanes=yes|no|designated|yes
-OSRM_ATTR_WARN_UNUSED
-inline std::string applyAccessTokens(std::string lane_string, const std::string &access_tokens)
+[[nodiscard]] inline std::string applyAccessTokens(std::string lane_string,
+                                                   const std::string &access_tokens)
 {
    using tokenizer = boost::tokenizer<boost::char_separator<char>>;
    boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
@@ -9,10 +9,9 @@

 #include "util/node_based_graph.hpp"

+#include <optional>
 #include <vector>

-#include <boost/optional.hpp>
-
 namespace osrm::guidance
 {

@@ -43,9 +42,9 @@ class SliproadHandler final : public IntersectionHandler
                            Intersection intersection) const override final;

  private:
-    boost::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
-                                                              const Intersection &intersection,
-                                                              const NodeID at) const;
+    std::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
+                                                            const Intersection &intersection,
+                                                            const NodeID at) const;

    // Next intersection from `start` onto `onto` is too far away for a Siproad scenario
    bool nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const;
@@ -17,7 +17,6 @@
 #include "guidance/turn_classification.hpp"
 #include "guidance/turn_handler.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

 #include <cstdint>
@@ -47,13 +46,11 @@ class TurnAnalysis

    /* Full Analysis Process for a single node/edge combination. Use with caution, as the process is
     * relatively expensive */
-    OSRM_ATTR_WARN_UNUSED
-    Intersection operator()(const NodeID node_prior_to_intersection,
-                            const EdgeID entering_via_edge) const;
+    [[nodiscard]] Intersection operator()(const NodeID node_prior_to_intersection,
+                                          const EdgeID entering_via_edge) const;

    // Select turn types based on the intersection shape
-    OSRM_ATTR_WARN_UNUSED
-    Intersection
+    [[nodiscard]] Intersection
    AssignTurnTypes(const NodeID from_node,
                    const EdgeID via_eid,
                    const extractor::intersection::IntersectionView &intersection) const;
@@ -8,12 +8,10 @@
 #include "guidance/intersection_handler.hpp"
 #include "guidance/is_through_street.hpp"

-#include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"

-#include <boost/optional.hpp>
-
 #include <cstddef>
+#include <optional>
 #include <utility>
 #include <vector>

@@ -72,41 +70,38 @@ class TurnHandler final : public IntersectionHandler

    bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;

-    boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
+    std::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;

    bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;

    // Dead end.
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleOneWayTurn(Intersection intersection) const;
+    [[nodiscard]] Intersection handleOneWayTurn(Intersection intersection) const;

    // Mode Changes, new names...
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleTwoWayTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleTwoWayTurn(const EdgeID via_edge,
+                                                Intersection intersection) const;

    // Forks, T intersections and similar
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleThreeWayTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleThreeWayTurn(const EdgeID via_edge,
+                                                  Intersection intersection) const;

    // Handling of turns larger then degree three
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const;
+    [[nodiscard]] Intersection handleComplexTurn(const EdgeID via_edge,
+                                                 Intersection intersection) const;

    void
    handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;

    // Classification
-    boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
+    std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignLeftTurns(const EdgeID via_edge,
-                                 Intersection intersection,
-                                 const std::size_t starting_at) const;
+    [[nodiscard]] Intersection assignLeftTurns(const EdgeID via_edge,
+                                               Intersection intersection,
+                                               const std::size_t starting_at) const;

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignRightTurns(const EdgeID via_edge,
-                                  Intersection intersection,
-                                  const std::size_t up_to) const;
+    [[nodiscard]] Intersection assignRightTurns(const EdgeID via_edge,
+                                                Intersection intersection,
+                                                const std::size_t up_to) const;
 };

 } // namespace osrm::guidance
@@ -2,7 +2,6 @@
 #define OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_

 #include "guidance/roundabout_type.hpp"
-#include "util/attributes.hpp"
 #include "util/typedefs.hpp"

 #include <algorithm>
@@ -243,8 +242,7 @@ inline guidance::DirectionModifier::Enum getTurnDirection(const double angle)
 }

 // swaps left <-> right modifier types
-OSRM_ATTR_WARN_UNUSED
-inline guidance::DirectionModifier::Enum
+[[nodiscard]] inline guidance::DirectionModifier::Enum
 mirrorDirectionModifier(const guidance::DirectionModifier::Enum modifier)
 {
    const constexpr guidance::DirectionModifier::Enum results[] = {
@@ -3,14 +3,12 @@

 #include "guidance/intersection.hpp"
 #include "guidance/turn_lane_data.hpp"
-#include "util/attributes.hpp"

 namespace osrm::guidance::lanes
 {

-OSRM_ATTR_WARN_UNUSED
-LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
-                                           const Intersection &intersection);
+[[nodiscard]] LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
+                                                         const Intersection &intersection);

 } // namespace osrm::guidance::lanes

@@ -2,7 +2,6 @@
 #define OSRM_GUIDANCE_TURN_LANE_DATA_HPP_

 #include "extractor/turn_lane_types.hpp"
-#include "util/attributes.hpp"
 #include "util/typedefs.hpp"
 #include <vector>

@@ -23,8 +22,8 @@ struct TurnLaneData
 using LaneDataVector = std::vector<TurnLaneData>;

 // convertes a string given in the OSM format into a TurnLaneData vector
-OSRM_ATTR_WARN_UNUSED
-LaneDataVector laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);
+[[nodiscard]] LaneDataVector
+laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);

 // Locate A Tag in a lane data vector (if multiple tags are set, the first one found is returned)
 LaneDataVector::const_iterator findTag(const extractor::TurnLaneType::Mask tag,
@@ -9,7 +9,6 @@
 #include "guidance/turn_analysis.hpp"
 #include "guidance/turn_lane_data.hpp"

-#include "util/attributes.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -68,8 +67,8 @@ class TurnLaneHandler

    ~TurnLaneHandler();

-    OSRM_ATTR_WARN_UNUSED
-    Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);
+    [[nodiscard]] Intersection
+    assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);

  private:
    mutable std::atomic<std::size_t> count_handled;
@@ -108,24 +107,23 @@ class TurnLaneHandler
                              const Intersection &intersection) const;

    // in case of a simple intersection, assign the lane entries
-    OSRM_ATTR_WARN_UNUSED
-    Intersection simpleMatchTuplesToTurns(Intersection intersection,
-                                          const LaneDataVector &lane_data,
-                                          const LaneDescriptionID lane_string_id);
+    [[nodiscard]] Intersection simpleMatchTuplesToTurns(Intersection intersection,
+                                                        const LaneDataVector &lane_data,
+                                                        const LaneDescriptionID lane_string_id);

    // partition lane data into lane data relevant at current turn and at next turn
-    OSRM_ATTR_WARN_UNUSED
-    std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector> partitionLaneData(
-        const NodeID at, LaneDataVector turn_lane_data, const Intersection &intersection) const;
+    [[nodiscard]] std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector>
+    partitionLaneData(const NodeID at,
+                      LaneDataVector turn_lane_data,
+                      const Intersection &intersection) const;

    // Sliproad turns have a separated lane to the right/left of other depicted lanes. These lanes
    // are not necessarily separated clearly from the rest of the way. As a result, we combine both
    // lane entries for our output, while performing the matching with the separated lanes only.
-    OSRM_ATTR_WARN_UNUSED
-    Intersection handleSliproadTurn(Intersection intersection,
-                                    const LaneDescriptionID lane_description_id,
-                                    LaneDataVector lane_data,
-                                    const Intersection &previous_intersection);
+    [[nodiscard]] Intersection handleSliproadTurn(Intersection intersection,
+                                                  const LaneDescriptionID lane_description_id,
+                                                  LaneDataVector lane_data,
+                                                  const Intersection &previous_intersection);

    // get the lane data for an intersection
    void extractLaneData(const EdgeID via_edge,
@@ -5,7 +5,6 @@
 #include "guidance/turn_instruction.hpp"
 #include "guidance/turn_lane_data.hpp"

-#include "util/attributes.hpp"
 #include "util/guidance/turn_lanes.hpp"
 #include "util/node_based_graph.hpp"

@@ -34,12 +33,12 @@ findBestMatchForReverse(const extractor::TurnLaneType::Mask leftmost_tag,
 bool canMatchTrivially(const Intersection &intersection, const LaneDataVector &lane_data);

 // perform a trivial match on the turn lanes
-OSRM_ATTR_WARN_UNUSED
-Intersection triviallyMatchLanesToTurns(Intersection intersection,
-                                        const LaneDataVector &lane_data,
-                                        const util::NodeBasedDynamicGraph &node_based_graph,
-                                        const LaneDescriptionID lane_string_id,
-                                        util::guidance::LaneDataIdMap &lane_data_to_id);
+[[nodiscard]] Intersection
+triviallyMatchLanesToTurns(Intersection intersection,
+                           const LaneDataVector &lane_data,
+                           const util::NodeBasedDynamicGraph &node_based_graph,
+                           const LaneDescriptionID lane_string_id,
+                           util::guidance::LaneDataIdMap &lane_data_to_id);

 } // namespace osrm::guidance::lanes

@@ -29,7 +29,7 @@ struct V8Renderer
        for (const auto &keyValue : object.values)
        {
            Napi::Value child;
-            mapbox::util::apply_visitor(V8Renderer(env, child), keyValue.second);
+            std::visit(V8Renderer(env, child), keyValue.second);
            obj.Set(keyValue.first, child);
        }
        out = obj;
@@ -41,7 +41,7 @@ struct V8Renderer
        for (auto i = 0u; i < array.values.size(); ++i)
        {
            Napi::Value child;
-            mapbox::util::apply_visitor(V8Renderer(env, child), array.values[i]);
+            std::visit(V8Renderer(env, child), array.values[i]);
            a.Set(i, child);
        }
        out = a;
@@ -24,11 +24,11 @@
 #include <boost/optional.hpp>

 #include <algorithm>
-#include <iostream>
 #include <iterator>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <variant>
 #include <vector>

 #include <exception>
@@ -51,7 +51,7 @@ struct PluginParameters
    bool renderToBuffer = false;
 };

-using ObjectOrString = typename mapbox::util::variant<osrm::json::Object, std::string>;
+using ObjectOrString = typename std::variant<osrm::json::Object, std::string>;

 template <typename ResultT> inline Napi::Value render(const Napi::Env &env, const ResultT &result);

@@ -62,18 +62,18 @@ template <> Napi::Value inline render(const Napi::Env &env, const std::string &r

 template <> Napi::Value inline render(const Napi::Env &env, const ObjectOrString &result)
 {
-    if (result.is<osrm::json::Object>())
+    if (std::holds_alternative<osrm::json::Object>(result))
    {
        // Convert osrm::json object tree into matching v8 object tree
        Napi::Value value;
-        renderToV8(env, value, result.get<osrm::json::Object>());
+        renderToV8(env, value, std::get<osrm::json::Object>(result));
        return value;
    }
    else
    {
        // Return the string object as a node Buffer
        return Napi::Buffer<char>::Copy(
-            env, result.get<std::string>().data(), result.get<std::string>().size());
+            env, std::get<std::string>(result).data(), std::get<std::string>(result).size());
    }
 }

@@ -96,7 +96,7 @@ inline void ParseResult(const osrm::Status &result_status, osrm::json::Object &r

    if (result_status == osrm::Status::Error)
    {
-        throw std::logic_error(code_iter->second.get<osrm::json::String>().value.c_str());
+        throw std::logic_error(std::get<osrm::json::String>(code_iter->second).value.c_str());
    }

    result.values.erase(code_iter);
@@ -296,24 +296,19 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
        {
            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
        }
-        else if (algorithm_str == "CoreCH")
-        {
-            engine_config->algorithm = osrm::EngineConfig::Algorithm::CH;
-        }
        else if (algorithm_str == "MLD")
        {
            engine_config->algorithm = osrm::EngineConfig::Algorithm::MLD;
        }
        else
        {
-            ThrowError(args.Env(), "algorithm option must be one of 'CH', 'CoreCH', or 'MLD'.");
+            ThrowError(args.Env(), "algorithm option must be one of 'CH', or 'MLD'.");
            return engine_config_ptr();
        }
    }
    else if (!algorithm.IsUndefined())
    {
-        ThrowError(args.Env(),
-                   "algorithm option must be a string and one of 'CH', 'CoreCH', or 'MLD'.");
+        ThrowError(args.Env(), "algorithm option must be a string and one of 'CH', or 'MLD'.");
        return engine_config_ptr();
    }

@@ -173,8 +173,8 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
                {
                    const auto &data = edge_based_graph.GetEdgeData(edge);
-                    // we only need to save the forward edges, since the read method will
-                    // convert from forward to bi-directional edges again
+                    // we only need to save the forward edges, since the read method
+                    // will convert from forward to bi-directional edges again
                    if (data.forward)
                    {
                        auto target = edge_based_graph.GetTarget(edge);
@@ -191,7 +191,7 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
    return edges;
 }

-inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &path)
+inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const std::filesystem::path &path)
 {
    EdgeID number_of_edge_based_nodes;
    std::vector<extractor::EdgeBasedEdge> edges;
@@ -10,7 +10,7 @@ namespace osrm::partitioner::files

 // read .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void readPartition(const boost::filesystem::path &path, MultiLevelPartitionT &mlp)
+inline void readPartition(const std::filesystem::path &path, MultiLevelPartitionT &mlp)
 {
    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -24,7 +24,7 @@ inline void readPartition(const boost::filesystem::path &path, MultiLevelPartiti

 // writes .osrm.partition file
 template <typename MultiLevelPartitionT>
-inline void writePartition(const boost::filesystem::path &path, const MultiLevelPartitionT &mlp)
+inline void writePartition(const std::filesystem::path &path, const MultiLevelPartitionT &mlp)
 {
    static_assert(std::is_same<MultiLevelPartitionView, MultiLevelPartitionT>::value ||
                      std::is_same<MultiLevelPartition, MultiLevelPartitionT>::value,
@@ -38,7 +38,7 @@ inline void writePartition(const boost::filesystem::path &path, const MultiLevel

 // reads .osrm.cells file
 template <typename CellStorageT>
-inline void readCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void readCells(const std::filesystem::path &path, CellStorageT &storage)
 {
    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                      std::is_same<CellStorage, CellStorageT>::value,
@@ -52,7 +52,7 @@ inline void readCells(const boost::filesystem::path &path, CellStorageT &storage

 // writes .osrm.cells file
 template <typename CellStorageT>
-inline void writeCells(const boost::filesystem::path &path, CellStorageT &storage)
+inline void writeCells(const std::filesystem::path &path, CellStorageT &storage)
 {
    static_assert(std::is_same<CellStorageView, CellStorageT>::value ||
                      std::is_same<CellStorage, CellStorageT>::value,
@@ -66,7 +66,7 @@ inline void writeCells(const boost::filesystem::path &path, CellStorageT &storag

 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const boost::filesystem::path &path,
+inline void readGraph(const std::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@@ -80,7 +80,7 @@ inline void readGraph(const boost::filesystem::path &path,

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const boost::filesystem::path &path,
+inline void writeGraph(const std::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
@@ -1,9 +1,8 @@
 #ifndef OSRM_PARTITIONER_CONFIG_HPP
 #define OSRM_PARTITIONER_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
 #include <array>
+#include <filesystem>
 #include <string>

 #include "storage/io_config.hpp"
@@ -29,7 +28,7 @@ struct PartitionerConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
@@ -12,7 +12,7 @@ struct header
    // explicitly use default copy c'tor as adding move c'tor
    header &operator=(const header &other) = default;
    header(std::string name, std::string value) : name(std::move(name)), value(std::move(value)) {}
-    header(header &&other) : name(std::move(other.name)), value(std::move(other.value)) {}
+    header(header &&other) noexcept : name(std::move(other.name)), value(std::move(other.value)) {}

    void clear()
    {
@@ -5,7 +5,7 @@
 #include "osrm/osrm.hpp"
 #include "util/coordinate.hpp"

-#include <mapbox/variant.hpp>
+#include <variant>

 #include <string>
 #include <vector>
@@ -10,14 +10,14 @@
 #include "util/log.hpp"
 #include "util/version.hpp"

-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/iostreams/device/array.hpp>
 #include <boost/iostreams/seek.hpp>
 #include <boost/iostreams/stream.hpp>
-
 #include <cerrno>
 #include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
 #include <tuple>
 #include <type_traits>

@@ -34,11 +34,11 @@ class FileReader
    };

    FileReader(const std::string &filename, const FingerprintFlag flag)
-        : FileReader(boost::filesystem::path(filename), flag)
+        : FileReader(std::filesystem::path(filename), flag)
    {
    }

-    FileReader(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileReader(const std::filesystem::path &filepath_, const FingerprintFlag flag)
        : filepath(filepath_), fingerprint(flag)
    {
        input_stream.open(filepath, std::ios::binary);
@@ -57,14 +57,14 @@ class FileReader

    std::size_t GetSize()
    {
-        const boost::filesystem::path path(filepath);
+        const std::filesystem::path path(filepath);
        try
        {
-            return std::size_t(boost::filesystem::file_size(path)) -
+            return std::size_t(std::filesystem::file_size(path)) -
                   ((fingerprint == FingerprintFlag::VerifyFingerprint) ? sizeof(util::FingerPrint)
                                                                        : 0);
        }
-        catch (const boost::filesystem::filesystem_error &ex)
+        catch (const std::filesystem::filesystem_error &ex)
        {
            std::cout << ex.what() << std::endl;
            throw;
@@ -195,8 +195,8 @@ class FileReader
    }

  private:
-    const boost::filesystem::path filepath;
-    boost::filesystem::ifstream input_stream;
+    const std::filesystem::path filepath;
+    std::ifstream input_stream;
    FingerprintFlag fingerprint;
 };

@@ -210,11 +210,11 @@ class FileWriter
    };

    FileWriter(const std::string &filename, const FingerprintFlag flag)
-        : FileWriter(boost::filesystem::path(filename), flag)
+        : FileWriter(std::filesystem::path(filename), flag)
    {
    }

-    FileWriter(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
+    FileWriter(const std::filesystem::path &filepath_, const FingerprintFlag flag)
        : filepath(filepath_), fingerprint(flag)
    {
        output_stream.open(filepath, std::ios::binary);
@@ -283,8 +283,8 @@ class FileWriter
    }

  private:
-    const boost::filesystem::path filepath;
-    boost::filesystem::ofstream output_stream;
+    const std::filesystem::path filepath;
+    std::ofstream output_stream;
    FingerprintFlag fingerprint;
 };

@@ -3,19 +3,19 @@

 #include "util/exception.hpp"

-#include <array>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/path.hpp>
+
+#include <array>
+#include <filesystem>
 #include <string>

 namespace osrm::storage
 {
 struct IOConfig
 {
-    IOConfig(std::vector<boost::filesystem::path> required_input_files_,
-             std::vector<boost::filesystem::path> optional_input_files_,
-             std::vector<boost::filesystem::path> output_files_)
+    IOConfig(std::vector<std::filesystem::path> required_input_files_,
+             std::vector<std::filesystem::path> optional_input_files_,
+             std::vector<std::filesystem::path> output_files_)
        : required_input_files(std::move(required_input_files_)),
          optional_input_files(std::move(optional_input_files_)),
          output_files(std::move(output_files_))
@@ -24,7 +24,7 @@ struct IOConfig

    bool IsValid() const;
    std::vector<std::string> GetMissingFiles() const;
-    boost::filesystem::path GetPath(const std::string &fileName) const
+    std::filesystem::path GetPath(const std::string &fileName) const
    {
        if (!IsConfigured(fileName, required_input_files) &&
            !IsConfigured(fileName, optional_input_files) && !IsConfigured(fileName, output_files))
@@ -40,11 +40,11 @@ struct IOConfig
        return IsConfigured(fileName, required_input_files);
    }

-    boost::filesystem::path base_path;
+    std::filesystem::path base_path;

  protected:
    // Infer the base path from the path of the .osrm file
-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        // potentially strip off the .osrm (or other) extensions for
        // determining the base path=
@@ -67,7 +67,7 @@ struct IOConfig

  private:
    static bool IsConfigured(const std::string &fileName,
-                             const std::vector<boost::filesystem::path> &paths)
+                             const std::vector<std::filesystem::path> &paths)
    {
        for (auto &path : paths)
        {
@@ -80,9 +80,9 @@ struct IOConfig
        return false;
    }

-    std::vector<boost::filesystem::path> required_input_files;
-    std::vector<boost::filesystem::path> optional_input_files;
-    std::vector<boost::filesystem::path> output_files;
+    std::vector<std::filesystem::path> required_input_files;
+    std::vector<std::filesystem::path> optional_input_files;
+    std::vector<std::filesystem::path> output_files;
 };
 } // namespace osrm::storage

@@ -5,8 +5,6 @@
 #include "util/exception_utils.hpp"
 #include "util/log.hpp"

-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/interprocess/mapped_region.hpp>
 #ifndef _WIN32
 #include <boost/interprocess/xsi_shared_memory.hpp>
@@ -23,6 +21,8 @@

 #include <algorithm>
 #include <exception>
+#include <filesystem>
+#include <fstream>
 #include <thread>

 #include "storage/shared_memory_ownership.hpp"
@@ -32,10 +32,10 @@ namespace osrm::storage

 struct OSRMLockFile
 {
-    template <typename IdentifierT> boost::filesystem::path operator()(const IdentifierT &id)
+    template <typename IdentifierT> std::filesystem::path operator()(const IdentifierT &id)
    {
-        boost::filesystem::path temp_dir = boost::filesystem::temp_directory_path();
-        boost::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
+        std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
+        std::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
        return lock_file;
    }
 };
@@ -51,7 +51,7 @@ class SharedMemory
    SharedMemory &operator=(const SharedMemory &) = delete;

    template <typename IdentifierT>
-    SharedMemory(const boost::filesystem::path &lock_file,
+    SharedMemory(const std::filesystem::path &lock_file,
                 const IdentifierT id,
                 const uint64_t size = 0)
        : key(lock_file.string().c_str(), id)
@@ -61,7 +61,7 @@ class SharedMemory
        {
            shm = boost::interprocess::xsi_shared_memory(boost::interprocess::open_only, key);

-            util::Log(logDEBUG) << "opening " << (int)shm.get_shmid() << " from id " << (int)id;
+            util::Log(logDEBUG) << "opening " << shm.get_shmid() << " from id " << (int)id;

            region = boost::interprocess::mapped_region(shm, boost::interprocess::read_only);
        }
@@ -202,7 +202,7 @@ class SharedMemory
    void *Ptr() const { return region.get_address(); }
    std::size_t Size() const { return region.get_size(); }

-    SharedMemory(const boost::filesystem::path &lock_file, const int id, const uint64_t size = 0)
+    SharedMemory(const std::filesystem::path &lock_file, const int id, const uint64_t size = 0)
    {
        sprintf(key, "%s.%d", "osrm.lock", id);
        if (0 == size)
@@ -290,7 +290,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
    try
    {
        LockFileT lock_file;
-        if (!boost::filesystem::exists(lock_file(id)))
+        if (!std::filesystem::exists(lock_file(id)))
        {
            if (0 == size)
            {
@@ -298,7 +298,7 @@ std::unique_ptr<SharedMemory> makeSharedMemory(const IdentifierT &id, const uint
            }
            else
            {
-                boost::filesystem::ofstream ofs(lock_file(id));
+                std::ofstream ofs(lock_file(id));
            }
        }
        return std::make_unique<SharedMemory>(lock_file(id), id, size);
@@ -32,15 +32,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/shared_datatype.hpp"
 #include "storage/storage_config.hpp"

-#include <boost/filesystem/path.hpp>
-
+#include <filesystem>
 #include <string>
 #include <vector>

 namespace osrm::storage
 {

-void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout);
+void populateLayoutFromFile(const std::filesystem::path &path, storage::BaseDataLayout &layout);

 class Storage
 {
@@ -51,10 +50,10 @@ class Storage
    void PopulateStaticData(const SharedDataIndex &index);
    void PopulateUpdatableData(const SharedDataIndex &index);
    void PopulateLayout(storage::BaseDataLayout &layout,
-                        const std::vector<std::pair<bool, boost::filesystem::path>> &files);
+                        const std::vector<std::pair<bool, std::filesystem::path>> &files);
    std::string PopulateLayoutWithRTree(storage::BaseDataLayout &layout);
-    std::vector<std::pair<bool, boost::filesystem::path>> GetUpdatableFiles();
-    std::vector<std::pair<bool, boost::filesystem::path>> GetStaticFiles();
+    std::vector<std::pair<bool, std::filesystem::path>> GetUpdatableFiles();
+    std::vector<std::pair<bool, std::filesystem::path>> GetStaticFiles();

  private:
    StorageConfig config;
@@ -28,22 +28,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef STORAGE_CONFIG_HPP
 #define STORAGE_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
 #include "storage/io_config.hpp"
 #include "osrm/datasets.hpp"

+#include <filesystem>
+#include <istream>
 #include <set>
+#include <vector>

 namespace osrm::storage
 {

 std::istream &operator>>(std::istream &in, FeatureDataset &datasets);

-static std::vector<boost::filesystem::path>
+static std::vector<std::filesystem::path>
 GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_dataset)
 {
-    std::set<boost::filesystem::path> required{
+    std::set<std::filesystem::path> required{
        ".osrm.datasource_names",
        ".osrm.ebg_nodes",
        ".osrm.edges",
@@ -82,7 +83,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
        }
    }

-    return std::vector<boost::filesystem::path>(required.begin(), required.end());
+    return std::vector<std::filesystem::path>(required.begin(), required.end());
    ;
 }

@@ -94,7 +95,7 @@ GetRequiredFiles(const std::vector<storage::FeatureDataset> &disabled_feature_da
 struct StorageConfig final : IOConfig
 {

-    StorageConfig(const boost::filesystem::path &base,
+    StorageConfig(const std::filesystem::path &base,
                  const std::vector<storage::FeatureDataset> &disabled_feature_datasets_ = {})
        : StorageConfig(disabled_feature_datasets_)
    {
@@ -7,7 +7,7 @@
 #include "util/integer_range.hpp"
 #include "util/version.hpp"

-#include <boost/filesystem/path.hpp>
+#include <filesystem>

 extern "C"
 {
@@ -19,7 +19,7 @@ namespace osrm::storage::tar
 namespace detail
 {
 inline void
-checkMTarError(int error_code, const boost::filesystem::path &filepath, const std::string &name)
+checkMTarError(int error_code, const std::filesystem::path &filepath, const std::string &name)
 {
    switch (error_code)
    {
@@ -78,7 +78,7 @@ class FileReader
        HasNoFingerprint
    };

-    FileReader(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileReader(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
    {
        auto ret = mtar_open(&handle, path.string().c_str(), "r");
        detail::checkMTarError(ret, path, "");
@@ -204,7 +204,7 @@ class FileReader
        return true;
    }

-    boost::filesystem::path path;
+    std::filesystem::path path;
    mtar_t handle;
 };

@@ -217,7 +217,7 @@ class FileWriter
        HasNoFingerprint
    };

-    FileWriter(const boost::filesystem::path &path, FingerprintFlag flag) : path(path)
+    FileWriter(const std::filesystem::path &path, FingerprintFlag flag) : path(path)
    {
        auto ret = mtar_open(&handle, path.string().c_str(), "w");
        detail::checkMTarError(ret, path, "");
@@ -305,7 +305,7 @@ class FileWriter
        WriteFrom("osrm_fingerprint.meta", fingerprint);
    }

-    boost::filesystem::path path;
+    std::filesystem::path path;
    mtar_t handle;
 };
 } // namespace osrm::storage::tar
@@ -202,7 +202,7 @@ inline auto make_search_tree_view(const SharedDataIndex &index, const std::strin

    const char *path = index.template GetBlockPtr<char>(name + "/file_index_path");

-    if (!boost::filesystem::exists(boost::filesystem::path{path}))
+    if (!std::filesystem::exists(std::filesystem::path{path}))
    {
        throw util::exception("Could not load " + std::string(path) + "Does the leaf file exist?" +
                              SOURCE_REF);
@@ -12,12 +12,12 @@
 #include <tbb/spin_mutex.h>

 #include <boost/exception/diagnostic_information.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
 #include <boost/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>

 #include <exception>
+#include <filesystem>
 #include <stdexcept>
 #include <vector>

@@ -39,7 +39,7 @@ template <typename Key, typename Value> struct CSVFilesParser
    {
    }

-    // Operator returns a lambda function that maps input Key to boost::optional<Value>.
+    // Operator returns a lambda function that maps input Key to std::optional<Value>.
    auto operator()(const std::vector<std::string> &csv_filenames) const
    {
        try
@@ -100,7 +100,7 @@ template <typename Key, typename Value> struct CSVFilesParser
        std::vector<std::pair<Key, Value>> result;
        try
        {
-            if (boost::filesystem::file_size(filename) == 0)
+            if (std::filesystem::file_size(filename) == 0)
                return result;

            boost::iostreams::mapped_file_source mmap(filename);
@@ -3,8 +3,7 @@

 #include "util/typedefs.hpp"

-#include <boost/optional.hpp>
-
+#include <optional>
 #include <vector>

 namespace osrm::updater
@@ -12,9 +11,9 @@ namespace osrm::updater

 template <typename Key, typename Value> struct LookupTable
 {
-    boost::optional<Value> operator()(const Key &key) const
+    std::optional<Value> operator()(const Key &key) const
    {
-        using Result = boost::optional<Value>;
+        using Result = std::optional<Value>;
        const auto it =
            std::lower_bound(lookup.begin(),
                             lookup.end(),
@@ -50,7 +49,7 @@ struct SpeedSource final
 {
    SpeedSource() : speed(0.), rate() {}
    double speed;
-    boost::optional<double> rate;
+    std::optional<double> rate;
    std::uint8_t source;
 };

@@ -28,14 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OSRM_UPDATER_UPDATER_CONFIG_HPP
 #define OSRM_UPDATER_UPDATER_CONFIG_HPP

-#include <boost/filesystem/path.hpp>
-
-#include <chrono>
-#include <string>
-
 #include "storage/io_config.hpp"
 #include "storage/storage_config.hpp"

+#include <chrono>
+#include <filesystem>
+#include <string>
+
 namespace osrm::updater
 {

@@ -59,7 +58,7 @@ struct UpdaterConfig final : storage::IOConfig
    {
    }

-    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    void UseDefaultOutputNames(const std::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
@@ -28,9 +28,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OSRM_UTIL_ALIAS_HPP
 #define OSRM_UTIL_ALIAS_HPP

-#include <boost/numeric/conversion/cast.hpp>
+#include <cstddef>
 #include <functional>
-#include <iostream>
+#include <ostream>
 #include <type_traits>

 namespace osrm
@@ -1,13 +0,0 @@
-#ifndef OSRM_ATTRIBUTES_HPP_
-#define OSRM_ATTRIBUTES_HPP_
-
-// OSRM_ATTR_WARN_UNUSED - caller has to use function's return value
-// https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html
-
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#define OSRM_ATTR_WARN_UNUSED __attribute__((warn_unused_result))
-#else
-#define OSRM_ATTR_WARN_UNUSED
-#endif
-
-#endif
@@ -0,0 +1,40 @@
+#pragma once
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <vector>
+
+namespace osrm::util
+{
+
+// in its essence it is std::priority_queue, but with `clear` method
+template <typename T> class BinaryHeap
+{
+  public:
+    bool empty() const { return heap_.empty(); }
+
+    const T &top() const
+    {
+        BOOST_ASSERT(!heap_.empty());
+        return heap_.front();
+    }
+
+    void pop()
+    {
+        BOOST_ASSERT(!heap_.empty());
+        std::pop_heap(heap_.begin(), heap_.end());
+        heap_.pop_back();
+    }
+
+    template <typename... Args> void emplace(Args &&...args)
+    {
+        heap_.emplace_back(std::forward<Args>(args)...);
+        std::push_heap(heap_.begin(), heap_.end());
+    }
+
+    void clear() { heap_.clear(); }
+
+  private:
+    std::vector<T> heap_;
+};
+
+} // namespace osrm::util
@@ -4,6 +4,7 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <numbers>
 #include <tuple>
 #include <utility>

@@ -37,7 +38,7 @@ class CheapRuler
    static constexpr double FE = 1.0 / 298.257223563; // flattening

    static constexpr double E2 = FE * (2 - FE);
-    static constexpr double RAD = M_PI / 180.0;
+    static constexpr double RAD = std::numbers::pi / 180.0;

  public:
    explicit CheapRuler(double latitude)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Siarhei Fedartsou	8b878a841e	Merge branch 'master' into sf-ankerl	2024-06-26 18:39:02 +02:00
Siarhei Fedartsou	8aade382bb	wip	2024-06-26 18:10:53 +02:00
Siarhei Fedartsou	a522016953	wip	2024-06-26 18:10:19 +02:00
Siarhei Fedartsou	0e17869e21	Re-use priority queue in StaticRTree (#6952 )	2024-06-25 18:58:48 +02:00
Siarhei Fedartsou	6f444be1de	ankerl	2024-06-25 18:27:53 +02:00
Siarhei Fedartsou	72527d63a0	Merge branch 'master' into sf-ankerl	2024-06-25 17:53:09 +02:00
Siarhei Fedartsou	5a48ce85b3	Use tmpfs for running benchmarks (#6966 )	2024-06-25 17:49:41 +02:00
Siarhei Fedartsou	7d72dfebf7	Optimise encodePolyline function (#6940 )	2024-06-22 20:04:32 +02:00
Siarhei Fedartsou	3d01d96036	Avoid reallocations in base64 encoding (#6951 )	2024-06-22 08:50:18 +02:00
Siarhei Fedartsou	e8da3d9231	Calculate confidence interval for benchmark measurements (#6950 )	2024-06-21 21:43:27 +02:00
Siarhei Fedartsou	d9ce9cf780	Get rid of unused Boost dependencies (#6960 )	2024-06-21 19:04:34 +02:00
Siarhei Fedartsou	3285ce3b2f	Configure stale bot (#6963 )	2024-06-21 08:51:56 +02:00
Dennis Luxen	f1eabc3ecc	Replace boost::filesystem with std (#6432 )	2024-06-20 21:44:28 +02:00
knowname	c3f2a6cdb9	Add CI job for building Alpine-based Docker image (#6959 )	2024-06-20 09:08:57 +02:00
knowname	97f676d5a3	add alpine dockerfile (#6958 )	2024-06-19 14:15:23 +02:00
Siarhei Fedartsou	7ffc08be28	Bump versions of TBB, Expat and Lua installed via Conan (#6957 )	2024-06-19 07:46:56 +02:00
Siarhei Fedartsou	feb9389436	Apply micro-optimisation for Table & Trip APIs (#6949 )	2024-06-15 18:57:26 +02:00
Siarhei Fedartsou	a0eda3e7d7	Apply micro-optimisation for Route API (#6948 )	2024-06-15 18:56:40 +02:00
Siarhei Fedartsou	7652f6ca6b	Apply micro-optimisation for Match API (#6945 )	2024-06-14 16:04:19 +02:00
Siarhei Fedartsou	3ff2819922	wip	2024-06-13 18:31:19 +02:00
Siarhei Fedartsou	aa4e6b1cf3	Apply micro-optimisation for Nearest API (#6944 )	2024-06-13 18:18:36 +02:00
Siarhei Fedartsou	559768c351	wip	2024-06-12 21:47:58 +02:00
Siarhei Fedartsou	316b8dbec2	wip	2024-06-12 21:05:39 +02:00
Siarhei Fedartsou	1724c3a7fa	wip	2024-06-12 21:03:13 +02:00
Siarhei Fedartsou	112e089166	wip	2024-06-12 20:01:37 +02:00
Siarhei Fedartsou	250c406098	wip	2024-06-12 17:18:47 +02:00
Siarhei Fedartsou	11c3369cf4	wip	2024-06-12 13:33:18 +02:00
Siarhei Fedartsou	f4ce1dc8f6	wip	2024-06-12 09:21:20 +02:00
Siarhei Fedartsou	49f07cbb8e	wip	2024-06-11 22:41:49 +02:00
Siarhei Fedartsou	68d5dbc919	wip	2024-06-11 16:27:21 +02:00
Siarhei Fedartsou	068a1da098	wip	2024-06-11 09:14:57 +02:00
Siarhei Fedartsou	de2f392960	Avoid copy of intersection in totalTurnAngle (#6938 )	2024-06-10 22:40:37 +02:00
Siarhei Fedartsou	ff02ae92f4	wip	2024-06-10 21:43:49 +02:00
Siarhei Fedartsou	0188d2bccd	Use std::unordered_map::emplace instead of operator[] when producing JSONs (#6936 )	2024-06-10 21:29:31 +02:00
Siarhei Fedartsou	054161fc7e	Avoid copy of vectors in MakeRoute function (#6939 )	2024-06-10 20:06:43 +02:00
Siarhei Fedartsou	a65c9cbcb1	wip	2024-06-10 12:33:53 +02:00
Siarhei Fedartsou	13d8eebbca	wip	2024-06-09 22:57:31 +02:00
Siarhei Fedartsou	93820be50e	Avoid copy of intersection in totalTurnAngle	2024-06-09 19:37:44 +02:00
Siarhei Fedartsou	47d1630e7f	wip	2024-06-09 18:17:27 +02:00
Siarhei Fedartsou	79da3793c1	wip	2024-06-09 17:07:35 +02:00
Siarhei Fedartsou	c5cf8c31ac	Merge branch 'master' into sf-ankerl	2024-06-09 17:03:53 +02:00
Siarhei Fedartsou	89435aa87f	Add new randomized benchmarks (#6929 )	2024-06-09 17:03:24 +02:00
Siarhei Fedartsou	67558b796f	wip	2024-06-09 13:11:09 +02:00
Siarhei Fedartsou	2a3f539bb2	wip	2024-06-09 11:13:31 +02:00
Siarhei Fedartsou	ada954cd8d	wip	2024-06-09 10:43:28 +02:00
Siarhei Fedartsou	9398bbc382	wip	2024-06-09 10:39:20 +02:00
Siarhei Fedartsou	0cbb23abe1	Fix Windows CI: update conan.cmake and disable unit tests as temporary workaround for OOM issues (#6930 )	2024-06-09 09:24:02 +02:00
Siarhei Fedartsou	2e3f3e90ef	Merge branch 'master' into sf-ankerl	2024-06-08 22:29:49 +02:00
Siarhei Fedartsou	a2915f78c5	Make e2e benchmarks more stable (#6927 )	2024-06-08 22:27:12 +02:00
Siarhei Fedartsou	99cb17aed3	Fix bugprone-unused-return-value clang-tidy warning (#6934 )	2024-06-08 14:33:24 +02:00
Siarhei Fedartsou	8fd8d0c24a	Fix performance-noexcept-move-constructor clang-tidy warning (#6933 )	2024-06-08 08:33:54 +02:00
Siarhei Fedartsou	c57b0d28b0	Fix performance-noexcept-swap clang-tidy warning (#6931 )	2024-06-07 16:18:10 +02:00
Siarhei Fedartsou	523ee762f0	Upgrade to clang-tidy 18 (#6919 )	2024-06-06 22:20:38 +02:00
Siarhei Fedartsou	feeed75cf1	Add simple benchmarks for osrm-* tools (#6925 )	2024-06-06 21:01:34 +02:00
Siarhei Fedartsou	2e54842ce8	Merge branch 'master' into sf-ankerl	2024-06-05 21:48:14 +02:00
Siarhei Fedartsou	c7ee1a59eb	Implement end to end benchmark (#6910 )	2024-06-05 21:39:10 +02:00
Dennis Luxen	2725202771	Use Lemire's fast check whether to escape a JSON string (#6923 )	2024-05-31 19:58:57 +02:00
Siarhei Fedartsou	42fafdcdfe	Use custom struct instead of std::pair in QueryHeap (#6921 )	2024-05-31 07:06:58 +02:00
Siarhei Fedartsou	c8de759cd6	Use std::string_view::starts_with instead of boost::starts_with (#6918 )	2024-05-30 21:55:25 +02:00
Siarhei Fedartsou	cf4141dffd	Try to use ankerl::unordered_dense::map instead of std::unordered_map in UnorderedMapStorage	2024-05-30 19:49:06 +02:00
Siarhei Fedartsou	fb9d1cefcc	Get rid of boost::math::constants::* and M_PI in favor of std::numbers (#6916 )	2024-05-30 19:40:56 +02:00
Siarhei Fedartsou	c3683201e6	Try to use ankerl::unordered_dense::map instead of std::unordered_map in UnorderedMapStorage	2024-05-30 19:21:38 +02:00
Siarhei Fedartsou	0f5ffc2a84	Try to use ankerl::unordered_dense::map instead of std::unordered_map in UnorderedMapStorage	2024-05-30 19:19:30 +02:00
Siarhei Fedartsou	fafe1d4f81	Merge commit 'f1087e81ecdca5a59ba5ffca684c955c5b38f7c2' as 'third_party/unordered_dense'	2024-05-30 19:06:16 +02:00
Siarhei Fedartsou	f1087e81ec	Squashed 'third_party/unordered_dense/' content from commit 231e48c94 git-subtree-dir: third_party/unordered_dense git-subtree-split: 231e48c9426bd21c273669e5fdcd042c146975cf	2024-05-30 19:06:16 +02:00
Siarhei Fedartsou	178bcb974e	Add ankerl	2024-05-30 19:06:09 +02:00
Dennis Luxen	a9b1bd88d3	Remove all core-CH left-overs (#6920 ) * Remove all core-CH left-overs * Fix formatting * Update CHANGELOG.md	2024-05-30 17:13:44 +02:00
Siarhei Fedartsou	1ff096ac5c	Make constants in PackedVector constexpr (#6917 )	2024-05-30 15:12:42 +02:00
Dennis Luxen	0ea757ed02	Remove unused header file (#6913 )	2024-05-29 09:13:13 +02:00
Dennis Luxen	42cbca0ff0	Move Sol2 to canonical path (#6912 )	2024-05-28 21:23:51 +02:00
Siarhei Fedartsou	c1ed73126d	Use std::variant instead of mapbox::util::variant (#6903 )	2024-05-28 18:52:49 +02:00
Siarhei Fedartsou	01b1673c8a	Fix CCache usage in GitHub Actions (#6911 )	2024-05-28 08:43:23 +02:00
Siarhei Fedartsou	d4dc297f75	Add CI job with GCC 14 (#6905 )	2024-05-27 09:31:13 +02:00
Siarhei Fedartsou	9aaab7a53f	Enable readability-container-contains clang-tidy check (#6909 )	2024-05-27 08:33:26 +02:00
Siarhei Fedartsou	1a6f4c44e7	Fix performance-type-promotion-in-math-fn clang-tidy warning (#6908 )	2024-05-27 08:33:05 +02:00
Siarhei Fedartsou	163a2cfe3c	Bump rapidjson version (#6906 )	2024-05-27 08:31:59 +02:00
Siarhei Fedartsou	667fd198ac	Use the latest Debian version in Dockerfile (#6904 )	2024-05-27 08:30:44 +02:00
Siarhei Fedartsou	b7a990d0b5	Use C++20 (#6877 )	2024-05-25 18:25:13 +02:00
Dennis Luxen	8306ed8ae3	Remove superflous iostreams include from header files (#6901 )	2024-05-25 09:17:45 +02:00
Dennis Luxen	640df69aa1	Remove dead CRC32 processor code (#6900 )	2024-05-24 22:43:03 +02:00
Siarhei Fedartsou	8b48e2ccc6	Bump mapbox/variant to version 1.2.0 (#6898 )	2024-05-24 20:39:45 +02:00
Dennis Luxen	babdced52f	Replace GCC-specific attribute with [[nodiscard]] attribute (#6899 )	2024-05-24 20:34:04 +02:00
Siarhei Fedartsou	21607e0cb2	Optimise getNetworkDistance in MLD even more (#6884 )	2024-05-23 20:46:13 +02:00
Dennis Luxen	24646aada9	Remove outdated warnings (#6894 )	2024-05-23 19:39:00 +02:00
Dennis Luxen	51b74a99aa	Avoid copy of std::function-based callback in path unpacking (#6895 ) * Avoid copy of std::function-based callback in path unpacking * Fix formatting * Update CHANGELOG.md	2024-05-23 18:51:51 +02:00
Dennis Luxen	ed5003b502	Upgrade CI actions to latest versions (#6893 ) * Upgrade actions * Update remaining actions * Update CHANGELOG.md * Update CHANGELOG.md	2024-05-23 14:40:47 +02:00
Dennis Luxen	46dc660801	Replace boost::hash by std::hash (#6892 ) * Replace boost::hash by std::hash * Fix formatting * Update CHANGELOG.md	2024-05-23 14:35:56 +02:00
Siarhei Fedartsou	73fb53cf36	Add benchmark for route (#6890 )	2024-05-23 14:27:43 +02:00
Mugr Rex	efe6840d08	Replace boost::optional with std::optional (#6611 )	2024-05-22 14:58:07 +02:00
Siarhei Fedartsou	d259848456	Optimise R-tree queries in the case of map matching (#6881 )	2024-05-20 12:32:40 +02:00
Siarhei Fedartsou	8a82d3929c	Improve map matching benchmark (#6885 )	2024-05-20 11:15:55 +02:00
Siarhei Fedartsou	89fce286a7	Fix benchmark script for the case if PR has empty description (#6887 )	2024-05-20 09:16:53 +02:00
Siarhei Fedartsou	11c7ddc84d	Fix failing gcc-13 based CI jobs (#6886 ) * Attempt to fix failing CI on gcc-13 jobs * Attempt to fix failing CI on gcc-13 jobs * Attempt to fix failing CI on gcc-13 jobs * Attempt to fix failing CI on gcc-13 jobs * Attempt to fix failing CI on gcc-13 jobs	2024-05-19 19:30:24 +02:00
Siarhei Fedartsou	54e50a67a8	Add benchmarks comparison job (#6880 )	2024-05-14 17:14:59 +02:00
Bart Louwers	c00c157479	Replace dead link with archive.org link (#6882 )	2024-05-14 11:49:49 +02:00