Merge branch 'master' into replace_boost_filesystem

2024-06-09 13:29:24 +02:00 · 2024-06-09 13:29:24 +02:00 · b71d3cda95
commit b71d3cda95
parent 129af1ae2c 0cbb23abe1
355 changed files with 14724 additions and 20042 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -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: '*'
--- a/.github/workflows/osrm-backend.yml
+++ b/.github/workflows/osrm-backend.yml
@ -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"

@ -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@v2
    - 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
@ -193,17 +209,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
@ -245,6 +262,16 @@ jobs:
            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON

+          - name: gcc-14-release
+            continue-on-error: false
+            node: 20
+            runs-on: ubuntu-24.04
+            BUILD_TOOLS: 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
@ -265,15 +292,6 @@ jobs:
            CXXCOMPILER: g++-12
            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
-
          - name: conan-linux-release-node
            build_node_package: true
            continue-on-error: false
@ -377,9 +395,11 @@ jobs:
        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
@ -396,7 +416,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
@ -417,7 +466,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
@ -427,7 +476,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
@ -458,8 +507,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} \
@ -476,7 +525,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
@ -579,7 +628,10 @@ 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'
@ -594,6 +646,13 @@ jobs:
      PR_NUMBER: ${{ github.event.pull_request.number }}
      GITHUB_REPOSITORY: ${{ github.repository }}
    steps: 
+      - name: Enable data.osm.pbf cache
+        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:
@ -613,7 +672,22 @@ jobs:
        with:
          ref: ${{ github.head_ref }}
          path: pr
-      - run: python3 -m pip install "conan<2.0.0" "requests==2.31.0"
+      - 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 [ ! -f "~/data.osm.pbf" ]; then
+            wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf
+          fi
+          gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
+      - name: Prepare environment
+        run: |
+          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+          mkdir -p $HOME/.ccache
+          ccache --zero-stats
+          ccache --max-size=256M
      - name: Build PR Branch
        run: |
          mkdir -p pr/build
@ -643,6 +717,10 @@ jobs:
      - 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
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,12 +1,15 @@
 # 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)
@ -21,6 +24,16 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
+      - 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)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -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,8 +120,7 @@ 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)

@ -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)
@ -607,7 +605,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 +624,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)
--- a/cmake/conan.cmake
+++ b/cmake/conan.cmake
@ -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}]")
--- a/cmake/warnings.cmake
+++ b/cmake/warnings.cmake
@ -78,4 +78,9 @@ add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
 # these warnings are not enabled by default
-# no_warning(name-of-warning)
+# 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)
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -1,15 +1,15 @@
-FROM debian:bullseye-slim as builder
+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.74-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+    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.3.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
    cd oneTBB && \
    mkdir build && \
    cd build && \
@ -21,6 +21,7 @@ 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)" && \
@ -42,15 +43,15 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \

 # 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
+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.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 \
+    apt-get install -y --no-install-recommends libboost-program-options1.81.0 libboost-regex1.81.0 \
+        libboost-date-time1.81.0 libboost-chrono1.81.0 libboost-filesystem1.81.0 \
+        libboost-iostreams1.81.0 libboost-system1.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
--- a/docs/nodejs/api.md
+++ b/docs/nodejs/api.md
@ -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.
--- a/example/example.cpp
+++ b/example/example.cpp
@ -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";
--- a/include/contractor/crc32_processor.hpp
+++ b/include/contractor/crc32_processor.hpp
@ -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 */
--- a/include/engine/api/base_result.hpp
+++ b/include/engine/api/base_result.hpp
@ -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
--- a/include/engine/api/json_factory.hpp
+++ b/include/engine/api/json_factory.hpp
@ -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;
 }
--- a/include/engine/api/match_api.hpp
+++ b/include/engine/api/match_api.hpp
@ -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);
        }
    }
--- a/include/engine/api/nearest_api.hpp
+++ b/include/engine/api/nearest_api.hpp
@ -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);
        }
    }
--- a/include/engine/api/route_api.hpp
+++ b/include/engine/api/route_api.hpp
@ -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);
        }
    }
@ -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)
@ -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();
    };

--- a/include/engine/api/table_api.hpp
+++ b/include/engine/api/table_api.hpp
@ -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);
        }
    }
@ -377,7 +377,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 +407,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 +416,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;
    }

--- a/include/engine/api/trip_api.hpp
+++ b/include/engine/api/trip_api.hpp
@ -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);
        }
    }
--- a/include/engine/engine_config.hpp
+++ b/include/engine/engine_config.hpp
@ -53,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.
 *
@ -73,7 +69,6 @@ struct EngineConfig final
    enum class Algorithm
    {
        CH,
-        CoreCH, // Deprecated, will be removed in v6.0
        MLD
    };

--- a/include/engine/guidance/collapse_turns.hpp
+++ b/include/engine/guidance/collapse_turns.hpp
@ -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
--- a/include/engine/guidance/collapsing_utility.hpp
+++ b/include/engine/guidance/collapsing_utility.hpp
@ -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.
--- a/include/engine/guidance/lane_processing.hpp
+++ b/include/engine/guidance/lane_processing.hpp
@ -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

--- a/include/engine/guidance/post_processing.hpp
+++ b/include/engine/guidance/post_processing.hpp
@ -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.
--- a/include/engine/guidance/verbosity_reduction.hpp
+++ b/include/engine/guidance/verbosity_reduction.hpp
@ -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

--- a/include/engine/map_matching/bayes_classifier.hpp
+++ b/include/engine/map_matching/bayes_classifier.hpp
@ -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));
    }

--- a/include/engine/map_matching/hidden_markov_model.hpp
+++ b/include/engine/map_matching/hidden_markov_model.hpp
@ -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();
--- a/include/engine/map_matching/matching_confidence.hpp
+++ b/include/engine/map_matching/matching_confidence.hpp
@ -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
--- a/include/engine/plugins/plugin_base.hpp
+++ b/include/engine/plugins/plugin_base.hpp
@ -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;
    }

--- a/include/engine/search_engine_data.hpp
+++ b/include/engine/search_engine_data.hpp
@ -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
--- a/include/extractor/internal_extractor_edge.hpp
+++ b/include/extractor/internal_extractor_edge.hpp
@ -7,8 +7,8 @@
 #include "util/typedefs.hpp"

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

 namespace osrm::extractor
 {
--- a/include/extractor/intersection/coordinate_extractor.hpp
+++ b/include/extractor/intersection/coordinate_extractor.hpp
@ -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;
--- a/include/extractor/maneuver_override.hpp
+++ b/include/extractor/maneuver_override.hpp
@ -11,7 +11,7 @@
 #include "util/std_hash.hpp"
 #include "util/vector_view.hpp"

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

 #include <algorithm>

--- a/include/extractor/restriction.hpp
+++ b/include/extractor/restriction.hpp
@ -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
--- a/include/extractor/serialization.hpp
+++ b/include/extractor/serialization.hpp
@ -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
--- a/include/extractor/traffic_signals.hpp
+++ b/include/extractor/traffic_signals.hpp
@ -17,18 +17,18 @@ struct TrafficSignals

    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});
--- a/include/extractor/turn_path.hpp
+++ b/include/extractor/turn_path.hpp
@ -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
--- a/include/guidance/motorway_handler.hpp
+++ b/include/guidance/motorway_handler.hpp
@ -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
--- a/include/guidance/parsing_toolkit.hpp
+++ b/include/guidance/parsing_toolkit.hpp
@ -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);
--- a/include/guidance/turn_analysis.hpp
+++ b/include/guidance/turn_analysis.hpp
@ -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;
--- a/include/guidance/turn_handler.hpp
+++ b/include/guidance/turn_handler.hpp
@ -8,7 +8,6 @@
 #include "guidance/intersection_handler.hpp"
 #include "guidance/is_through_street.hpp"

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

 #include <cstddef>
@ -76,20 +75,19 @@ class TurnHandler final : public IntersectionHandler
    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;
@ -97,15 +95,13 @@ class TurnHandler final : public IntersectionHandler
    // Classification
    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
--- a/include/guidance/turn_instruction.hpp
+++ b/include/guidance/turn_instruction.hpp
@ -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[] = {
--- a/include/guidance/turn_lane_augmentation.hpp
+++ b/include/guidance/turn_lane_augmentation.hpp
@ -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

--- a/include/guidance/turn_lane_data.hpp
+++ b/include/guidance/turn_lane_data.hpp
@ -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,
--- a/include/guidance/turn_lane_handler.hpp
+++ b/include/guidance/turn_lane_handler.hpp
@ -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,
--- a/include/guidance/turn_lane_matcher.hpp
+++ b/include/guidance/turn_lane_matcher.hpp
@ -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

--- a/include/nodejs/json_v8_renderer.hpp
+++ b/include/nodejs/json_v8_renderer.hpp
@ -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;
--- a/include/nodejs/node_osrm_support.hpp
+++ b/include/nodejs/node_osrm_support.hpp
@ -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();
    }

--- a/include/server/http/header.hpp
+++ b/include/server/http/header.hpp
@ -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()
    {
--- a/include/server/service/base_service.hpp
+++ b/include/server/service/base_service.hpp
@ -5,7 +5,7 @@
 #include "osrm/osrm.hpp"
 #include "util/coordinate.hpp"

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

 #include <string>
 #include <vector>
--- a/include/storage/shared_memory.hpp
+++ b/include/storage/shared_memory.hpp
@ -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);
        }
--- a/include/util/alias.hpp
+++ b/include/util/alias.hpp
@ -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
--- a/include/util/attributes.hpp
+++ b/include/util/attributes.hpp
@ -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
--- a/include/util/cheap_ruler.hpp
+++ b/include/util/cheap_ruler.hpp
@ -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/include/util/concurrent_id_map.hpp
+++ b/include/util/concurrent_id_map.hpp
@ -26,7 +26,7 @@ struct ConcurrentIDMap
    mutable UpgradableMutex mutex;

    ConcurrentIDMap() = default;
-    ConcurrentIDMap(ConcurrentIDMap &&other)
+    ConcurrentIDMap(ConcurrentIDMap &&other) noexcept
    {
        if (this != &other)
        {
@ -36,7 +36,7 @@ struct ConcurrentIDMap
            data = std::move(other.data);
        }
    }
-    ConcurrentIDMap &operator=(ConcurrentIDMap &&other)
+    ConcurrentIDMap &operator=(ConcurrentIDMap &&other) noexcept
    {
        if (this != &other)
        {
--- a/include/util/coordinate_calculation.hpp
+++ b/include/util/coordinate_calculation.hpp
@ -3,7 +3,7 @@

 #include "util/coordinate.hpp"

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

 #include <algorithm>
 #include <cmath>
@ -23,17 +23,9 @@ const constexpr double RAD_TO_DEGREE = 1. / DEGREE_TO_RAD;
 // The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
 const constexpr long double EARTH_RADIUS = 6372797.560856;

-inline double degToRad(const double degree)
-{
-    using namespace boost::math::constants;
-    return degree * (pi<double>() / 180.0);
-}
+inline double degToRad(const double degree) { return degree * (std::numbers::pi / 180.0); }

-inline double radToDeg(const double radian)
-{
-    using namespace boost::math::constants;
-    return radian * (180.0 * (1. / pi<double>()));
-}
+inline double radToDeg(const double radian) { return radian * (180.0 * std::numbers::inv_pi); }
 } // namespace detail

 const constexpr static double METERS_PER_DEGREE_LAT = 110567.0;
--- a/include/util/deallocating_vector.hpp
+++ b/include/util/deallocating_vector.hpp
@ -166,7 +166,7 @@ class DeallocatingVectorIterator

 template <typename ElementT> class DeallocatingVector;

-template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T> &rhs);
+template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T> &rhs) noexcept;

 template <typename ElementT> class DeallocatingVector
 {
@ -204,8 +204,8 @@ template <typename ElementT> class DeallocatingVector
    }

    // moving is fine
-    DeallocatingVector(DeallocatingVector &&other) { swap(other); }
-    DeallocatingVector &operator=(DeallocatingVector &&other)
+    DeallocatingVector(DeallocatingVector &&other) noexcept { swap(other); }
+    DeallocatingVector &operator=(DeallocatingVector &&other) noexcept
    {
        swap(other);
        return *this;
@ -221,9 +221,10 @@ template <typename ElementT> class DeallocatingVector

    ~DeallocatingVector() { clear(); }

-    friend void swap<>(DeallocatingVector<ElementT> &lhs, DeallocatingVector<ElementT> &rhs);
+    friend void swap<>(DeallocatingVector<ElementT> &lhs,
+                       DeallocatingVector<ElementT> &rhs) noexcept;

-    void swap(DeallocatingVector<ElementT> &other)
+    void swap(DeallocatingVector<ElementT> &other) noexcept
    {
        std::swap(current_size, other.current_size);
        bucket_list.swap(other.bucket_list);
@ -342,7 +343,7 @@ template <typename ElementT> class DeallocatingVector
    }
 };

-template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T> &rhs)
+template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T> &rhs) noexcept
 {
    lhs.swap(rhs);
 }
--- a/include/util/debug.hpp
+++ b/include/util/debug.hpp
@ -12,7 +12,7 @@
 #include "util/typedefs.hpp"

 #include <iomanip>
-#include <iostream>
+#include <ostream>
 #include <sstream>
 #include <string>
 #include <vector>
--- a/include/util/dynamic_graph.hpp
+++ b/include/util/dynamic_graph.hpp
@ -154,7 +154,7 @@ template <typename EdgeDataT> class DynamicGraph
        return *this;
    }

-    DynamicGraph(DynamicGraph &&other)
+    DynamicGraph(DynamicGraph &&other) noexcept
    {
        number_of_nodes = other.number_of_nodes;
        // atomics can't be moved this is why we need an own constructor
@ -164,7 +164,7 @@ template <typename EdgeDataT> class DynamicGraph
        edge_list = std::move(other.edge_list);
    }

-    DynamicGraph &operator=(DynamicGraph &&other)
+    DynamicGraph &operator=(DynamicGraph &&other) noexcept
    {
        number_of_nodes = other.number_of_nodes;
        // atomics can't be moved this is why we need an own constructor
--- a/include/util/exception.hpp
+++ b/include/util/exception.hpp
@ -30,7 +30,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <array>
 #include <exception>
-#include <iostream>
 #include <string>
 #include <utility>

--- a/include/util/exception_utils.hpp
+++ b/include/util/exception_utils.hpp
@ -1,6 +1,8 @@
-#ifndef SOURCE_MACROS_HPP
-#define SOURCE_MACROS_HPP
+#ifndef EXCEPTION_UTILS_HPP
+#define EXCEPTION_UTILS_HPP
+
 #include <cstring>
+#include <string>

 // Helper macros, don't use these ones
 // STRIP the OSRM_PROJECT_DIR from the front of a filename.  Expected to come
@ -12,4 +14,4 @@
 // This is the macro to use
 #define SOURCE_REF (OSRM_SOURCE_FILE_ + ":" + std::to_string(__LINE__))

-#endif // SOURCE_MACROS_HPP
+#endif // EXCEPTION_UTILS_HPP
--- a/include/util/geojson_debug_logger.hpp
+++ b/include/util/geojson_debug_logger.hpp
@ -51,7 +51,7 @@ class GeojsonLogger
            if (!first)
                ofs << ",\n\t\t";

-            util::json::render(ofs, object.get<util::json::Object>());
+            util::json::render(ofs, std::get<util::json::Object>(object));

            first = false;
        }
--- a/include/util/geojson_debug_policies.hpp
+++ b/include/util/geojson_debug_policies.hpp
@ -51,4 +51,4 @@ struct CoordinateVectorToMultiPoint

 } // namespace osrm::util

-#endif /* OSRM_GEOJSON_DEBUG_POLICIES */
+#endif /* OSRM_GEOJSON_DEBUG_POLICIES */
--- a/include/util/geojson_debug_policy_toolkit.hpp
+++ b/include/util/geojson_debug_policy_toolkit.hpp
@ -55,12 +55,12 @@ inline util::json::Object makeStyle(const GeojsonStyleSize size_type,

 struct CoordinateToJsonArray
 {
-    util::json::Array operator()(const util::Coordinate coordinate)
+    util::json::Value operator()(const util::Coordinate coordinate)
    {
        util::json::Array json_coordinate;
        json_coordinate.values.push_back(static_cast<double>(toFloating(coordinate.lon)));
        json_coordinate.values.push_back(static_cast<double>(toFloating(coordinate.lat)));
-        return json_coordinate;
+        return util::json::Value{json_coordinate};
    }
 };

@ -73,7 +73,7 @@ struct NodeIdToCoordinate

    const std::vector<util::Coordinate> &node_coordinates;

-    util::json::Array operator()(const NodeID nid)
+    util::json::Value operator()(const NodeID nid)
    {
        auto coordinate = node_coordinates[nid];
        CoordinateToJsonArray converter;
@ -108,4 +108,4 @@ inline util::json::Array makeJsonArray(const std::vector<util::Coordinate> &inpu
 }
 } // namespace osrm::util

-#endif /* OSRM_GEOJSON_DEBUG_POLICY_TOOLKIT_HPP */
+#endif /* OSRM_GEOJSON_DEBUG_POLICY_TOOLKIT_HPP */
--- a/include/util/guidance/name_announcements.hpp
+++ b/include/util/guidance/name_announcements.hpp
@ -6,7 +6,6 @@
 #include "extractor/name_table.hpp"
 #include "extractor/suffix_table.hpp"

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

 #include <algorithm>
@ -15,9 +14,6 @@
 #include <utility>
 #include <vector>

-#include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-
 namespace osrm::util::guidance
 {
 // Name Change Logic
@ -128,8 +124,7 @@ inline bool requiresNameAnnounced(const StringView &from_name,

    // check similarity of names
    const auto names_are_empty = from_name.empty() && to_name.empty();
-    const auto name_is_contained =
-        boost::starts_with(from_name, to_name) || boost::starts_with(to_name, from_name);
+    const auto name_is_contained = from_name.starts_with(to_name) || to_name.starts_with(from_name);

    const auto checkForPrefixOrSuffixChange = [](const std::string_view first,
                                                 const std::string_view second,
--- a/include/util/json_container.hpp
+++ b/include/util/json_container.hpp
@ -31,11 +31,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef JSON_CONTAINER_HPP
 #define JSON_CONTAINER_HPP

-#include <mapbox/variant.hpp>
-
 #include <string>
 #include <unordered_map>
 #include <utility>
+#include <variant>
 #include <vector>

 namespace osrm::util::json
@ -96,13 +95,7 @@ struct Null
 *
 * Dispatch on its type by either by using apply_visitor or its get function.
 */
-using Value = mapbox::util::variant<String,
-                                    Number,
-                                    mapbox::util::recursive_wrapper<Object>,
-                                    mapbox::util::recursive_wrapper<Array>,
-                                    True,
-                                    False,
-                                    Null>;
+using Value = std::variant<String, Number, Object, Array, True, False, Null>;

 /**
 * Typed Object.
--- a/include/util/json_deep_compare.hpp
+++ b/include/util/json_deep_compare.hpp
@ -81,10 +81,10 @@ struct Comparator

            const auto &rhs_child = rhs.values.find(key)->second;
            const auto &lhs_child = lhs.values.find(key)->second;
-            auto is_same = mapbox::util::apply_visitor(
-                Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
-                lhs_child,
-                rhs_child);
+            auto is_same =
+                std::visit(Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
+                           lhs_child,
+                           rhs_child);
            if (!is_same)
            {
                return false;
@ -104,12 +104,11 @@ struct Comparator

        for (auto i = 0UL; i < lhs.values.size(); ++i)
        {
-            auto is_same =
-                mapbox::util::apply_visitor(Comparator(reason,
-                                                       lhs_path + "[" + std::to_string(i) + "]",
-                                                       rhs_path + "[" + std::to_string(i) + "]"),
-                                            lhs.values[i],
-                                            rhs.values[i]);
+            auto is_same = std::visit(Comparator(reason,
+                                                 lhs_path + "[" + std::to_string(i) + "]",
+                                                 rhs_path + "[" + std::to_string(i) + "]"),
+                                      lhs.values[i],
+                                      rhs.values[i]);
            if (!is_same)
            {
                return false;
@ -151,8 +150,7 @@ struct Comparator

 inline bool compare(const Value &reference, const Value &result, std::string &reason)
 {
-    return mapbox::util::apply_visitor(
-        Comparator(reason, "reference", "result"), reference, result);
+    return std::visit(Comparator(reason, "reference", "result"), reference, result);
 }
 } // namespace osrm::util::json

--- a/include/util/json_renderer.hpp
+++ b/include/util/json_renderer.hpp
@ -67,7 +67,7 @@ template <typename Out> struct Renderer
            write('\"');
            write(it->first);
            write<>("\":");
-            mapbox::util::apply_visitor(Renderer(out), it->second);
+            std::visit(Renderer(out), it->second);
            if (++it != end)
            {
                write(',');
@ -81,7 +81,7 @@ template <typename Out> struct Renderer
        write('[');
        for (auto it = array.values.cbegin(), end = array.values.cend(); it != end;)
        {
-            mapbox::util::apply_visitor(Renderer(out), *it);
+            std::visit(Renderer(out), *it);
            if (++it != end)
            {
                write(',');
--- a/include/util/lua_util.hpp
+++ b/include/util/lua_util.hpp
@ -9,7 +9,7 @@ extern "C"
 }

 #include <filesystem>
-#include <iostream>
+
 #include <string>

 namespace osrm::util
--- a/include/util/matrix_graph_wrapper.hpp
+++ b/include/util/matrix_graph_wrapper.hpp
@ -1,49 +0,0 @@
-#ifndef MATRIX_GRAPH_WRAPPER_H
-#define MATRIX_GRAPH_WRAPPER_H
-
-#include <cstddef>
-#include <iterator>
-#include <vector>
-
-#include "util/typedefs.hpp"
-
-namespace osrm::util
-{
-
-// This Wrapper provides all methods that are needed for util::TarjanSCC, when the graph is
-// given in a matrix representation (e.g. as output from a distance table call)
-
-template <typename T> class MatrixGraphWrapper
-{
-  public:
-    MatrixGraphWrapper(std::vector<T> table, const std::size_t number_of_nodes)
-        : table_(std::move(table)), number_of_nodes_(number_of_nodes)
-    {
-    }
-
-    std::size_t GetNumberOfNodes() const { return number_of_nodes_; }
-
-    std::vector<T> GetAdjacentEdgeRange(const NodeID node) const
-    {
-
-        std::vector<T> edges;
-        // find all valid adjacent edges and move to vector `edges`
-        for (std::size_t i = 0; i < number_of_nodes_; ++i)
-        {
-            if (*(std::begin(table_) + node * number_of_nodes_ + i) != INVALID_EDGE_WEIGHT)
-            {
-                edges.push_back(i);
-            }
-        }
-        return edges;
-    }
-
-    EdgeWeight GetTarget(const EdgeWeight edge) const { return edge; }
-
-  private:
-    const std::vector<T> table_;
-    const std::size_t number_of_nodes_;
-};
-} // namespace osrm::util
-
-#endif // MATRIX_GRAPH_WRAPPER_H
--- a/include/util/node_based_graph.hpp
+++ b/include/util/node_based_graph.hpp
@ -9,7 +9,6 @@

 #include <tbb/parallel_sort.h>

-#include <iostream>
 #include <memory>
 #include <utility>

--- a/include/util/packed_vector.hpp
+++ b/include/util/packed_vector.hpp
@ -153,8 +153,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
    // number of words per block
    static constexpr std::size_t BLOCK_WORDS = (Bits * BLOCK_ELEMENTS) / WORD_BITS;

-    // C++14 does not allow operator[] to be constexpr, this is fixed in C++17.
-    static /* constexpr */ std::array<WordT, BLOCK_ELEMENTS> initialize_lower_mask()
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> initialize_lower_mask()
    {
        std::array<WordT, BLOCK_ELEMENTS> lower_mask;

@ -170,7 +169,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
        return lower_mask;
    }

-    static /* constexpr */ std::array<WordT, BLOCK_ELEMENTS> initialize_upper_mask()
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> initialize_upper_mask()
    {
        std::array<WordT, BLOCK_ELEMENTS> upper_mask;

@ -194,7 +193,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
        return upper_mask;
    }

-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_lower_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_lower_offset()
    {
        std::array<std::uint8_t, WORD_BITS> lower_offset;

@ -209,7 +208,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
        return lower_offset;
    }

-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_upper_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_upper_offset()
    {
        std::array<std::uint8_t, BLOCK_ELEMENTS> upper_offset;

@ -232,7 +231,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
        return upper_offset;
    }

-    static /* constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_word_offset()
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> initialize_word_offset()
    {
        std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset;

@ -246,28 +245,15 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
        return word_offset;
    }

-    // For now we need to call these on object creation
-    void initialize()
-    {
-        lower_mask = initialize_lower_mask();
-        upper_mask = initialize_upper_mask();
-        lower_offset = initialize_lower_offset();
-        upper_offset = initialize_upper_offset();
-        word_offset = initialize_word_offset();
-    }
-
    // mask for the lower/upper word of a record
-    // TODO: With C++17 these could be constexpr
-    /* static constexpr */ std::array<WordT, BLOCK_ELEMENTS>
-        lower_mask /* = initialize_lower_mask()*/;
-    /* static constexpr */ std::array<WordT, BLOCK_ELEMENTS>
-        upper_mask /* = initialize_upper_mask()*/;
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS>
-        lower_offset /* = initialize_lower_offset()*/;
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS>
-        upper_offset /* = initialize_upper_offset()*/;
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> lower_mask = initialize_lower_mask();
+    static constexpr std::array<WordT, BLOCK_ELEMENTS> upper_mask = initialize_upper_mask();
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> lower_offset =
+        initialize_lower_offset();
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> upper_offset =
+        initialize_upper_offset();
    // in which word of the block is the element
-    /* static constexpr */ std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset =
+    static constexpr std::array<std::uint8_t, BLOCK_ELEMENTS> word_offset =
        initialize_word_offset();

    struct InternalIndex
@ -378,27 +364,21 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack

    PackedVector(std::initializer_list<T> list)
    {
-        initialize();
        reserve(list.size());
        for (const auto value : list)
            push_back(value);
    }

-    PackedVector() { initialize(); };
+    PackedVector(){};
    PackedVector(const PackedVector &) = default;
    PackedVector(PackedVector &&) = default;
    PackedVector &operator=(const PackedVector &) = default;
    PackedVector &operator=(PackedVector &&) = default;

-    PackedVector(std::size_t size)
-    {
-        initialize();
-        resize(size);
-    }
+    PackedVector(std::size_t size) { resize(size); }

    PackedVector(std::size_t size, T initial_value)
    {
-        initialize();
        resize(size);
        fill(initial_value);
    }
@ -406,7 +386,6 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
    PackedVector(util::ViewOrVector<WordT, Ownership> vec_, std::size_t num_elements)
        : vec(std::move(vec_)), num_elements(num_elements)
    {
-        initialize();
    }

    // forces the efficient read-only lookup
--- a/include/util/permutation.hpp
+++ b/include/util/permutation.hpp
@ -10,9 +10,9 @@ namespace osrm::util

 namespace permutation_detail
 {
-template <typename T> static inline void swap(T &a, T &b) { std::swap(a, b); }
+template <typename T> static inline void swap(T &a, T &b) noexcept { std::swap(a, b); }

-static inline void swap(std::vector<bool>::reference a, std::vector<bool>::reference b)
+static inline void swap(std::vector<bool>::reference a, std::vector<bool>::reference b) noexcept
 {
    std::vector<bool>::swap(a, b);
 }
--- a/include/util/query_heap.hpp
+++ b/include/util/query_heap.hpp
@ -193,7 +193,20 @@ template <typename NodeID,
 class QueryHeap
 {
  private:
-    using HeapData = std::pair<Weight, Key>;
+    struct HeapData
+    {
+        Weight weight;
+        Key index;
+
+        bool operator>(const HeapData &other) const
+        {
+            if (weight == other.weight)
+            {
+                return index > other.index;
+            }
+            return weight > other.weight;
+        }
+    };
    using HeapContainer = boost::heap::d_ary_heap<HeapData,
                                                  boost::heap::arity<4>,
                                                  boost::heap::mutable_<true>,
@ -232,7 +245,7 @@ class QueryHeap
    {
        BOOST_ASSERT(node < std::numeric_limits<NodeID>::max());
        const auto index = static_cast<Key>(inserted_nodes.size());
-        const auto handle = heap.push(std::make_pair(weight, index));
+        const auto handle = heap.emplace(HeapData{weight, index});
        inserted_nodes.emplace_back(HeapNode{handle, node, weight, data});
        node_index[node] = index;
    }
@ -315,19 +328,19 @@ class QueryHeap
    NodeID Min() const
    {
        BOOST_ASSERT(!heap.empty());
-        return inserted_nodes[heap.top().second].node;
+        return inserted_nodes[heap.top().index].node;
    }

    Weight MinKey() const
    {
        BOOST_ASSERT(!heap.empty());
-        return heap.top().first;
+        return heap.top().weight;
    }

    NodeID DeleteMin()
    {
        BOOST_ASSERT(!heap.empty());
-        const Key removedIndex = heap.top().second;
+        const Key removedIndex = heap.top().index;
        heap.pop();
        inserted_nodes[removedIndex].handle = heap.s_handle_from_iterator(heap.end());
        return inserted_nodes[removedIndex].node;
@ -336,7 +349,7 @@ class QueryHeap
    HeapNode &DeleteMinGetHeapNode()
    {
        BOOST_ASSERT(!heap.empty());
-        const Key removedIndex = heap.top().second;
+        const Key removedIndex = heap.top().index;
        heap.pop();
        inserted_nodes[removedIndex].handle = heap.s_handle_from_iterator(heap.end());
        return inserted_nodes[removedIndex];
@ -357,13 +370,13 @@ class QueryHeap
        const auto index = node_index.peek_index(node);
        auto &reference = inserted_nodes[index];
        reference.weight = weight;
-        heap.increase(reference.handle, std::make_pair(weight, index));
+        heap.increase(reference.handle, HeapData{weight, static_cast<Key>(index)});
    }

    void DecreaseKey(const HeapNode &heapNode)
    {
        BOOST_ASSERT(!WasRemoved(heapNode.node));
-        heap.increase(heapNode.handle, std::make_pair(heapNode.weight, (*heapNode.handle).second));
+        heap.increase(heapNode.handle, HeapData{heapNode.weight, (*heapNode.handle).index});
    }

  private:
--- a/include/util/static_assert.hpp
+++ b/include/util/static_assert.hpp
@ -1,6 +1,7 @@
 #ifndef OSRM_STATIC_ASSERT_HPP
 #define OSRM_STATIC_ASSERT_HPP

+#include <iterator>
 #include <type_traits>

 namespace osrm::util
@ -8,14 +9,13 @@ namespace osrm::util

 template <typename It, typename Value> inline void static_assert_iter_value()
 {
-    using IterValueType = typename std::iterator_traits<It>::value_type;
-    static_assert(std::is_same<IterValueType, Value>::value, "");
+    static_assert(std::is_same_v<std::iter_value_t<It>, Value>, "");
 }

 template <typename It, typename Category> inline void static_assert_iter_category()
 {
    using IterCategoryType = typename std::iterator_traits<It>::iterator_category;
-    static_assert(std::is_base_of<Category, IterCategoryType>::value, "");
+    static_assert(std::is_base_of_v<Category, IterCategoryType>, "");
 }

 } // namespace osrm::util
--- a/include/util/string_util.hpp
+++ b/include/util/string_util.hpp
@ -1,8 +1,9 @@
 #ifndef STRING_UTIL_HPP
 #define STRING_UTIL_HPP

+#include <array>
 #include <cctype>
-
+#include <cstddef>
 #include <random>
 #include <string>
 #include <vector>
@ -10,73 +11,30 @@
 namespace osrm::util
 {

-// precision:  position after decimal point
-// length: maximum number of digits including comma and decimals
-// work with negative values to prevent overflowing when taking -value
-template <int length, int precision> char *printInt(char *buffer, int value)
+// implements Lemire's table-based escape needs check
+// cf. https://lemire.me/blog/2024/05/31/quickly-checking-whether-a-string-needs-escaping/
+inline static constexpr std::array<uint8_t, 256> json_quotable_character = []() constexpr
 {
-    static_assert(length > 0, "length must be positive");
-    static_assert(precision > 0, "precision must be positive");
-
-    const bool minus = [&value]
+    std::array<uint8_t, 256> result{};
+    for (auto i = 0; i < 32; i++)
    {
-        if (value >= 0)
-        {
-            value = -value;
-            return false;
-        }
-        return true;
-    }();
-
-    buffer += length - 1;
-    for (int i = 0; i < precision; ++i)
-    {
-        *buffer = '0' - (value % 10);
-        value /= 10;
-        --buffer;
+        result[i] = 1;
    }
-    *buffer = '.';
-    --buffer;
-
-    for (int i = precision + 1; i < length; ++i)
+    for (auto i : {'"', '\\'})
    {
-        *buffer = '0' - (value % 10);
-        value /= 10;
-        if (value == 0)
-        {
-            break;
-        }
-        --buffer;
+        result[i] = 1;
    }
-
-    if (minus)
-    {
-        --buffer;
-        *buffer = '-';
-    }
-    return buffer;
-}
+    return result;
+}();

 inline bool RequiresJSONStringEscaping(const std::string &string)
 {
-    for (const char letter : string)
+    uint8_t needs = 0;
+    for (uint8_t c : string)
    {
-        switch (letter)
-        {
-        case '\\':
-        case '"':
-        case '/':
-        case '\b':
-        case '\f':
-        case '\n':
-        case '\r':
-        case '\t':
-            return true;
-        default:
-            continue;
-        }
+        needs |= json_quotable_character[c];
    }
-    return false;
+    return needs;
 }

 inline void EscapeJSONString(const std::string &input, std::string &output)
--- a/include/util/trigonometry_table.hpp
+++ b/include/util/trigonometry_table.hpp
@ -6,7 +6,7 @@

 #include <limits>

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

 namespace osrm::util
 {
@ -356,25 +356,21 @@ constexpr unsigned short atan_table[4096] = {
    0xffe0, 0xffea, 0xfff4, 0xffff};

 // max value is pi/4
-#ifdef _MSC_VER // TODO: remove as soon as boost allows C++14 features with Visual Studio
-const constexpr double SCALING_FACTOR = 4. / M_PI * 0xFFFF;
-#else
-const constexpr double SCALING_FACTOR = 4. / boost::math::constants::pi<double>() * 0xFFFF;
-#endif
+const constexpr double SCALING_FACTOR = 4. * std::numbers::inv_pi * 0xFFFF;

 inline double atan2_lookup(double y, double x)
 {
-    using namespace boost::math::constants;
+    static constexpr auto half_pi = std::numbers::pi * 0.5;

    if (std::abs(x) < std::numeric_limits<double>::epsilon())
    {
        if (y >= 0.)
        {
-            return half_pi<double>();
+            return half_pi;
        }
        else
        {
-            return -half_pi<double>();
+            return -half_pi;
        }
    }

@ -405,25 +401,25 @@ inline double atan2_lookup(double y, double x)
    case 0:
        break;
    case 1:
-        angle = pi<double>() - angle;
+        angle = std::numbers::pi - angle;
        break;
    case 2:
        angle = -angle;
        break;
    case 3:
-        angle = -pi<double>() + angle;
+        angle = -std::numbers::pi + angle;
        break;
    case 4:
-        angle = half_pi<double>() - angle;
+        angle = half_pi - angle;
        break;
    case 5:
-        angle = half_pi<double>() + angle;
+        angle = half_pi + angle;
        break;
    case 6:
-        angle = -half_pi<double>() + angle;
+        angle = -half_pi + angle;
        break;
    case 7:
-        angle = -half_pi<double>() - angle;
+        angle = -half_pi - angle;
        break;
    }
    return angle;
--- a/include/util/web_mercator.hpp
+++ b/include/util/web_mercator.hpp
@ -3,7 +3,7 @@

 #include "util/coordinate.hpp"

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

 namespace osrm::util::web_mercator
 {
@ -14,7 +14,7 @@ const constexpr double RAD_TO_DEGREE = 1. / DEGREE_TO_RAD;
 // radius used by WGS84
 const constexpr double EARTH_RADIUS_WGS84 = 6378137.0;
 // earth circumference devided by 2
-const constexpr double MAXEXTENT = EARTH_RADIUS_WGS84 * boost::math::constants::pi<double>();
+const constexpr double MAXEXTENT = EARTH_RADIUS_WGS84 * std::numbers::pi;
 // ^ math functions are not constexpr since they have side-effects (setting errno) :(
 const constexpr double EPSG3857_MAX_LATITUDE = 85.051128779806592378; // 90(4*atan(exp(pi))/pi-1)
 const constexpr double MAX_LONGITUDE = 180.0;
@ -103,8 +103,8 @@ inline void pixelToDegree(const double shift, double &x, double &y)
    const double b = shift / 2.0;
    x = (x - b) / shift * 360.0;
    // FIXME needs to be simplified
-    const double g = (y - b) / -(shift / (2 * M_PI)) / detail::DEGREE_TO_RAD;
-    static_assert(detail::DEGREE_TO_RAD / (2 * M_PI) - 1 / 360. < 0.0001, "");
+    const double g = (y - b) / -(shift * 0.5 * std::numbers::inv_pi) / detail::DEGREE_TO_RAD;
+    static_assert(detail::DEGREE_TO_RAD * 0.5 * std::numbers::inv_pi - 1 / 360. < 0.0001, "");
    y = static_cast<double>(yToLat(g));
 }

--- a/scripts/ci/download_gps_traces.py
+++ b/scripts/ci/download_gps_traces.py
@ -0,0 +1,91 @@
+import requests
+import xml.etree.ElementTree as ET
+import csv
+import sys
+import argparse
+
+def get_osm_gps_traces(min_lon, min_lat, max_lon, max_lat):
+    url = 'https://api.openstreetmap.org/api/0.6/trackpoints'
+    traces = []
+    
+    lon_step = 0.25
+    lat_step = 0.25
+    
+    current_min_lon = min_lon
+
+    while current_min_lon < max_lon:
+        current_max_lon = min(current_min_lon + lon_step, max_lon)
+        
+        current_min_lat = min_lat
+        while current_min_lat < max_lat:
+            current_max_lat = min(current_min_lat + lat_step, max_lat)
+            
+            bbox = f'{current_min_lon},{current_min_lat},{current_max_lon},{current_max_lat}'
+            print(f"Requesting bbox: {bbox}", file=sys.stderr)
+            
+            params = {
+                'bbox': bbox,
+                'page': 0
+            }
+            headers = {
+                'Accept': 'application/xml'
+            }
+            
+            response = requests.get(url, params=params, headers=headers)
+            if response.status_code == 200:
+                traces.append(response.content)
+            else:
+                print(f"Error fetching data for bbox {bbox}: {response.status_code} {response.text}", file=sys.stderr)
+            
+            current_min_lat += lat_step
+        current_min_lon += lon_step
+    
+    return traces
+
+def parse_gpx_data(gpx_data):
+    try:
+        root = ET.fromstring(gpx_data)
+    except ET.ParseError as e:
+        print(f"Error parsing GPX data: {e}", file=sys.stderr)
+        return []
+    namespace = {'gpx': 'http://www.topografix.com/GPX/1/0'}
+
+    tracks = []
+    for trk in root.findall('.//gpx:trk', namespace):
+        track_data = []
+        for trkseg in trk.findall('.//gpx:trkseg', namespace):
+            for trkpt in trkseg.findall('gpx:trkpt', namespace):
+                lat = trkpt.get('lat')
+                lon = trkpt.get('lon')
+                time = trkpt.find('time').text if trkpt.find('time') is not None else ''
+                track_data.append([lat, lon, time])
+        tracks.append(track_data)
+    return tracks
+
+def save_to_csv(data, file):
+    writer = csv.writer(file)
+    writer.writerow(['TrackID', 'Latitude', 'Longitude', 'Time'])
+    writer.writerows(data)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Fetch and output OSM GPS traces for a given bounding box.')
+    parser.add_argument('min_lon', type=float, help='Minimum longitude of the bounding box')
+    parser.add_argument('min_lat', type=float, help='Minimum latitude of the bounding box')
+    parser.add_argument('max_lon', type=float, help='Maximum longitude of the bounding box')
+    parser.add_argument('max_lat', type=float, help='Maximum latitude of the bounding box')
+    
+    args = parser.parse_args()
+    
+    gpx_data_traces = get_osm_gps_traces(args.min_lon, args.min_lat, args.max_lon, args.max_lat)
+    print(f"Collected {len(gpx_data_traces)} trace segments", file=sys.stderr)
+
+    all_data = []
+    track_id = 0
+    for gpx_data in gpx_data_traces:
+        for track in parse_gpx_data(gpx_data):
+            for point in track:
+                all_data.append([track_id] + point)
+            track_id += 1
+    
+    # Output all data to stdout
+    save_to_csv(all_data, sys.stdout)
--- a/scripts/ci/e2e_benchmark.py
+++ b/scripts/ci/e2e_benchmark.py
@ -0,0 +1,102 @@
+import requests
+import sys
+import random
+from collections import defaultdict
+import os
+import csv
+import numpy as np
+import time
+import argparse
+
+class BenchmarkRunner:
+    def __init__(self):
+        self.coordinates = []
+        self.tracks = defaultdict(list)
+
+        gps_traces_file_path = os.path.expanduser('~/gps_traces.csv')
+        with open(gps_traces_file_path, 'r') as file:
+            reader = csv.DictReader(file)
+            for row in reader:
+                coord = (float(row['Latitude']), float(row['Longitude']))
+                self.coordinates.append(coord)
+                self.tracks[row['TrackID']].append(coord)
+        self.track_ids = list(self.tracks.keys())
+    
+    def run(self, benchmark_name, host, num_requests, warmup_requests=50):
+        for _ in range(warmup_requests):
+            url = self.make_url(host, benchmark_name)
+            _ = requests.get(url)
+    
+        times = []
+
+        for _ in range(num_requests):
+            url = self.make_url(host, benchmark_name)
+
+            start_time = time.time()
+            response = requests.get(url)
+            end_time = time.time()
+            if response.status_code != 200:
+                if benchmark_name == 'match':
+                    code = response.json()['code']
+                    if code == 'NoSegment' or code == 'NoMatch':
+                        continue
+                raise Exception(f"Error: {response.status_code} {response.text}")
+            times.append((end_time - start_time) * 1000) # convert to ms
+        
+        return times
+    
+    def make_url(self, host, benchmark_name): 
+        if benchmark_name == 'route':
+            start = random.choice(self.coordinates)
+            end = random.choice(self.coordinates)
+            
+            start_coord = f"{start[1]:.6f},{start[0]:.6f}"
+            end_coord = f"{end[1]:.6f},{end[0]:.6f}"
+            return f"{host}/route/v1/driving/{start_coord};{end_coord}?overview=full&steps=true"
+        elif benchmark_name == 'table':
+            num_coords = random.randint(3, 100)
+            selected_coords = random.sample(self.coordinates, num_coords)
+            coords_str = ";".join([f"{coord[1]:.6f},{coord[0]:.6f}" for coord in selected_coords])
+            return f"{host}/table/v1/driving/{coords_str}"
+        elif benchmark_name == 'match':
+            num_coords = random.randint(50, 100)
+            track_id = random.choice(self.track_ids)
+            track_coords = self.tracks[track_id][:num_coords]
+            coords_str = ";".join([f"{coord[1]:.6f},{coord[0]:.6f}" for coord in track_coords])
+            radiues_str = ";".join([f"{random.randint(5, 20)}" for _ in range(len(track_coords))])
+            return f"{host}/match/v1/driving/{coords_str}?steps=true&radiuses={radiues_str}"
+        elif benchmark_name == 'nearest':
+            coord = random.choice(self.coordinates)
+            coord_str = f"{coord[1]:.6f},{coord[0]:.6f}"
+            return f"{host}/nearest/v1/driving/{coord_str}"
+        elif benchmark_name == 'trip':
+            num_coords = random.randint(2, 10)
+            selected_coords = random.sample(self.coordinates, num_coords)
+            coords_str = ";".join([f"{coord[1]:.6f},{coord[0]:.6f}" for coord in selected_coords])
+            return f"{host}/trip/v1/driving/{coords_str}?steps=true"
+        else:
+            raise Exception(f"Unknown benchmark: {benchmark_name}")
+
+def main():
+    parser = argparse.ArgumentParser(description='Run GPS benchmark tests.')
+    parser.add_argument('--host', type=str, required=True, help='Host URL')
+    parser.add_argument('--method', type=str, required=True, choices=['route', 'table', 'match', 'nearest', 'trip'], help='Benchmark method')
+    parser.add_argument('--num_requests', type=int, required=True, help='Number of requests to perform')
+
+    args = parser.parse_args()
+
+    random.seed(42)
+
+    runner = BenchmarkRunner()
+    times = runner.run(args.method, args.host, args.num_requests)
+
+    print(f'Total: {np.sum(times)}ms')
+    print(f"Min time: {np.min(times)}ms")
+    print(f"Mean time: {np.mean(times)}ms")
+    print(f"Median time: {np.median(times)}ms")
+    print(f"95th percentile: {np.percentile(times, 95)}ms")
+    print(f"99th percentile: {np.percentile(times, 99)}ms")
+    print(f"Max time: {np.max(times)}ms")
+
+if __name__ == '__main__':
+    main()
--- a/scripts/ci/post_benchmark_results.py
+++ b/scripts/ci/post_benchmark_results.py
@ -16,8 +16,10 @@ def create_markdown_table(results):
    rows = []
    for result in results:
        name = result['name']
-        base = result['base'].replace('\n', '<br/>')
-        pr = result['pr'].replace('\n', '<br/>')
+        base = result['base'] or ''
+        base = base.replace('\n', '<br/>')
+        pr = result['pr'] or ''
+        pr = pr.replace('\n', '<br/>')
        row = f"| {name} | {base} | {pr} |"
        rows.append(row)
    return f"{header}\n" + "\n".join(rows)
@ -75,7 +77,14 @@ def main():
    pr_body = pr_details.get('body', '') or ''

    markdown_table = create_markdown_table(benchmark_results)
-    new_benchmark_section = f"<!-- BENCHMARK_RESULTS_START -->\n## Benchmark Results\n{markdown_table}\n<!-- BENCHMARK_RESULTS_END -->"
+    new_benchmark_section = f"""
+<!-- BENCHMARK_RESULTS_START -->
+<details><summary><h2>Benchmark Results</h2></summary>
+
+{markdown_table}
+</details>
+<!-- BENCHMARK_RESULTS_END -->
+"""

    if re.search(r'<!-- BENCHMARK_RESULTS_START -->.*<!-- BENCHMARK_RESULTS_END -->', pr_body, re.DOTALL):
        updated_body = re.sub(
--- a/scripts/ci/run_benchmarks.sh
+++ b/scripts/ci/run_benchmarks.sh
@ -1,11 +1,24 @@
 #!/bin/bash
 set -eou pipefail

+function measure_peak_ram_and_time {
+    COMMAND=$1
+    OUTPUT_FILE=$2
+
+    OUTPUT=$(/usr/bin/time -f "%e %M" $COMMAND 2>&1 | tail -n 1)
+
+    TIME=$(echo $OUTPUT | awk '{print $1}')
+    PEAK_RAM_KB=$(echo $OUTPUT | awk '{print $2}')
+    PEAK_RAM_MB=$(echo "scale=2; $PEAK_RAM_KB / 1024" | bc)
+    echo "Time: ${TIME}s Peak RAM: ${PEAK_RAM_MB}MB" > $OUTPUT_FILE
+}
+
 function run_benchmarks_for_folder {
    echo "Running benchmarks for $1"

    FOLDER=$1
    RESULTS_FOLDER=$2
+    SCRIPTS_FOLDER=$3

    mkdir -p $RESULTS_FOLDER

@ -13,14 +26,43 @@ function run_benchmarks_for_folder {

    ./$BENCHMARKS_FOLDER/match-bench "./$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/match_mld.bench"
    ./$BENCHMARKS_FOLDER/match-bench "./$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/match_ch.bench"
-    ./$BENCHMARKS_FOLDER/route-bench "./$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/route_mld.bench" || true # TODO: remove `true` when this benchmark will be merged to master
-    ./$BENCHMARKS_FOLDER/route-bench "./$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/route_ch.bench" || true # TODO: remove `true` when this benchmark will be merged to master
+    ./$BENCHMARKS_FOLDER/route-bench "./$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/route_mld.bench"
+    ./$BENCHMARKS_FOLDER/route-bench "./$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/route_ch.bench"
    ./$BENCHMARKS_FOLDER/alias-bench > "$RESULTS_FOLDER/alias.bench"
    ./$BENCHMARKS_FOLDER/json-render-bench  "./$FOLDER/src/benchmarks/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
    ./$BENCHMARKS_FOLDER/packedvector-bench > "$RESULTS_FOLDER/packedvector.bench"
    ./$BENCHMARKS_FOLDER/rtree-bench "./$FOLDER/test/data/monaco.osrm.ramIndex" "./$FOLDER/test/data/monaco.osrm.fileIndex" "./$FOLDER/test/data/monaco.osrm.nbg_nodes" > "$RESULTS_FOLDER/rtree.bench"
+
+    BINARIES_FOLDER="$FOLDER/build"
+
+    cp ~/data.osm.pbf $FOLDER
+
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-extract -p $FOLDER/profiles/car.lua $FOLDER/data.osm.pbf" "$RESULTS_FOLDER/osrm_extract.bench"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-partition $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_partition.bench"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-customize $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_customize.bench"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-contract $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_contract.bench"
+
+    for ALGORITHM in ch mld; do
+        $BINARIES_FOLDER/osrm-routed --algorithm $ALGORITHM $FOLDER/data.osrm &
+        OSRM_ROUTED_PID=$!
+
+        # wait for osrm-routed to start
+        if ! curl --retry-delay 3 --retry 10 --retry-all-errors "http://127.0.0.1:5000/route/v1/driving/13.388860,52.517037;13.385983,52.496891?steps=true"; then
+            echo "osrm-routed failed to start for algorithm $ALGORITHM"
+            kill -9 $OSRM_ROUTED_PID
+            continue
+        fi
+
+        for METHOD in route nearest trip table match; do
+            python3 $SCRIPTS_FOLDER/scripts/ci/e2e_benchmark.py --host http://localhost:5000 --method $METHOD --num_requests 1000 > $RESULTS_FOLDER/e2e_${METHOD}_${ALGORITHM}.bench
+        done
+
+        kill -9 $OSRM_ROUTED_PID
+    done
+
+
 }

-run_benchmarks_for_folder $1 "${1}_results"
-run_benchmarks_for_folder $2 "${2}_results"
+run_benchmarks_for_folder $1 "${1}_results" $2
+run_benchmarks_for_folder $2 "${2}_results" $2

--- a/scripts/update_dependencies.sh
+++ b/scripts/update_dependencies.sh
@ -12,14 +12,11 @@ set -o nounset
 OSMIUM_PATH="osmcode/libosmium"
 OSMIUM_TAG=v2.14.0

-VARIANT_PATH="mapbox/variant"
-VARIANT_TAG=v1.1.3
-
 SOL_PATH="ThePhD/sol2"
-SOL_TAG=v2.17.5
+SOL_TAG=v3.3.0

 RAPIDJSON_PATH="Tencent/rapidjson"
-RAPIDJSON_TAG=v1.1.0
+RAPIDJSON_TAG=f9d53419e912910fd8fa57d5705fa41425428c35

 MICROTAR_PATH="rxi/microtar"
 MICROTAR_TAG=v0.1.0
@ -34,7 +31,7 @@ FMT_PATH="fmtlib/fmt"
 FMT_TAG=v10.2.1

 function update_subtree () {
-    name=${1^^}
+    name=$(echo "$1" | tr '[:lower:]' '[:upper:]')
    path=$(tmpvar=${name}_PATH && echo ${!tmpvar})
    tag=$(tmpvar=${name}_TAG && echo ${!tmpvar})
    dir=$(basename $path)
@ -56,6 +53,6 @@ function update_subtree () {
 }

 ## Update dependencies
-for dep in osmium variant sol rapidjson microtar protozero vtzero fmt; do
+for dep in osmium sol rapidjson microtar protozero vtzero fmt; do
    update_subtree $dep
 done
--- a/src/benchmarks/alias.cpp
+++ b/src/benchmarks/alias.cpp
@ -5,6 +5,7 @@

 #include <algorithm>
 #include <iomanip>
+#include <iostream>
 #include <numeric>
 #include <random>
 #include <string>
--- a/src/benchmarks/json_render.cpp
+++ b/src/benchmarks/json_render.cpp
@ -86,7 +86,7 @@ json::Object load(const char *filename)

    json::Value result;
    convert(document, result);
-    return result.get<json::Object>();
+    return std::get<json::Object>(result);
 }

 } // namespace
--- a/src/benchmarks/match.cpp
+++ b/src/benchmarks/match.cpp
@ -232,9 +232,9 @@ try
        {
            engine::api::ResultT result = json::Object();
            const auto rc = osrm.Match(params, result);
-            auto &json_result = result.get<json::Object>();
+            auto &json_result = std::get<json::Object>(result);
            if (rc != Status::Ok ||
-                json_result.values.at("matchings").get<json::Array>().values.size() != 1)
+                std::get<json::Array>(json_result.values.at("matchings")).values.size() != 1)
            {
                throw std::runtime_error{"Couldn't match"};
            }
--- a/src/benchmarks/packed_vector.cpp
+++ b/src/benchmarks/packed_vector.cpp
@ -5,6 +5,7 @@

 #include <algorithm>
 #include <iomanip>
+#include <iostream>
 #include <numeric>
 #include <random>
 #include <string>
--- a/src/benchmarks/route.cpp
+++ b/src/benchmarks/route.cpp
@ -76,7 +76,7 @@ try
        {
            engine::api::ResultT result = json::Object();
            const auto rc = osrm.Route(params, result);
-            auto &json_result = result.get<json::Object>();
+            auto &json_result = std::get<json::Object>(result);
            if (rc != Status::Ok || json_result.values.find("routes") == json_result.values.end())
            {
                throw std::runtime_error{"Couldn't route"};
--- a/src/contractor/contractor.cpp
+++ b/src/contractor/contractor.cpp
@ -1,7 +1,6 @@
 #include "contractor/contractor.hpp"
 #include "contractor/contract_excludable_graph.hpp"
 #include "contractor/contracted_edge_container.hpp"
-#include "contractor/crc32_processor.hpp"
 #include "contractor/files.hpp"
 #include "contractor/graph_contractor.hpp"
 #include "contractor/graph_contractor_adaptors.hpp"
--- a/src/engine/api/json_factory.cpp
+++ b/src/engine/api/json_factory.cpp
@ -74,12 +74,12 @@ std::string waypointTypeToString(const guidance::WaypointType waypoint_type)
    return waypoint_type_names[static_cast<std::size_t>(waypoint_type)];
 }

-util::json::Array coordinateToLonLat(const util::Coordinate &coordinate)
+util::json::Value coordinateToLonLat(const util::Coordinate &coordinate)
 {
    util::json::Array array;
    array.values.push_back(static_cast<double>(util::toFloating(coordinate.lon)));
    array.values.push_back(static_cast<double>(util::toFloating(coordinate.lat)));
-    return array;
+    return util::json::Value{std::move(array)};
 }

 } // namespace detail
--- a/src/engine/guidance/collapse_turns.cpp
+++ b/src/engine/guidance/collapse_turns.cpp
@ -433,8 +433,7 @@ void suppressStep(RouteStep &step_at_turn_location, RouteStep &step_after_turn_l
 }

 // OTHER IMPLEMENTATIONS
-OSRM_ATTR_WARN_UNUSED
-RouteSteps collapseTurnInstructions(RouteSteps steps)
+[[nodiscard]] RouteSteps collapseTurnInstructions(RouteSteps steps)
 {
    // make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn)
    BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back()));
@ -589,8 +588,7 @@ RouteSteps collapseTurnInstructions(RouteSteps steps)
 }

 // OTHER IMPLEMENTATIONS
-OSRM_ATTR_WARN_UNUSED
-RouteSteps collapseSegregatedTurnInstructions(RouteSteps steps)
+[[nodiscard]] RouteSteps collapseSegregatedTurnInstructions(RouteSteps steps)
 {
    // make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn)
    BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back()));
--- a/src/engine/guidance/lane_processing.cpp
+++ b/src/engine/guidance/lane_processing.cpp
@ -125,9 +125,9 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,

                if (previous_is_straight)
                {
-                    if (isLeftTurn(current_inst) || is_straight_left.count(&current) > 0)
+                    if (isLeftTurn(current_inst) || is_straight_left.contains(&current))
                        is_straight_left.insert(&previous);
-                    else if (isRightTurn(current_inst) || is_straight_right.count(&current) > 0)
+                    else if (isRightTurn(current_inst) || is_straight_right.contains(&current))
                        is_straight_right.insert(&previous);
                }

@ -190,9 +190,9 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
                    //
                    // coming from right, going to left (in direction of way) -> handle as left turn

-                    if (is_straight_left.count(&current) > 0)
+                    if (is_straight_left.contains(&current))
                        anticipate_for_left_turn();
-                    else if (is_straight_right.count(&current) > 0)
+                    else if (is_straight_right.contains(&current))
                        anticipate_for_right_turn();
                    else // FIXME: right-sided driving
                        anticipate_for_right_turn();
--- a/src/engine/plugins/tile.cpp
+++ b/src/engine/plugins/tile.cpp
@ -497,13 +497,13 @@ void encodeVectorTile(const DataFacadeBase &facade,
                    {
                        // Calculate the speed for this line
                        std::uint32_t speed_kmh_idx = static_cast<std::uint32_t>(
-                            round(length / from_alias<double>(forward_duration) * 10 * 3.6));
+                            std::round(length / from_alias<double>(forward_duration) * 10 * 3.6));

                        // Rate values are in meters per weight-unit - and similar to speeds, we
                        // present 1 decimal place of precision (these values are added as
                        // double/10) lower down
                        std::uint32_t forward_rate = static_cast<std::uint32_t>(
-                            round(length / from_alias<double>(forward_weight) * 10.));
+                            std::round(length / from_alias<double>(forward_weight) * 10.));

                        auto tile_line = coordinatesToTileLine(a, b, tile_bbox);
                        if (!tile_line.empty())
@ -531,13 +531,13 @@ void encodeVectorTile(const DataFacadeBase &facade,
                    {
                        // Calculate the speed for this line
                        std::uint32_t speed_kmh_idx = static_cast<std::uint32_t>(
-                            round(length / from_alias<double>(reverse_duration) * 10 * 3.6));
+                            std::round(length / from_alias<double>(reverse_duration) * 10 * 3.6));

                        // Rate values are in meters per weight-unit - and similar to speeds, we
                        // present 1 decimal place of precision (these values are added as
                        // double/10) lower down
                        std::uint32_t reverse_rate = static_cast<std::uint32_t>(
-                            round(length / from_alias<double>(reverse_weight) * 10.));
+                            std::round(length / from_alias<double>(reverse_weight) * 10.));

                        auto tile_line = coordinatesToTileLine(b, a, tile_bbox);
                        if (!tile_line.empty())
@ -663,7 +663,7 @@ Status TilePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 {
    BOOST_ASSERT(parameters.IsValid());

-    auto &pbf_buffer = result.get<std::string>();
+    auto &pbf_buffer = std::get<std::string>(result);
    const auto &facade = algorithms.GetFacade();
    auto edges = getEdges(facade, parameters.x, parameters.y, parameters.z);
    auto segregated_nodes = getSegregatedNodes(facade, edges);
--- a/src/engine/routing_algorithms/alternative_path_mld.cpp
+++ b/src/engine/routing_algorithms/alternative_path_mld.cpp
@ -248,7 +248,7 @@ filterViaCandidatesByViaNotOnPath(const WeightedViaNodePackedPath &path, RandIt
    for (const auto &edge : path.path)
        nodes.insert(std::get<1>(edge));

-    const auto via_on_path = [&](const auto via) { return nodes.count(via.node) > 0; };
+    const auto via_on_path = [&](const auto via) { return nodes.contains(via.node); };

    return std::remove_if(first, last, via_on_path);
 }
@ -308,7 +308,7 @@ RandIt filterPackedPathsByCellSharing(RandIt first,
        {
            const auto source_cell = get_cell(std::get<0>(edge));
            const auto target_cell = get_cell(std::get<1>(edge));
-            return cells.count(source_cell) < 1 && cells.count(target_cell) < 1;
+            return !cells.contains(source_cell) && !cells.contains(target_cell);
        };

        const auto different = std::count_if(begin(packed.path), end(packed.path), not_seen);
@ -491,7 +491,7 @@ RandIt filterUnpackedPathsBySharing(RandIt first,
        {
            auto node_duration = facade.GetNodeDuration(node);
            total_duration += node_duration;
-            if (nodes.count(node) > 0)
+            if (nodes.contains(node))
            {
                return duration + node_duration;
            }
--- a/src/engine/routing_algorithms/many_to_many_mld.cpp
+++ b/src/engine/routing_algorithms/many_to_many_mld.cpp
@ -325,7 +325,7 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                           EdgeDuration initial_duration,
                           EdgeDistance initial_distance)
    {
-        if (target_nodes_index.count(node))
+        if (target_nodes_index.contains(node))
        {
            // Source and target on the same edge node. If target is not reachable directly via
            // the node (e.g destination is before source on oneway segment) we want to allow
--- a/src/engine/routing_algorithms/routing_base_mld.cpp
+++ b/src/engine/routing_algorithms/routing_base_mld.cpp
@ -0,0 +1,60 @@
+#include "engine/routing_algorithms/routing_base_mld.hpp"
+
+namespace osrm::engine::routing_algorithms::mld
+{
+double getNetworkDistance(SearchEngineData<mld::Algorithm> &engine_working_data,
+                          const DataFacade<mld::Algorithm> &facade,
+                          typename SearchEngineData<mld::Algorithm>::QueryHeap &forward_heap,
+                          typename SearchEngineData<mld::Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          EdgeWeight weight_upper_bound)
+{
+    forward_heap.Clear();
+    reverse_heap.Clear();
+
+    const PhantomEndpoints endpoints{source_phantom, target_phantom};
+    insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
+
+    auto [weight, unpacked_nodes, unpacked_edges] = search(
+        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
+
+    if (weight == INVALID_EDGE_WEIGHT)
+    {
+        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);
+}
+} // namespace osrm::engine::routing_algorithms::mld
--- a/src/engine/routing_algorithms/tile_turns.cpp
+++ b/src/engine/routing_algorithms/tile_turns.cpp
@ -49,7 +49,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
        {
            // operator[] will construct an empty vector at [edge.u] if there is no value.
            directed_graph[edge.u].push_back({edge.v, edge.forward_segment_id.id});
-            if (edge_based_node_info.count(edge.forward_segment_id.id) == 0)
+            if (!edge_based_node_info.contains(edge.forward_segment_id.id))
            {
                edge_based_node_info[edge.forward_segment_id.id] = {true, get_geometry_id(edge)};
            }
@ -64,7 +64,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
        if (edge.reverse_segment_id.enabled)
        {
            directed_graph[edge.v].push_back({edge.u, edge.reverse_segment_id.id});
-            if (edge_based_node_info.count(edge.reverse_segment_id.id) == 0)
+            if (!edge_based_node_info.contains(edge.reverse_segment_id.id))
            {
                edge_based_node_info[edge.reverse_segment_id.id] = {false, get_geometry_id(edge)};
            }
@ -106,7 +106,7 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
        {
            // If the target of this edge doesn't exist in our directed
            // graph, it's probably outside the tile, so we can skip it
-            if (directed_graph.count(approachedge.target_node) == 0)
+            if (!directed_graph.contains(approachedge.target_node))
                continue;

            // For each of the outgoing edges from our target coordinate
--- a/src/extractor/edge_based_graph_factory.cpp
+++ b/src/extractor/edge_based_graph_factory.cpp
@ -167,7 +167,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
    m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_1]].annotation_id =
        forward_data.annotation_data;
    m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_1]].segregated =
-        segregated_edges.count(edge_id_1) > 0;
+        segregated_edges.contains(edge_id_1);

    if (nbe_to_ebn_mapping[edge_id_2] != SPECIAL_EDGEID)
    {
@ -176,7 +176,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
        m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_2]].annotation_id =
            reverse_data.annotation_data;
        m_edge_based_node_container.nodes[nbe_to_ebn_mapping[edge_id_2]].segregated =
-            segregated_edges.count(edge_id_2) > 0;
+            segregated_edges.contains(edge_id_2);
    }

    // Add segments of edge-based nodes
@ -382,7 +382,7 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
            m_edge_based_node_container.nodes[edge_based_node_id].annotation_id =
                edge_data.annotation_data;
            m_edge_based_node_container.nodes[edge_based_node_id].segregated =
-                segregated_edges.count(eid) > 0;
+                segregated_edges.contains(eid);

            const auto ebn_weight = m_edge_based_node_weights[nbe_to_ebn_mapping[eid]];
            BOOST_ASSERT((ebn_weight & EdgeWeight{0x7fffffff}) == edge_data.weight);
@ -942,7 +942,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(

                            const auto turn_nodes = NodeBasedTurn{
                                incoming_edge.node, intersection_node, outgoing_edge_target};
-                            const auto is_maneuver_turn = unresolved_turns.count(turn_nodes) > 0;
+                            const auto is_maneuver_turn = unresolved_turns.contains(turn_nodes);

                            if (is_maneuver_turn)
                            {
--- a/src/extractor/extractor.cpp
+++ b/src/extractor/extractor.cpp
@ -50,7 +50,6 @@
 #include <atomic>
 #include <bitset>
 #include <chrono>
-#include <iostream>
 #include <memory>
 #include <thread>
 #include <tuple>
--- a/src/extractor/graph_compressor.cpp
+++ b/src/extractor/graph_compressor.cpp
@ -83,7 +83,7 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
            }

            // check if v is an entry/exit via node for a turn restriction
-            if (incompressible_via_nodes.count(node_v) > 0)
+            if (incompressible_via_nodes.contains(node_v))
            {
                continue;
            }
--- a/src/extractor/intersection/intersection_analysis.cpp
+++ b/src/extractor/intersection/intersection_analysis.cpp
@ -6,6 +6,7 @@
 #include "util/coordinate_calculation.hpp"

 #include <boost/optional/optional_io.hpp>
+#include <numbers>

 namespace osrm::extractor::intersection
 {
@ -79,11 +80,11 @@ namespace
 {
 double findAngleBisector(double alpha, double beta)
 {
-    alpha *= M_PI / 180.;
-    beta *= M_PI / 180.;
+    alpha *= std::numbers::pi / 180.;
+    beta *= std::numbers::pi / 180.;
    const auto average =
-        180. * std::atan2(std::sin(alpha) + std::sin(beta), std::cos(alpha) + std::cos(beta)) /
-        M_PI;
+        180. * std::atan2(std::sin(alpha) + std::sin(beta), std::cos(alpha) + std::cos(beta)) *
+        std::numbers::inv_pi;
    return std::fmod(average + 360., 360.);
 }

@ -622,7 +623,7 @@ IntersectionView convertToIntersectionView(const util::NodeBasedDynamicGraph &gr
    for (const auto &outgoing_edge : outgoing_edges)
    {
        const auto edge_it = findEdge(edge_geometries, outgoing_edge.edge);
-        const auto is_merged = merged_edges.count(outgoing_edge.edge) != 0;
+        const auto is_merged = merged_edges.contains(outgoing_edge.edge);
        const auto is_turn_allowed = intersection::isTurnAllowed(graph,
                                                                 node_data_container,
                                                                 restriction_map,
--- a/src/extractor/intersection/mergable_road_detector.cpp
+++ b/src/extractor/intersection/mergable_road_detector.cpp
@ -351,7 +351,7 @@ bool MergableRoadDetector::IsCircularShape(const NodeID intersection_node,
    //      ----         ----
    //          \       /
    //           -------
-    const auto constexpr CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND = 0.85 / (4 * M_PI);
+    const auto constexpr CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND = 0.85 / (4 * std::numbers::pi);
    if (connect_again && coordinates_to_the_left.front() == coordinates_to_the_left.back())
    { // if the left and right roads connect again and are closed polygons ...
        const auto area = util::coordinate_calculation::computeArea(coordinates_to_the_left);
@ -359,7 +359,7 @@ bool MergableRoadDetector::IsCircularShape(const NodeID intersection_node,
        const auto area_to_squared_perimeter_ratio = std::abs(area) / (perimeter * perimeter);

        // then don't merge roads if A/L² is greater than the lower bound
-        BOOST_ASSERT(area_to_squared_perimeter_ratio <= 1. / (4 * M_PI));
+        BOOST_ASSERT(area_to_squared_perimeter_ratio <= 1. / (4 * std::numbers::pi));
        if (area_to_squared_perimeter_ratio >= CIRCULAR_POLYGON_ISOPERIMETRIC_LOWER_BOUND)
            return true;
    }
--- a/Show More
+++ b/Show More