wip

Merge branch 'master' into sf-re-use-heap-in-getNetworkDistance
wip
2024-06-10 22:46:30 +02:00 · 2024-06-10 22:41:39 +02:00 · 2024-05-29 08:24:25 +02:00 · 2024-05-28 21:08:01 +02:00 · 2024-05-28 20:41:59 +02:00 · 2024-05-28 19:37:11 +02:00
145 changed files with 2042 additions and 2190 deletions
@@ -17,7 +17,6 @@ Checks: >
    -bugprone-incorrect-enable-if,
    -bugprone-switch-missing-default-case,
    -bugprone-empty-catch,
-    -bugprone-unchecked-optional-access,
    -clang-analyzer-*,
    -clang-diagnostic-deprecated-declarations,
    -clang-diagnostic-constant-conversion,
@@ -6,9 +6,6 @@ on:

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


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

      # build and publish "normal" image as last to get it listed on top
      - name: Build container image - normal
@@ -78,7 +75,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
-          tags: ${{ steps.meta.outputs.tags  }}
+          file: ./docker/Dockerfile
+          tags:  ${{ steps.meta.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
+
+
+            
@@ -116,10 +116,7 @@ jobs:
        npm run docs && ./scripts/error_on_dirty.sh
        npm audit --production

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

@@ -170,49 +168,52 @@ jobs:
            continue-on-error: false
            node: 20
            runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
            CCOMPILER: gcc-13
            CUCUMBER_TIMEOUT: 20000
            CXXCOMPILER: g++-13
            ENABLE_COVERAGE: ON

-          - name: clang-18-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            ENABLE_SANITIZER: ON
            TARGET_ARCH: x86_64-asan-ubsan
            OSRM_CONNECTION_RETRIES: 10
            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5

-          - name: clang-18-release
+          - name: clang-15-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF

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

          - name: clang-18-debug-clang-tidy
            continue-on-error: false
            node: 18
            runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
            CCOMPILER: clang-18
            CXXCOMPILER: clang++-18
@@ -220,51 +221,52 @@ jobs:
            ENABLE_CLANG_TIDY: ON


-          - name: clang-17-release
+          - name: clang-14-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-17
-            CXXCOMPILER: clang++-17
+            CCOMPILER: clang-14
+            CXXCOMPILER: clang++-14
            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF

-          - name: clang-16-release
+          - name: clang-13-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
            CUCUMBER_TIMEOUT: 60000
-            ENABLE_LTO: OFF

          - name: conan-linux-debug-asan-ubsan
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON
            ENABLE_SANITIZER: ON
-            ENABLE_LTO: OFF

          - name: conan-linux-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+            CCOMPILER: clang-15
+            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON
-            ENABLE_LTO: OFF

          - 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
@@ -274,6 +276,7 @@ jobs:
            continue-on-error: false
            node: 20
            runs-on: ubuntu-24.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-13
            CXXCOMPILER: g++-13
@@ -283,6 +286,7 @@ jobs:
            continue-on-error: false
            node: 20
            runs-on: ubuntu-22.04
+            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-12
            CXXCOMPILER: g++-12
@@ -292,10 +296,10 @@ jobs:
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

@@ -303,10 +307,10 @@ jobs:
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-16
-            CXXCOMPILER: clang++-16
+            CCOMPILER: clang-13
+            CXXCOMPILER: clang++-13
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON

@@ -338,6 +342,7 @@ jobs:
    continue-on-error: ${{ matrix.continue-on-error }}
    runs-on: ${{ matrix.runs-on }}
    env:
+      BUILD_TOOLS: ${{ matrix.BUILD_TOOLS }}
      BUILD_TYPE: ${{ matrix.BUILD_TYPE }}
      BUILD_SHARED_LIBS: ${{ matrix.BUILD_SHARED_LIBS }}
      CCOMPILER: ${{ matrix.CCOMPILER }}
@@ -354,7 +359,6 @@ jobs:
      TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
      OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
      OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
-      ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
    steps:
    - uses: actions/checkout@v4
    - name: Build machine architecture
@@ -482,13 +486,6 @@ jobs:
        tar zxvf onetbb.tgz
        sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
        sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
-    - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
-      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
-      run: |
-        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
-
-        conan config init
-        yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
    - name: Prepare build
      run: |
        mkdir ${OSRM_BUILD_DIR}
@@ -520,8 +517,8 @@ jobs:
                 -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
                 -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
                 -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+                 -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
                 -DENABLE_CCACHE=ON \
-                 -DENABLE_LTO=${ENABLE_LTO:-ON} \
                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
        make --jobs=${JOBS}

@@ -536,6 +533,13 @@ jobs:
          echo "PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig" >> $GITHUB_ENV
        fi
        popd
+    - name: Build example
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      run: |
+        mkdir example/build && pushd example/build
+        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
+        make --jobs=${JOBS}
+        popd
    - name: Run all tests
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
      run: |
@@ -543,6 +547,7 @@ jobs:

        # macOS SIP strips the linker path. Reset this inside the running shell
        export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
+        ./example/build/osrm-example test/data/mld/monaco.osrm

        # All tests assume to be run from the build directory
        pushd ${OSRM_BUILD_DIR}
@@ -631,12 +636,12 @@ jobs:
  benchmarks:
    if: github.event_name == 'pull_request'
    needs: [format-taginfo-docs]
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
    env:
-      CCOMPILER: clang-16
-      CXXCOMPILER: clang++-16
-      CC: clang-16
-      CXX: clang++-16
+      CCOMPILER: clang-13
+      CXXCOMPILER: clang++-13
+      CC: clang-13
+      CXX: clang++-13
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      PR_NUMBER: ${{ github.event.pull_request.number }}
      GITHUB_REPOSITORY: ${{ github.repository }}
@@ -671,7 +676,7 @@ jobs:
          path: pr
      - name: Install dependencies
        run: | 
-          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" --break-system-packages
+          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: |
@@ -693,6 +698,15 @@ jobs:
          mkdir -p $HOME/.ccache
          ccache --zero-stats
          ccache --max-size=256M
+      - name: Build PR Branch
+        run: |
+          mkdir -p pr/build
+          cd pr/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc) 
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
      - name: Checkout Base Branch
        uses: actions/checkout@v4
        with:
@@ -707,43 +721,9 @@ jobs:
          make -j$(nproc) benchmarks
          cd ..
          make -C test/data 
-      - name: Build PR Branch
+      - name: Run Benchmarks
        run: |
-          mkdir -p pr/build
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
-          make -j$(nproc) 
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      # we run benchmarks in tmpfs to avoid impact of disk IO
-      - name: Create folder for tmpfs 
-        run: mkdir -p /opt/benchmarks
-      - name: Run PR Benchmarks 
-        run: |
-          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-          cp -rf pr/build /opt/benchmarks/build
-          mkdir -p /opt/benchmarks/test
-          cp -rf pr/test/data /opt/benchmarks/test/data
-          cp -rf pr/profiles /opt/benchmarks/profiles
-
-          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount /opt/benchmarks
-      - name: Run Base Benchmarks
-        run: |
-          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-          cp -rf base/build /opt/benchmarks/build
-          mkdir -p /opt/benchmarks/test
-          cp -rf base/test/data /opt/benchmarks/test/data
-          cp -rf base/profiles /opt/benchmarks/profiles
-
-          # TODO: remove it when base branch will have this file at needed location
-          if [ ! -f /opt/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
-          fi
-          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
-          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount /opt/benchmarks
+          ./pr/scripts/ci/run_benchmarks.sh base pr
      - name: Post Benchmark Results
        run: |
          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
@@ -754,7 +734,6 @@ jobs:

  ci-complete:
    runs-on: ubuntu-22.04
-    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image, windows-release-node, benchmarks]
    steps:
    - run: echo "CI complete"
-
@@ -1,29 +0,0 @@
-name: 'Close stale issues'
-on:
-  # NOTE: uncomment if you want to test changes to this file in PRs CI
-  # pull_request:
-  #   branches:
-  #     - master
-  schedule:
-    - cron: '30 1 * * *' # every day at 1:30am
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/stale@v9
-        with:
-          operations-per-run: 3000
-          stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
-          stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
-          days-before-issue-stale: 180 # 6 months
-          days-before-issue-close: 30 # 1 month
-          days-before-pr-stale: 180 # 6 months
-          days-before-pr-close: -1 # never close PRs
-          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
-
-  
-
@@ -43,6 +43,7 @@ Thumbs.db
 #######################
 /_build*
 /build/
+/example/build/
 /test/data/monaco.osrm*
 /test/data/ch
 /test/data/corech
@@ -24,22 +24,6 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
-      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
-      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
-      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
-      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
-      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
-      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
-      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
-      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
-      - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
-      - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
-      - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)
-      - CHANGED: Apply micro-optimisation for Match API. [#6945](https://github.com/Project-OSRM/osrm-backend/pull/6945)
-      - CHANGED: Apply micro-optimisation for Nearest API. [#6944](https://github.com/Project-OSRM/osrm-backend/pull/6944)
-      - CHANGED: Avoid copy of intersection in totalTurnAngle. [#6938](https://github.com/Project-OSRM/osrm-backend/pull/6938)
-      - CHANGED: Use std::unordered_map::emplace instead of operator[] when producing JSONs. [#6936](https://github.com/Project-OSRM/osrm-backend/pull/6936)
-      - CHANGED: Avoid copy of vectors in MakeRoute function. [#6939](https://github.com/Project-OSRM/osrm-backend/pull/6939)
      - FIXED: Fix bugprone-unused-return-value clang-tidy warning. [#6934](https://github.com/Project-OSRM/osrm-backend/pull/6934)
      - FIXED: Fix performance-noexcept-move-constructor clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6933)
      - FIXED: Fix performance-noexcept-swap clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6931)
@@ -53,7 +37,6 @@
      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
-      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
      - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-project(OSRM C CXX)
+
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -10,12 +10,6 @@ Please create a directory and run cmake from there, passing the path to this sou
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
 endif()

-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(STATUS "Building on a 64 bit system")
-else()
-  message(FATAL_ERROR "Building on a 32 bit system is not supported")
-endif()
-
 # detect if this is included as subproject and if so expose
 # some variables to its parent scope
 get_directory_property(BUILD_AS_SUBPROJECT PARENT_DIRECTORY)
@@ -28,37 +22,41 @@ if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
  set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 endif()

-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-option(BUILD_PACKAGE "Build OSRM package" OFF)
-option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
-option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
-option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
 option(ENABLE_CONAN "Use conan for dependencies" OFF)
-option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
+option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
+option(BUILD_TOOLS "Build OSRM tools" OFF)
+option(BUILD_PACKAGE "Build OSRM package" OFF)
+option(BUILD_ROUTED "Build osrm-routed HTTP server" ON)
+option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
-option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
-option(ENABLE_LTO "Use Link Time Optimisation" ON)
-option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
+option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
+option(ENABLE_LTO "Use LTO if available" OFF)
+option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
+option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
+option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)

 if (ENABLE_CLANG_TIDY)
-  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy REQUIRED)
-  message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
-  set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
-endif()
-
-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
+  if(NOT CLANG_TIDY_COMMAND)
+    message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
  else()
-      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
+    message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*;--header-filter=.*")
  endif()
 endif()

+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# be compatible with version handling before cmake 3.x
+if (POLICY CMP0057)
+  cmake_policy(SET CMP0057 NEW)
+endif()
+if (POLICY CMP0074)
+  cmake_policy(SET CMP0074 NEW)
+endif()
+project(OSRM C CXX)
+
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
  set(CMAKE_BUILD_RPATH "@loader_path")
@@ -75,14 +73,14 @@ sbeParseJson(packagejson packagejsonraw)
 # This regex is not strict enough, but the correct one is too complicated for cmake matching.
 # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
 if (packagejson.version MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)([-+][0-9a-zA-Z.-]+)?$")
-  set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
-  set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
-  set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
-  set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})
+    set(OSRM_VERSION_MAJOR            ${CMAKE_MATCH_1})
+    set(OSRM_VERSION_MINOR            ${CMAKE_MATCH_2})
+    set(OSRM_VERSION_PATCH            ${CMAKE_MATCH_3})
+    set(OSRM_VERSION_PRERELEASE_BUILD ${CMAKE_MATCH_4})

-  set(OSRM_VERSION packagejson.version)
+    set(OSRM_VERSION packagejson.version)
 else()
-  message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
+    message(FATAL_ERROR "Version from package.json cannot be parsed, expected semver compatible label, but found ${packagejson.version}")
 endif()

 if (MSVC)
@@ -114,11 +112,17 @@ include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
 include(GNUInstallDirs)

+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(FATAL_ERROR "Building on a 32 bit system is not supported")
+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/include)

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

 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@@ -134,6 +138,7 @@ file(GLOB UpdaterGlob src/updater/*.cpp)
 file(GLOB StorageGlob src/storage/*.cpp)
 file(GLOB ServerGlob src/server/*.cpp src/server/**/*.cpp)
 file(GLOB EngineGlob src/engine/*.cpp src/engine/**/*.cpp)
+file(GLOB ErrorcodesGlob src/osrm/errorcodes.cpp)

 add_library(UTIL OBJECT ${UtilGlob})
 add_library(EXTRACTOR OBJECT ${ExtractorGlob})
@@ -144,11 +149,14 @@ add_library(CONTRACTOR OBJECT ${ContractorGlob})
 add_library(UPDATER OBJECT ${UpdaterGlob})
 add_library(STORAGE OBJECT ${StorageGlob})
 add_library(ENGINE OBJECT ${EngineGlob})
-add_library(SERVER OBJECT ${ServerGlob})
+
+if (BUILD_ROUTED)
+  add_library(SERVER OBJECT ${ServerGlob})
+  add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
+endif()

 set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)

-add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 add_executable(osrm-extract src/tools/extract.cpp)
 add_executable(osrm-partition src/tools/partition.cpp)
 add_executable(osrm-customize src/tools/customize.cpp)
@@ -200,6 +208,17 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()

+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(WARNING "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
  if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -271,7 +290,6 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})

 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
-
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)

@@ -312,12 +330,20 @@ if(ENABLE_CONAN)

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

  set(CONAN_SYSTEM_INCLUDES ON)

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

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

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


@@ -435,6 +467,7 @@ add_dependency_includes(${ZLIB_INCLUDE_DIRS})

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

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

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

 set(BOOST_ENGINE_LIBRARIES
  ${Boost_ZLIB_LIBRARY}
@@ -458,10 +494,13 @@ target_link_libraries(osrm-extract osrm_extract ${Boost_PROGRAM_OPTIONS_LIBRARY}
 target_link_libraries(osrm-partition osrm_partition ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-customize osrm_customize ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-contract osrm_contract ${Boost_PROGRAM_OPTIONS_LIBRARY})
-target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+if (BUILD_ROUTED)
+  target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+endif()

 set(EXTRACTOR_LIBRARIES
    ${BZIP2_LIBRARIES}
+    ${Boost_REGEX_LIBRARY}
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${EXPAT_LIBRARIES}
@@ -532,13 +571,18 @@ target_link_libraries(osrm_partition ${PARTITIONER_LIBRARIES})
 target_link_libraries(osrm_customize ${CUSTOMIZER_LIBRARIES} osrm_update osrm_store)
 target_link_libraries(osrm_store ${STORAGE_LIBRARIES})

+# BUILD_COMPONENTS
 add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 target_link_libraries(osrm-components ${TBB_LIBRARIES} ${BOOST_BASE_LIBRARIES} ${UTIL_LIBRARIES})
 install(TARGETS osrm-components DESTINATION bin)

-add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
-target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
-install(TARGETS osrm-io-benchmark DESTINATION bin)
+if(BUILD_TOOLS)
+  message(STATUS "Activating OSRM internal tools")
+  add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
+  target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
+
+  install(TARGETS osrm-io-benchmark DESTINATION bin)
+endif()

 if (ENABLE_ASSERTIONS)
  message(STATUS "Enabling assertions")
@@ -557,14 +601,47 @@ set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-partition PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+if (BUILD_ROUTED)
+  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+endif()

+file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
+file(GLOB LibraryGlob include/osrm/*.hpp)
+file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
+set(ApiHeader include/engine/api/base_result.hpp)
+set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
+set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
+set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
+set(PartitionerHeader include/partitioner/partitioner.hpp include/partitioner/partitioner_config.hpp)
+set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
+set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
+install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
+install(FILES ${UtilHeader} DESTINATION include/osrm/util)
+install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
+install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
+install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
+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 ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
 install(TARGETS osrm-customize DESTINATION bin)
 install(TARGETS osrm-contract DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
-install(TARGETS osrm-routed DESTINATION bin)
+if (BUILD_ROUTED)
+  install(TARGETS osrm-routed DESTINATION bin)
+endif()
+install(TARGETS osrm DESTINATION lib)
+install(TARGETS osrm_extract DESTINATION lib)
+install(TARGETS osrm_partition DESTINATION lib)
+install(TARGETS osrm_customize DESTINATION lib)
+install(TARGETS osrm_update DESTINATION lib)
+install(TARGETS osrm_contract DESTINATION lib)
+install(TARGETS osrm_store DESTINATION lib)
+install(TARGETS osrm_guidance DESTINATION lib)
+

 # Install profiles and support library to /usr/local/share/osrm/profiles by default
 set(DefaultProfilesDir profiles)
@@ -575,6 +652,8 @@ set(DefaultProfilesDir data)
 install(DIRECTORY ${DefaultProfilesDir} DESTINATION share/osrm)

 # Setup exporting variables for pkgconfig and subproject
+#
+
 if(BUILD_PACKAGE)
  include(CPackConfig)
  include(CPack)
@@ -651,6 +730,7 @@ if (ENABLE_NODE_BINDINGS)
  add_subdirectory(src/nodejs)
 endif()

+
 if (ENABLE_FUZZING)
  # Requires libosrm being built with sanitizers; make configurable and default to ubsan
  set(FUZZ_SANITIZER "undefined" CACHE STRING "Sanitizer to be used for Fuzz testing")
@@ -684,3 +764,4 @@ foreach(header ${headers_to_check})
 endforeach()
 add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
 set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
+
@@ -64,6 +64,7 @@ add_warning(init-self)
 add_warning(bool-compare)
 add_warning(logical-not-parentheses)
 add_warning(logical-op)
+add_warning(maybe-uninitialized)
 add_warning(misleading-indentation)
 # `no-` prefix is part of warning name(i.e. doesn't mean we are disabling it)
 add_warning(no-return-local-addr)
@@ -83,6 +84,3 @@ no_warning(comma-subscript)
 no_warning(ambiguous-reversed-operator)
 no_warning(restrict)
 no_warning(free-nonheap-object)
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  no_warning(stringop-overflow)
-endif()
@@ -1 +0,0 @@
-Dockerfile-debian
@@ -0,0 +1,68 @@
+FROM debian:bookworm-slim as builder
+ARG DOCKER_TAG
+ARG BUILD_CONCURRENCY
+RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
+    libzip-dev libboost1.81-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    ldconfig /usr/local/lib && \
+    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
+    cd oneTBB && \
+    mkdir build && \
+    cd build && \
+    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
+    cmake --build . && \
+    cmake --install .
+
+COPY . /src
+WORKDIR /src
+
+RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
+    echo "Building OSRM ${DOCKER_TAG}" && \
+    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
+    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
+    mkdir -p build && \
+    cd build && \
+    BUILD_TYPE="Release" && \
+    ENABLE_ASSERTIONS="Off" && \
+    BUILD_TOOLS="Off" && \
+    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
+    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
+    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    make -j${NPROC} install && \
+    cd ../profiles && \
+    cp -r * /opt && \
+    strip /usr/local/bin/* && \
+    rm -rf /src
+
+
+# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
+# Only the content below ends up in the image, this helps remove /src from the image (which is large)
+FROM debian:bookworm-slim as runstage
+
+COPY --from=builder /usr/local /usr/local
+COPY --from=builder /opt /opt
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends libboost-program-options1.81.0 libboost-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
+    ldconfig /usr/local/lib
+
+RUN /usr/local/bin/osrm-extract --help && \
+    /usr/local/bin/osrm-routed --help && \
+    /usr/local/bin/osrm-contract --help && \
+    /usr/local/bin/osrm-partition --help && \
+    /usr/local/bin/osrm-customize --help
+
+WORKDIR /opt
+
+EXPOSE 5000
@@ -1,61 +0,0 @@
-FROM alpine:3.20.0 as alpine-mimalloc
-
-RUN apk add --no-cache mimalloc
-
-ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
-ENV MIMALLOC_LARGE_OS_PAGES=1
-
-
-FROM alpine-mimalloc as builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-RUN mkdir -p /src  && mkdir -p /opt
-
-RUN apk add --no-cache \
-    cmake make git clang libbz2 libxml2 \
-    boost-dev boost-program_options boost-filesystem boost-iostreams boost-thread \
-    lua5.4-dev onetbb-dev expat-dev
-
-COPY . /src
-WORKDIR /src
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=OFF && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM alpine-mimalloc as runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apk add --no-cache \
-    boost-program_options boost-date_time boost-iostreams boost-thread \
-    expat lua5.4 onetbb && \
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
@@ -1,66 +0,0 @@
-FROM debian:bookworm-slim as builder
-ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
-RUN mkdir -p /src  && mkdir -p /opt
-
-RUN apt-get update && \
-    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
-    libzip-dev libboost1.81-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    ldconfig /usr/local/lib && \
-    git clone --branch v2021.12.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
-    cd oneTBB && \
-    mkdir build && \
-    cd build && \
-    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
-    cmake --build . && \
-    cmake --install .
-
-COPY . /src
-WORKDIR /src
-
-RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bookworm-slim as runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        libboost-program-options1.81.0 libboost-date-time1.81.0 libboost-iostreams1.81.0 libboost-thread1.81.0 \
-        expat liblua5.4-0 && \
-    rm -rf /var/lib/apt/lists/* && \
-# add /usr/local/lib to ldconfig to allow loading libraries from there
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000
@@ -6,8 +6,4 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-
-DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
-
-$DOCKER_BUILD Dockerfile ..
-$DOCKER_BUILD Dockerfile-alpine ..
+docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
@@ -0,0 +1,33 @@
+## Introduction
+
+OSRM can be used as a library (libosrm) via C++ instead of using it through the HTTP interface and `osrm-routed`. This allows for fine-tuning OSRM and has much less overhead. Here is a quick introduction into how to use `libosrm` in the upcoming v5 release.
+
+Take a look at the example code that lives in the [example directory](https://github.com/Project-OSRM/osrm-backend/tree/master/example). Here is all you ever wanted to know about `libosrm`, that is a short description of what the types do and where to find documentation on it:
+
+## Important interface objects
+
+- [`EngineConfig`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/engine_config.hpp) - for initializing an OSRM instance we can configure certain properties and constraints. E.g. the storage config is the base path such as `france.osm.osrm` from which we derive and load `france.osm.osrm.*` auxiliary files. This also lets you set constraints such as the maximum number of locations allowed for specific services.
+
+- [`OSRM`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/osrm/osrm.hpp) - this is the main Routing Machine type with functions such as `Route` and `Table`. You initialize it with a `EngineConfig`. It does all the heavy lifting for you. Each function takes its own parameters, e.g. the `Route` function takes `RouteParameters`, and a out-reference to a JSON result that gets filled. The return value is a `Status`, indicating error or success.
+
+- [`Status`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/status.hpp) - this is a type wrapping `Error` or `Ok` for indicating error or success, respectively.
+
+- [`TableParameters`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/table_parameters.hpp) - this is an example of parameter types the Routing Machine functions expect. In this case `Table` expects its own parameters as `TableParameters`. You can see it wrapping two vectors, sources and destinations --- these are indices into your coordinates for the table service to construct a matrix from (empty sources or destinations means: use all of them). If you ask yourself where coordinates come from, you can see `TableParameters` inheriting from `BaseParameters`.
+
+- [`BaseParameter`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/engine/api/base_parameters.hpp) - this most importantly holds coordinates (and a few other optional properties that you don't need for basic usage); the specific parameter types inherit from `BaseParameters` to get these member attributes. That means your `TableParameters` type has `coordinates`, `sources` and `destination` member attributes (and a few other that we ignore for now).
+
+- [`Coordinate`](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/coordinate.hpp) - this is a wrapper around a (longitude, latitude) pair. We really don't care about (lon,lat) vs (lat, lon) but we don't want you to accidentally mix them up, so both latitude and longitude are strictly typed wrappers around integers (fixed notation such as `13423240`) and floating points (floating notation such as `13.42324`).
+
+- [Parameters for other services](https://github.com/Project-OSRM/osrm-backend/tree/master/include/engine/api) - here are all other `*Parameters` you need for other Routing Machine services.
+
+- [JSON](https://github.com/Project-OSRM/osrm-backend/blob/master/include/util/json_container.hpp) - this is a sum type resembling JSON. The Routing Machine service functions take a out-ref to a JSON result and fill it accordingly. It is currently implemented using [mapbox/variant](https://github.com/mapbox/variant) which is similar to [Boost.Variant](http://www.boost.org/doc/libs/1_55_0/doc/html/variant.html). There are two ways to work with this sum type: either provide a visitor that acts on each type on visitation or use the `get` function in case you're sure about the structure. The JSON structure is written down in the [HTTP API](#http-api).
+
+## Example
+
+See [the example folder](https://github.com/Project-OSRM/osrm-backend/tree/master/example) in the OSRM repository.
+
+## Workflow
+
+ - Create an `OSRM` instance initialized with a `EngineConfig`
+ - Call the service function on the `OSRM` object providing service specific `*Parameters`
+ - Check the return code and use the JSON result
@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.18)
+
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
+  message(FATAL_ERROR "In-source builds are not allowed.
+Please create a directory and run cmake from there, passing the path to this source directory as the last argument.
+This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. Please delete them.")
+endif()
+
+if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+project(osrm-example C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(STATUS "Building on a 32 bit system")
+endif()
+
+link_directories(${LibOSRM_LIBRARY_DIRS})
+add_executable(osrm-example example.cpp)
+
+find_package(LibOSRM REQUIRED)
+
+target_link_libraries(osrm-example ${LibOSRM_LIBRARIES} ${LibOSRM_DEPENDENT_LIBRARIES})
+include_directories(SYSTEM ${LibOSRM_INCLUDE_DIRS})
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LibOSRM_CXXFLAGS}")
@@ -0,0 +1,63 @@
+# - Try to find LibOSRM
+# Once done this will define
+#  LibOSRM_FOUND - System has LibOSRM
+#  LibOSRM_LIBRARIES - The libraries and ldflags needed to use LibOSRM
+#  LibOSRM_DEPENDENT_LIBRARIES - The libraries and ldflags need to link LibOSRM dependencies
+#  LibOSRM_LIBRARY_DIRS - The libraries paths needed to find LibOSRM
+#  LibOSRM_CXXFLAGS - Compiler switches required for using LibOSRM
+
+find_package(PkgConfig)
+pkg_search_module(PC_LibOSRM QUIET libosrm)
+
+function(JOIN VALUES GLUE OUTPUT)
+  string (REPLACE ";" "${GLUE}" _TMP_STR "${VALUES}")
+  set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE)
+endfunction()
+
+list(REMOVE_ITEM PC_LibOSRM_CFLAGS " ")
+JOIN("${PC_LibOSRM_CFLAGS}" " " output)
+
+set(LibOSRM_CXXFLAGS ${output})
+set(LibOSRM_LIBRARY_DIRS ${PC_LibOSRM_LIBRARY_DIRS})
+
+find_path(LibOSRM_INCLUDE_DIR osrm/osrm.hpp
+  PATH_SUFFIXES osrm include/osrm include
+  HINTS ${PC_LibOSRM_INCLUDEDIR} ${PC_LibOSRM_INCLUDE_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+
+find_library(TEST_LibOSRM_STATIC_LIBRARY Names osrm.lib libosrm.a
+  PATH_SUFFIXES osrm lib/osrm lib
+  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+find_library(TEST_LibOSRM_DYNAMIC_LIBRARY Names libosrm.dylib libosrm.so
+  PATH_SUFFIXES osrm lib/osrm lib
+  HINTS ${PC_LibOSRM_LIBDIR} ${PC_LibOSRM_LIBRARY_DIRS}
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt)
+
+set(LibOSRM_DEPENDENT_LIBRARIES ${PC_LibOSRM_STATIC_LDFLAGS})
+set(LibOSRM_LIBRARIES ${PC_LibOSRM_LDFLAGS})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LIBOSRM_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(LibOSRM DEFAULT_MSG
+                                LibOSRM_LIBRARY_DIRS
+                                LibOSRM_CXXFLAGS
+                                LibOSRM_LIBRARIES
+                                LibOSRM_DEPENDENT_LIBRARIES
+                                LibOSRM_INCLUDE_DIR)
@@ -0,0 +1 @@
+../../cmake/FindTBB.cmake
@@ -0,0 +1,90 @@
+#include "osrm/match_parameters.hpp"
+#include "osrm/nearest_parameters.hpp"
+#include "osrm/route_parameters.hpp"
+#include "osrm/table_parameters.hpp"
+#include "osrm/trip_parameters.hpp"
+
+#include "osrm/coordinate.hpp"
+#include "osrm/engine_config.hpp"
+#include "osrm/json_container.hpp"
+
+#include "osrm/osrm.hpp"
+#include "osrm/status.hpp"
+
+#include <exception>
+#include <iostream>
+#include <string>
+#include <utility>
+
+#include <cstdlib>
+
+int main(int argc, const char *argv[])
+{
+    if (argc < 2)
+    {
+        std::cerr << "Usage: " << argv[0] << " data.osrm\n";
+        return EXIT_FAILURE;
+    }
+
+    using namespace osrm;
+
+    // Configure based on a .osrm base path, and no datasets in shared mem from osrm-datastore
+    EngineConfig config;
+
+    config.storage_config = {argv[1]};
+    config.use_shared_memory = false;
+
+    // We support two routing speed up techniques:
+    // - Contraction Hierarchies (CH): requires extract+contract pre-processing
+    // - Multi-Level Dijkstra (MLD): requires extract+partition+customize pre-processing
+    //
+    // config.algorithm = EngineConfig::Algorithm::CH;
+    config.algorithm = EngineConfig::Algorithm::MLD;
+
+    // Routing machine with several services (such as Route, Table, Nearest, Trip, Match)
+    const OSRM osrm{config};
+
+    // The following shows how to use the Route service; configure this service
+    RouteParameters params;
+
+    // Route in monaco
+    params.coordinates.push_back({util::FloatLongitude{7.419758}, util::FloatLatitude{43.731142}});
+    params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}});
+
+    // Response is in JSON format
+    engine::api::ResultT result = json::Object();
+
+    // Execute routing request, this does the heavy lifting
+    const auto status = osrm.Route(params, result);
+
+    auto &json_result = std::get<json::Object>(result);
+    if (status == Status::Ok)
+    {
+        auto &routes = std::get<json::Array>(json_result.values["routes"]);
+
+        // Let's just use the first route
+        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)
+        {
+            std::cout << "Note: distance or duration is zero. ";
+            std::cout << "You are probably doing a query outside of the OSM extract.\n\n";
+        }
+
+        std::cout << "Distance: " << distance << " meter\n";
+        std::cout << "Duration: " << duration << " seconds\n";
+        return EXIT_SUCCESS;
+    }
+    else if (status == Status::Error)
+    {
+        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";
+        return EXIT_FAILURE;
+    }
+}
@@ -42,7 +42,7 @@ module.exports = function () {
        this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;

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

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

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

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

    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
@@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                      std::uint32_t &connectivity_checksum)
 {
@@ -30,7 +30,7 @@ inline void readGraph(const std::filesystem::path &path,

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

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

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

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

 #include "storage/shared_memory_ownership.hpp"

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

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

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

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

 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
@@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"

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

 #include <algorithm>
 #include <vector>
@@ -74,12 +74,12 @@ struct BaseParameters
    };

    std::vector<util::Coordinate> coordinates;
-    std::vector<std::optional<Hint>> hints;
-    std::vector<std::optional<double>> radiuses;
-    std::vector<std::optional<Bearing>> bearings;
-    std::vector<std::optional<Approach>> approaches;
+    std::vector<boost::optional<Hint>> hints;
+    std::vector<boost::optional<double>> radiuses;
+    std::vector<boost::optional<Bearing>> bearings;
+    std::vector<boost::optional<Approach>> approaches;
    std::vector<std::string> exclude;
-    std::optional<OutputFormatType> format = OutputFormatType::JSON;
+    boost::optional<OutputFormatType> format = OutputFormatType::JSON;

    // Adds hints to response which can be included in subsequent requests, see `hints` above.
    bool generate_hints = true;
@@ -90,10 +90,10 @@ struct BaseParameters
    SnappingType snapping = SnappingType::Default;

    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<std::optional<Hint>> hints_ = {},
-                   std::vector<std::optional<double>> radiuses_ = {},
-                   std::vector<std::optional<Bearing>> bearings_ = {},
-                   std::vector<std::optional<Approach>> approaches_ = {},
+                   std::vector<boost::optional<Hint>> hints_ = {},
+                   std::vector<boost::optional<double>> radiuses_ = {},
+                   std::vector<boost::optional<Bearing>> bearings_ = {},
+                   std::vector<boost::optional<Approach>> approaches_ = {},
                   bool generate_hints_ = true,
                   std::vector<std::string> exclude = {},
                   const SnappingType snapping_ = SnappingType::Default)
@@ -112,7 +112,7 @@ struct BaseParameters
               (approaches.empty() || approaches.size() == coordinates.size()) &&
               std::all_of(bearings.begin(),
                           bearings.end(),
-                           [](const std::optional<Bearing> &bearing_and_range)
+                           [](const boost::optional<Bearing> &bearing_and_range)
                           {
                               if (bearing_and_range)
                               {
@@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"

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

 #include <algorithm>
 #include <iterator>
@@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                             const char *weight_name);

 // Creates a Waypoint without Hint, see the Hint overload below
@@ -77,19 +77,19 @@ class MatchAPI final : public RouteAPI
                                   sub_routes[index].unpacked_path_segments,
                                   sub_routes[index].source_traversed_in_reverse,
                                   sub_routes[index].target_traversed_in_reverse);
-            route.values.emplace("confidence", sub_matchings[index].confidence);
-            routes.values.emplace_back(std::move(route));
+            route.values["confidence"] = sub_matchings[index].confidence;
+            routes.values.push_back(std::move(route));
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
+            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
        }
-        response.values.emplace("matchings", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["matchings"] = std::move(routes);
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

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

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

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

        return waypoints;
@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
@@ -100,23 +100,23 @@ class NearestAPI final : public BaseAPI
                               auto waypoint = MakeWaypoint({phantom_node});

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

                               auto node_values = MakeNodes(phantom_node);

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

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

@@ -110,14 +110,14 @@ class RouteAPI : public BaseAPI

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

@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
        return builder.CreateVectorOfStructs(coordinates);
    }

-    std::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    boost::optional<util::json::Value>
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
    {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
        if (annotations)
        {
            auto begin = annotations->begin();
@@ -340,8 +340,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);

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

        auto route = guidance::assembleRoute(legs);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
+            MakeGeometry(MakeOverview(leg_geometries));

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

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

                annotations.push_back(std::move(annotation));
@@ -996,10 +989,10 @@ class RouteAPI : public BaseAPI
        return result;
    }

-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
    MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
    {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::optional<std::vector<Coordinate>> overview;
        if (parameters.overview != RouteParameters::OverviewType::False)
        {
            const auto use_simplification =
@@ -82,7 +82,7 @@ struct RouteParameters : public BaseParameters
                    const bool alternatives_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    Args &&...args_)
        // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
        // below.
@@ -100,7 +100,7 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
@@ -118,7 +118,7 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u},
@@ -135,7 +135,7 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
                    const Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -153,7 +153,7 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -172,7 +172,7 @@ struct RouteParameters : public BaseParameters
    AnnotationsType annotations_type = AnnotationsType::None;
    GeometriesType geometries = GeometriesType::Polyline;
    OverviewType overview = OverviewType::Simplified;
-    std::optional<bool> continue_straight;
+    boost::optional<bool> continue_straight;
    std::vector<std::size_t> waypoints;

    bool IsValid() const
@@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates));
+                response.values["sources"] = MakeWaypoints(candidates);
            }
            number_of_sources = candidates.size();
        }
@@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
+                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
            }
        }

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

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

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

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

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

@@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
+            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
        }
-        response.values.emplace("trips", std::move(routes));
-        response.values.emplace("code", "Ok");
+        response.values["trips"] = std::move(routes);
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }

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

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

@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "engine/api/route_parameters.hpp"

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

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

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

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

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

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

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

 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types
@@ -177,7 +177,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

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

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

@@ -369,7 +369,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const override final
    {
@@ -382,20 +382,20 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                        const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

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

    PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const override final
    {
@@ -35,7 +35,6 @@
 #include <cstddef>

 #include <engine/bearing.hpp>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -127,21 +126,21 @@ class BaseDataFacade
    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const = 0;

    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing,
                        const Approach approach) const = 0;

    virtual PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<double> max_distance,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const = 0;

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

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

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

 #include "osrm/coordinate.hpp"

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

 #include <algorithm>
 #include <cmath>
@@ -53,8 +53,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const double max_distance,
-                        const std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::optional<bool> use_all_edges) const
    {
        auto results = rtree.SearchInRange(
            input_coordinate,
@@ -85,9 +85,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
-                        const std::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<double> max_distance,
+                        const boost::optional<Bearing> bearing_with_range,
+                        const boost::optional<bool> use_all_edges) const
    {
        auto results = rtree.Nearest(
            input_coordinate,
@@ -121,9 +121,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
        const util::Coordinate input_coordinate,
        const Approach approach,
-        const std::optional<double> max_distance,
-        const std::optional<Bearing> bearing_with_range,
-        const std::optional<bool> use_all_edges) const
+        const boost::optional<double> max_distance,
+        const boost::optional<Bearing> bearing_with_range,
+        const boost::optional<bool> use_all_edges) const
    {
        bool has_nearest = false;
        bool has_big_component = false;
@@ -37,14 +37,6 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 {
    LegGeometry geometry;

-    // each container will at most have `leg_data.size()` + 1/2 elements in it
-    // these additional 1/2 elements come from processing of very first and very last segment
-    geometry.locations.reserve(leg_data.size() + 2);
-    geometry.segment_distances.reserve(leg_data.size() + 1);
-    geometry.segment_offsets.reserve(leg_data.size() + 1);
-    geometry.annotations.reserve(leg_data.size() + 1);
-    geometry.node_ids.reserve(leg_data.size() + 2);
-
    // segment 0 first and last
    geometry.segment_offsets.push_back(0);
    geometry.locations.push_back(source_node.location);
@@ -17,9 +17,9 @@
 #include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"

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

 namespace osrm::engine::guidance
@@ -202,8 +202,8 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
    if (entry_step.geometry_begin > exit_step.geometry_begin)
        return totalTurnAngle(exit_step, entry_step);

-    const auto &exit_intersection = exit_step.intersections.front();
-    const auto &entry_intersection = entry_step.intersections.front();
+    const auto exit_intersection = exit_step.intersections.front();
+    const auto entry_intersection = entry_step.intersections.front();
    if ((exit_intersection.out >= exit_intersection.bearings.size()) ||
        (entry_intersection.in >= entry_intersection.bearings.size()))
        return entry_intersection.bearings[entry_intersection.out];
@@ -3,7 +3,7 @@

 #include "engine/guidance/route_step.hpp"

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

 #include <string>
 #include <vector>
@@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"

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

 namespace osrm::engine
@@ -42,7 +42,7 @@ struct PathData
    // Source of the speed value on this road segment
    DatasourceID datasource_id;
    // If segment precedes a turn, ID of the turn itself
-    std::optional<EdgeID> turn_edge;
+    boost::optional<EdgeID> turn_edge;
 };

 struct InternalRouteResult
@@ -214,7 +214,7 @@ struct PhantomNode
    util::Coordinate input_location;
    unsigned short fwd_segment_position;
    // is phantom node valid to be used as source or target
-  private:
+    // private:
    unsigned short is_valid_forward_source : 1;
    unsigned short is_valid_forward_target : 1;
    unsigned short is_valid_reverse_source : 1;
@@ -22,7 +22,7 @@ class MatchPlugin : public BasePlugin

    MatchPlugin(const int max_locations_map_matching,
                const double max_radius_map_matching,
-                const std::optional<double> default_radius)
+                const boost::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_map_matching(max_locations_map_matching),
          max_radius_map_matching(max_radius_map_matching)
    {
@@ -13,7 +13,7 @@ namespace osrm::engine::plugins
 class NearestPlugin final : public BasePlugin
 {
  public:
-    explicit NearestPlugin(const int max_results, const std::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const boost::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::NearestParameters &params,
@@ -29,7 +29,7 @@ class BasePlugin
  protected:
    BasePlugin() = default;

-    BasePlugin(const std::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const boost::optional<double> default_radius_) : default_radius(default_radius_) {}

    bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
    {
@@ -200,8 +200,8 @@ class BasePlugin
            phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                parameters.coordinates[i],
                radiuses[i],
-                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);
        }
@@ -242,8 +242,8 @@ class BasePlugin
                parameters.coordinates[i],
                number_of_results,
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : engine::Approach::UNRESTRICTED);

            // we didn't find a fitting node, return error
@@ -284,8 +284,8 @@ class BasePlugin
            alternatives[i] = facade.NearestCandidatesWithAlternativeFromBigComponent(
                parameters.coordinates[i],
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : std::nullopt,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_bearings ? parameters.bearings[i] : boost::none,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);

@@ -325,7 +325,7 @@ class BasePlugin
               std::to_string(missing_index);
    }

-    const std::optional<double> default_radius;
+    const boost::optional<double> default_radius;
 };
 } // namespace osrm::engine::plugins

@@ -15,7 +15,7 @@ class TablePlugin final : public BasePlugin
 {
  public:
    explicit TablePlugin(const int max_locations_distance_table,
-                         const std::optional<double> default_radius);
+                         const boost::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::TableParameters &params,
@@ -32,7 +32,7 @@ class TripPlugin final : public BasePlugin
                                     const bool roundtrip) const;

  public:
-    explicit TripPlugin(const int max_locations_trip_, std::optional<double> default_radius)
+    explicit TripPlugin(const int max_locations_trip_, boost::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_trip(max_locations_trip_)
    {
    }
@@ -27,7 +27,7 @@ class ViaRoutePlugin final : public BasePlugin
  public:
    explicit ViaRoutePlugin(int max_locations_viaroute,
                            int max_alternatives,
-                            std::optional<double> default_radius);
+                            boost::optional<double> default_radius);

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

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

 // Decodes geometry from polyline format
@@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface

    virtual InternalRouteResult
    ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const std::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const boost::optional<bool> continue_straight_at_waypoint) const = 0;

    virtual InternalRouteResult
    DirectShortestPathSearch(const PhantomEndpointCandidates &endpoint_candidates) const = 0;
@@ -40,7 +40,7 @@ class RoutingAlgorithmsInterface
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const = 0;

    virtual std::vector<routing_algorithms::TurnData>
@@ -78,7 +78,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo

    InternalRouteResult ShortestPathSearch(
        const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-        const std::optional<bool> continue_straight_at_waypoint) const final override;
+        const boost::optional<bool> continue_straight_at_waypoint) const final override;

    InternalRouteResult DirectShortestPathSearch(
        const PhantomEndpointCandidates &endpoint_candidates) const final override;
@@ -93,7 +93,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const final override;

    std::vector<routing_algorithms::TurnData>
@@ -160,7 +160,7 @@ InternalManyRoutesResult RoutingAlgorithms<Algorithm>::AlternativePathSearch(
 template <typename Algorithm>
 InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-    const std::optional<bool> continue_straight_at_waypoint) const
+    const boost::optional<bool> continue_straight_at_waypoint) const
 {
    return routing_algorithms::shortestPathSearch(
        heaps, *facade, waypoint_candidates, continue_straight_at_waypoint);
@@ -178,7 +178,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
    const routing_algorithms::CandidateLists &candidates_list,
    const std::vector<util::Coordinate> &trace_coordinates,
    const std::vector<unsigned> &trace_timestamps,
-    const std::vector<std::optional<double>> &trace_gps_precision,
+    const std::vector<boost::optional<double>> &trace_gps_precision,
    const bool allow_splitting) const
 {
    return routing_algorithms::mapMatching(heaps,
@@ -24,7 +24,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                            const CandidateLists &candidates_list,
                            const std::vector<util::Coordinate> &trace_coordinates,
                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<std::optional<double>> &trace_gps_precision,
+                            const std::vector<boost::optional<double>> &trace_gps_precision,
                            const bool allow_splitting);

 } // namespace osrm::engine::routing_algorithms
@@ -258,7 +258,7 @@ void annotatePath(const FacadeT &facade,
                                             alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                                             {0},
                                             datasource_vector[segment_idx],
-                                             std::nullopt});
+                                             boost::none});
        }
        BOOST_ASSERT(!unpacked_path.empty());

@@ -315,7 +315,7 @@ void annotatePath(const FacadeT &facade,
                     alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                     {0},
                     datasource_vector[segment_idx],
-                     std::nullopt});
+                     boost::none});
    }

    if (!unpacked_path.empty())
@@ -471,6 +471,23 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                          const PhantomNode &target_phantom,
                          EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT);

+inline double getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
+                                    const DataFacade<ch::Algorithm> &facade,
+                                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                                    const PhantomNode &source_phantom,
+                                    const PhantomNode &target_phantom,
+                                    EdgeWeight duration_upper_bound = INVALID_EDGE_WEIGHT)
+{
+    return getNetworkDistance(engine_working_data,
+                              facade,
+                              forward_heap,
+                              reverse_heap,
+                              source_phantom,
+                              target_phantom,
+                              duration_upper_bound);
+}
+
 template <typename EdgeMetric>
 std::tuple<EdgeMetric, EdgeDistance> getLoopMetric(const DataFacade<Algorithm> &facade, NodeID node)
 {
@@ -487,13 +487,7 @@ void routingStep(const DataFacade<Algorithm> &facade,

 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-
-struct UnpackedPath
-{
-    EdgeWeight weight;
-    UnpackedNodes nodes;
-    UnpackedEdges edges;
-};
+using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;

 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -503,7 +497,7 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
                                                       EdgeWeight weight_upper_bound,
                                                       const Args &...args)
 {
-    if (forward_heap.Empty() || reverse_heap.Empty())
+    if (forward_heap.Empty() && reverse_heap.Empty())
    {
        return {};
    }
@@ -516,9 +510,19 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
    EdgeWeight weight = weight_upper_bound;
    EdgeWeight forward_heap_min = forward_heap.MinKey();
    EdgeWeight reverse_heap_min = reverse_heap.MinKey();
+// if (!reverse_heap.Empty())
+//     reverse_heap_min = reverse_heap.MinKey();
+#if 0
+    while (forward_heap.Size() + reverse_heap.Size() > 0 && (
+           forward_heap_min < weight || reverse_heap_min < weight))
+#else
    while (forward_heap.Size() + reverse_heap.Size() > 0 &&
-           forward_heap_min + reverse_heap_min < weight)
+           (forward_heap_min + reverse_heap_min < weight))
+#endif
    {
+        // std::cerr << "F: " << forward_heap_min << " R: " << reverse_heap_min << " W: " << weight
+        // << std::endl;
+
        if (!forward_heap.Empty())
        {
            routingStep<FORWARD_DIRECTION>(
@@ -535,12 +539,21 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
        }
    };

+    // while (!reverse_heap.Empty() && (reverse_heap_min < weight)) {
+    //     routingStep<REVERSE_DIRECTION>(
+    //         facade, reverse_heap, forward_heap, middle, weight, force_step_nodes, args...);
+    //     if (!reverse_heap.Empty())
+    //         reverse_heap_min = reverse_heap.MinKey();
+    // }
+
    // No path found for both target nodes?
    if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
    {
        return {};
    }

+    std::cerr << "MIDDLE = " << middle << std::endl;
+
    return {{middle, weight}};
 }

@@ -557,7 +570,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
    if (!searchResult)
    {
-        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
    }

    auto [middle, weight] = *searchResult;
@@ -601,27 +614,25 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
            forward_heap.Insert(source, {0}, {source});
            reverse_heap.Insert(target, {0}, {target});

-            auto unpacked_subpath = search(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           force_step_nodes,
-                                           INVALID_EDGE_WEIGHT,
-                                           sublevel,
-                                           parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
-                                  std::next(unpacked_subpath.nodes.begin()),
-                                  unpacked_subpath.nodes.end());
-            unpacked_edges.insert(
-                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
+                                                                         facade,
+                                                                         forward_heap,
+                                                                         reverse_heap,
+                                                                         force_step_nodes,
+                                                                         INVALID_EDGE_WEIGHT,
+                                                                         sublevel,
+                                                                         parent_cell_id);
+            BOOST_ASSERT(!subpath_edges.empty());
+            BOOST_ASSERT(subpath_nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.back() == target);
+            unpacked_nodes.insert(
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
        }
    }

-    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }

 template <typename Algorithm, typename... Args>
@@ -642,8 +653,8 @@ searchDistance(SearchEngineData<Algorithm> &,
        return INVALID_EDGE_DISTANCE;
    }

-    auto [middle, _] = *searchResult;
-
+    auto [middle, weight] = *searchResult;
+    // std::cerr << "W: " << weight << std::endl;
    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;

    return distance;
@@ -662,15 +673,13 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                   const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
    // TODO: change search calling interface to use unpacked_edges result
-    auto unpacked_path = search(engine_working_data,
-                                facade,
-                                forward_heap,
-                                reverse_heap,
-                                force_step_nodes,
-                                weight_upper_bound,
-                                endpoints);
-    weight = unpacked_path.weight;
-    unpacked_nodes = std::move(unpacked_path.nodes);
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
+                                                           facade,
+                                                           forward_heap,
+                                                           reverse_heap,
+                                                           force_step_nodes,
+                                                           weight_upper_bound,
+                                                           endpoints);
 }

 // TODO: refactor CH-related stub to use unpacked_edges
@@ -714,41 +723,148 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                          const PhantomNode &target_phantom,
                          EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
-    forward_heap.Clear();
    reverse_heap.Clear();
+    // forward_heap.Clear();
+
+    // if (forward_heap.Empty())
+    // {
+    //     if (source_phantom.IsValidForwardSource())
+    //     {
+    //         forward_heap.Insert(source_phantom.forward_segment_id.id,
+    //                             EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
+    //                             {source_phantom.forward_segment_id.id,
+    //                              false,
+    //                              EdgeDistance{0} - source_phantom.GetForwardDistance()});
+    //     }
+
+    //     if (source_phantom.IsValidReverseSource())
+    //     {
+    //         forward_heap.Insert(source_phantom.reverse_segment_id.id,
+    //                             EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
+    //                             {source_phantom.reverse_segment_id.id,
+    //                              false,
+    //                              EdgeDistance{0} - source_phantom.GetReverseDistance()});
+    //     }
+    // } else {
+    //     const auto node =
+    //     forward_heap.GetHeapNodeIfWasInserted(target_phantom.forward_segment_id.id); if (node) {
+    //         std::cerr << "Found " << target_phantom.forward_segment_id.id << " in forward_heap "
+    //         << node->data.distance <<  std::endl;
+    //     }
+    // }
+
+    //  forward_heap.Clear();
+    if (forward_heap.Empty())
+    {
+        if (source_phantom.IsValidForwardSource())
+        {
+            forward_heap.Insert(source_phantom.forward_segment_id.id,
+                                EdgeWeight{0},
+                                {source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
+        }
+
+        if (source_phantom.IsValidReverseSource())
+        {
+            forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                                EdgeWeight{0},
+                                {source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
+        }
+    }
+    else
+    {
+        if (target_phantom.IsValidForwardTarget())
+        {
+            if (forward_heap.WasInserted(target_phantom.forward_segment_id.id))
+            {
+                std::cerr << "Found " << target_phantom.forward_segment_id.id << " in forward_heap"
+                          << std::endl;
+            }
+            else
+            {
+                std::cerr << "Not found " << target_phantom.forward_segment_id.id
+                          << " in forward_heap" << std::endl;
+            }
+        }
+        if (target_phantom.IsValidReverseTarget())
+        {
+            if (forward_heap.WasInserted(target_phantom.reverse_segment_id.id))
+            {
+                std::cerr << "Found " << target_phantom.reverse_segment_id.id << " in forward_heap"
+                          << std::endl;
+            }
+            else
+            {
+                std::cerr << "Not found " << target_phantom.reverse_segment_id.id
+                          << " in forward_heap" << std::endl;
+            }
+        }
+    }
+
+    if (target_phantom.IsValidForwardTarget())
+    {
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
+    }
+
+    if (target_phantom.IsValidReverseTarget())
+    {
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
+    }
+
+    const PhantomEndpoints endpoints{source_phantom, target_phantom};
+
+    auto distance = searchDistance(
+        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
+
+    if (distance == INVALID_EDGE_DISTANCE)
+    {
+        return std::numeric_limits<double>::max();
+    }
+    return from_alias<double>(distance);
+}
+
+template <typename Algorithm>
+double
+getNetworkDistanceOld(SearchEngineData<Algorithm> &engine_working_data,
+                      const DataFacade<Algorithm> &facade,
+                      typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+                      typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
+                      const PhantomNode &source_phantom,
+                      const PhantomNode &target_phantom,
+                      EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
+{
+    reverse_heap.Clear();
+    forward_heap.Clear();

    if (source_phantom.IsValidForwardSource())
    {
        forward_heap.Insert(source_phantom.forward_segment_id.id,
-                            EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
-                            {source_phantom.forward_segment_id.id,
-                             false,
-                             EdgeDistance{0} - source_phantom.GetForwardDistance()});
+                            EdgeWeight{0},
+                            {source_phantom.forward_segment_id.id, false, EdgeDistance{0}});
    }

    if (source_phantom.IsValidReverseSource())
    {
        forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                            EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
-                            {source_phantom.reverse_segment_id.id,
-                             false,
-                             EdgeDistance{0} - source_phantom.GetReverseDistance()});
+                            EdgeWeight{0},
+                            {source_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
    }

    if (target_phantom.IsValidForwardTarget())
    {
-        reverse_heap.Insert(
-            target_phantom.forward_segment_id.id,
-            target_phantom.GetForwardWeightPlusOffset(),
-            {target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.forward_segment_id.id, false, EdgeDistance{0}});
    }

    if (target_phantom.IsValidReverseTarget())
    {
-        reverse_heap.Insert(
-            target_phantom.reverse_segment_id.id,
-            target_phantom.GetReverseWeightPlusOffset(),
-            {target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            EdgeWeight{0},
+                            {target_phantom.reverse_segment_id.id, false, EdgeDistance{0}});
    }

    const PhantomEndpoints endpoints{source_phantom, target_phantom};
@@ -14,7 +14,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const std::optional<bool> continue_straight_at_waypoint);
+                   const boost::optional<bool> continue_straight_at_waypoint);

 } // namespace osrm::engine::routing_algorithms

@@ -4,7 +4,7 @@
 #include "engine/routing_algorithms/shortest_path.hpp"

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

 namespace osrm::engine::routing_algorithms
 {
@@ -339,10 +339,10 @@ struct leg_connections
 {
    // X_to_Y = i can be read as
    // sources[i].X is the source of the shortest leg path to target.Y
-    std::optional<size_t> forward_to_forward;
-    std::optional<size_t> reverse_to_forward;
-    std::optional<size_t> forward_to_reverse;
-    std::optional<size_t> reverse_to_reverse;
+    boost::optional<size_t> forward_to_forward;
+    boost::optional<size_t> reverse_to_forward;
+    boost::optional<size_t> forward_to_reverse;
+    boost::optional<size_t> reverse_to_reverse;
 };

 // Identify which of the source candidates segments is being used for paths to the
@@ -771,7 +771,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const std::optional<bool> continue_straight_at_waypoint)
+                   const boost::optional<bool> continue_straight_at_waypoint)
 {
    const bool allow_uturn_at_waypoint =
        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
@@ -28,12 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP

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

 #include <array>
-#include <filesystem>
 #include <string>

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -135,9 +136,9 @@ void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordi

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@@ -1,13 +1,13 @@
 #ifndef OSRM_LOCATION_DEPENDENT_DATA_HPP
 #define OSRM_LOCATION_DEPENDENT_DATA_HPP

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

 #include <osmium/osm/way.hpp>

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

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

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

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

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

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

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

-#include <filesystem>
+#include <boost/filesystem/path.hpp>
+
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -7,13 +7,14 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
 #include <boost/foreach.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/qi_int.hpp>

 #include <storage/io.hpp>

-#include <filesystem>
 #include <iterator>
 #include <string>
 #include <unordered_map>
@@ -39,7 +40,7 @@ struct RasterDatum
 class RasterGrid
 {
  public:
-    RasterGrid(const std::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
    {
        xdim = _xdim;
        ydim = _ydim;
@@ -70,7 +70,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment

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

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

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

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

 namespace osrm::extractor
@@ -10,16 +10,12 @@

 #include <boost/assert.hpp>

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

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

 // writes .osrm.edges
 template <typename TurnDataT>
-inline void writeTurnData(const std::filesystem::path &path,
+inline void writeTurnData(const boost::filesystem::path &path,
                          const TurnDataT &turn_data,
                          const std::uint32_t connectivity_checksum)
 {
@@ -21,7 +21,7 @@
 #include <napi.h>

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

 #include <algorithm>
 #include <iterator>
@@ -395,11 +395,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
    return engine_config;
 }

-inline std::optional<std::vector<osrm::Coordinate>>
+inline boost::optional<std::vector<osrm::Coordinate>>
 parseCoordinateArray(const Napi::Array &coordinates_array)
 {
    Napi::HandleScope scope(coordinates_array.Env());
-    std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
+    boost::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
    std::vector<osrm::Coordinate> temp_coordinates;

    for (uint32_t i = 0; i < coordinates_array.Length(); ++i)
@@ -450,7 +450,7 @@ parseCoordinateArray(const Napi::Array &coordinates_array)
                                      osrm::util::FloatLatitude{std::move(lat)});
    }

-    resulting_coordinates = std::make_optional(std::move(temp_coordinates));
+    resulting_coordinates = boost::make_optional(std::move(temp_coordinates));
    return resulting_coordinates;
 }

@@ -1023,7 +1023,7 @@ inline bool parseCommonParameters(const Napi::Object &obj, ParamType &params)

 inline PluginParameters argumentsToPluginParameters(
    const Napi::CallbackInfo &args,
-    const std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
+    const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
 {
    if (args.Length() < 3 || !args[1].IsObject())
    {
@@ -173,8 +173,8 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
                {
                    const auto &data = edge_based_graph.GetEdgeData(edge);
-                    // we only need to save the forward edges, since the read method
-                    // will convert from forward to bi-directional edges again
+                    // we only need to save the forward edges, since the read method will
+                    // convert from forward to bi-directional edges again
                    if (data.forward)
                    {
                        auto target = edge_based_graph.GetTarget(edge);
@@ -191,7 +191,7 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
    return edges;
 }

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

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

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

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

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

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

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

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

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

-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
@@ -7,9 +7,9 @@
 #include "engine/hint.hpp"
 #include "engine/polyline_compressor.hpp"

+#include <boost/optional.hpp>
 #include <boost/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
-#include <optional>

 #include <limits>
 #include <string>
@@ -88,7 +88,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            }
            else
            {
-                base_parameters.hints.emplace_back(std::nullopt);
+                base_parameters.hints.emplace_back(boost::none);
            }
        };

@@ -96,24 +96,13 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            [](engine::api::BaseParameters &base_parameters,
               boost::optional<boost::fusion::vector2<short, short>> bearing_range)
        {
-            std::optional<engine::Bearing> bearing;
+            boost::optional<engine::Bearing> bearing;
            if (bearing_range)
            {
                bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
                                          boost::fusion::at_c<1>(*bearing_range)};
            }
-            base_parameters.bearings.push_back(bearing);
-        };
-
-        const auto add_approach = [](engine::api::BaseParameters &base_parameters,
-                                     boost::optional<osrm::engine::Approach> approach) {
-            base_parameters.approaches.push_back(approach ? std::make_optional(*approach)
-                                                          : std::nullopt);
-        };
-
-        const auto add_radius = [](engine::api::BaseParameters &base_parameters,
-                                   boost::optional<double> radius) {
-            base_parameters.radiuses.push_back(radius ? std::make_optional(*radius) : std::nullopt);
+            base_parameters.bearings.push_back(std::move(bearing));
        };

        polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\%~`^");
@@ -155,9 +144,9 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            ((location_rule % ';') | polyline_rule |
             polyline6_rule)[ph::bind(&engine::api::BaseParameters::coordinates, qi::_r1) = qi::_1];

-        radiuses_rule =
-            qi::lit("radiuses=") >
-            (-(qi::double_ | unlimited_rule))[ph::bind(add_radius, qi::_r1, qi::_1)] % ';';
+        radiuses_rule = qi::lit("radiuses=") >
+                        (-(qi::double_ | unlimited_rule) %
+                         ';')[ph::bind(&engine::api::BaseParameters::radiuses, qi::_r1) = qi::_1];

        hints_rule =
            qi::lit("hints=") >
@@ -181,7 +170,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            "curb", engine::Approach::CURB)("opposite", engine::Approach::OPPOSITE);

        approach_rule = qi::lit("approaches=") >
-                        (-approach_type)[ph::bind(add_approach, qi::_r1, qi::_1)] % ';';
+                        (-approach_type %
+                         ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];

        snapping_type.add("default", engine::api::BaseParameters::SnappingType::Default)(
            "any", engine::api::BaseParameters::SnappingType::Any);
@@ -26,13 +26,13 @@ using is_parameter_t =
 // Starts parsing and iter and modifies it until iter == end or parsing failed
 template <typename ParameterT,
          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-std::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                          const std::string::iterator end);
+boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
+                                            const std::string::iterator end);

 // Copy on purpose because we need mutability
 template <typename ParameterT,
          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-std::optional<ParameterT> parseParameters(std::string options_string)
+boost::optional<ParameterT> parseParameters(std::string options_string)
 {
    auto first = options_string.begin();
    const auto last = options_string.end();
@@ -3,7 +3,7 @@

 #include "server/api/parsed_url.hpp"

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

 #include <string>

@@ -11,9 +11,9 @@ namespace osrm::server::api
 {

 // Starts parsing and iter and modifies it until iter == end or parsing failed
-std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
+boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);

-inline std::optional<ParsedURL> parseURL(std::string url_string)
+inline boost::optional<ParsedURL> parseURL(std::string url_string)
 {
    auto iter = url_string.begin();
    return parseURL(iter, url_string.end());
@@ -10,13 +10,14 @@
 #include "util/log.hpp"
 #include "util/version.hpp"

+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
 #include <boost/iostreams/device/array.hpp>
 #include <boost/iostreams/seek.hpp>
 #include <boost/iostreams/stream.hpp>
+
 #include <cerrno>
 #include <cstring>
-#include <filesystem>
-#include <fstream>
 #include <iostream>
 #include <tuple>
 #include <type_traits>
@@ -34,11 +35,11 @@ class FileReader
    };

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

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

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

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

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

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

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

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

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

 #include "util/exception.hpp"

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

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

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

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

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

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

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

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

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

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

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

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

    template <typename IdentifierT>
-    SharedMemory(const std::filesystem::path &lock_file,
+    SharedMemory(const boost::filesystem::path &lock_file,
                 const IdentifierT id,
                 const uint64_t size = 0)
        : key(lock_file.string().c_str(), id)
@@ -202,7 +202,7 @@ class SharedMemory
    void *Ptr() const { return region.get_address(); }
    std::size_t Size() const { return region.get_size(); }

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

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

 namespace osrm::storage
 {

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

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

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

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

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

 namespace osrm::storage
 {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -100,7 +100,7 @@ template <typename Key, typename Value> struct CSVFilesParser
        std::vector<std::pair<Key, Value>> result;
        try
        {
-            if (std::filesystem::file_size(filename) == 0)
+            if (boost::filesystem::file_size(filename) == 0)
                return result;

            boost::iostreams::mapped_file_source mmap(filename);
@@ -28,13 +28,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OSRM_UPDATER_UPDATER_CONFIG_HPP
 #define OSRM_UPDATER_UPDATER_CONFIG_HPP

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

 #include <chrono>
-#include <filesystem>
 #include <string>

+#include "storage/io_config.hpp"
+#include "storage/storage_config.hpp"
+
 namespace osrm::updater
 {

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

-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
@@ -1,40 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <boost/assert.hpp>
-#include <vector>
-
-namespace osrm::util
-{
-
-// in its essence it is std::priority_queue, but with `clear` method
-template <typename T> class BinaryHeap
-{
-  public:
-    bool empty() const { return heap_.empty(); }
-
-    const T &top() const
-    {
-        BOOST_ASSERT(!heap_.empty());
-        return heap_.front();
-    }
-
-    void pop()
-    {
-        BOOST_ASSERT(!heap_.empty());
-        std::pop_heap(heap_.begin(), heap_.end());
-        heap_.pop_back();
-    }
-
-    template <typename... Args> void emplace(Args &&...args)
-    {
-        heap_.emplace_back(std::forward<Args>(args)...);
-        std::push_heap(heap_.begin(), heap_.end());
-    }
-
-    void clear() { heap_.clear(); }
-
-  private:
-    std::vector<T> heap_;
-};
-
-} // namespace osrm::util
@@ -8,7 +8,7 @@ extern "C"
 #include <lualib.h>
 }

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

 #include <string>

@@ -20,7 +20,7 @@ namespace osrm::util
 // See http://lua-users.org/wiki/PackagePath for details on the package.path syntax.
 inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name)
 {
-    std::filesystem::path profile_path = std::filesystem::canonical(file_name);
+    boost::filesystem::path profile_path = boost::filesystem::canonical(file_name);
    std::string folder = profile_path.parent_path().generic_string();
    const std::string lua_code = "package.path = \"" + folder + "/?.lua;\" .. package.path";
    luaL_dostring(lua_state, lua_code.c_str());
@@ -5,22 +5,20 @@
 #include "util/exception_utils.hpp"
 #include "util/vector_view.hpp"

+#include <boost/filesystem/path.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>

-#include <filesystem>
-
 namespace osrm::util
 {

 namespace detail
 {
 template <typename T, typename MmapContainerT>
-util::vector_view<T> mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container)
+util::vector_view<T> mmapFile(const boost::filesystem::path &file, MmapContainerT &mmap_container)
 {
    try
    {
-        auto path_string = file.string();
-        mmap_container.open(path_string);
+        mmap_container.open(file);
        std::size_t num_objects = mmap_container.size() / sizeof(T);
        auto data_ptr = mmap_container.data();
        BOOST_ASSERT(reinterpret_cast<uintptr_t>(data_ptr) % alignof(T) == 0);
@@ -35,8 +33,9 @@ util::vector_view<T> mmapFile(const std::filesystem::path &file, MmapContainerT
 }

 template <typename T, typename MmapContainerT>
-util::vector_view<T>
-mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, const std::size_t size)
+util::vector_view<T> mmapFile(const boost::filesystem::path &file,
+                              MmapContainerT &mmap_container,
+                              const std::size_t size)
 {
    try
    {
@@ -62,21 +61,21 @@ mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, cons
 } // namespace detail

 template <typename T>
-util::vector_view<const T> mmapFile(const std::filesystem::path &file,
+util::vector_view<const T> mmapFile(const boost::filesystem::path &file,
                                    boost::iostreams::mapped_file_source &mmap_container)
 {
    return detail::mmapFile<const T>(file, mmap_container);
 }

 template <typename T>
-util::vector_view<T> mmapFile(const std::filesystem::path &file,
+util::vector_view<T> mmapFile(const boost::filesystem::path &file,
                              boost::iostreams::mapped_file &mmap_container)
 {
    return detail::mmapFile<T>(file, mmap_container);
 }

 template <typename T>
-util::vector_view<T> mmapFile(const std::filesystem::path &file,
+util::vector_view<T> mmapFile(const boost::filesystem::path &file,
                              boost::iostreams::mapped_file &mmap_container,
                              std::size_t size)
 {
@@ -15,7 +15,7 @@ namespace osrm::util
 using DataRange = std::pair<const char *, const char *>;
 using DataMap = std::unordered_map<std::string, DataRange>;

-inline DataMap mmapTarFile(const std::filesystem::path &path,
+inline DataMap mmapTarFile(const boost::filesystem::path &path,
                           boost::iostreams::mapped_file_source &region)
 {
    DataMap map;
@@ -2,9 +2,7 @@
 #define STATIC_RTREE_HPP

 #include "storage/tar_fwd.hpp"
-#include "osrm/coordinate.hpp"
 #include "util/bearing.hpp"
-#include "util/binary_heap.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/deallocating_vector.hpp"
 #include "util/exception.hpp"
@@ -17,9 +15,12 @@
 #include "util/vector_view.hpp"
 #include "util/web_mercator.hpp"

+#include "osrm/coordinate.hpp"
+
 #include "storage/shared_memory_ownership.hpp"

 #include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
 #include <boost/format.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>

@@ -29,7 +30,6 @@

 #include <algorithm>
 #include <array>
-#include <filesystem>
 #include <limits>
 #include <memory>
 #include <queue>
@@ -271,7 +271,7 @@ class StaticRTree
    // Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
    explicit StaticRTree(const std::vector<EdgeDataT> &input_data_vector,
                         const Vector<Coordinate> &coordinate_list,
-                         const std::filesystem::path &on_disk_file_name)
+                         const boost::filesystem::path &on_disk_file_name)
        : m_coordinate_list(coordinate_list.data(), coordinate_list.size())
    {
        const auto element_count = input_data_vector.size();
@@ -458,7 +458,7 @@ class StaticRTree
     * Constructs an empty RTree for de-serialization.
     */
    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
-    explicit StaticRTree(const std::filesystem::path &on_disk_file_name,
+    explicit StaticRTree(const boost::filesystem::path &on_disk_file_name,
                         const Vector<Coordinate> &coordinate_list)
        : m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
          m_objects(mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region))
@@ -473,7 +473,7 @@ class StaticRTree
     */
    explicit StaticRTree(Vector<TreeNode> search_tree_,
                         Vector<std::uint64_t> tree_level_starts,
-                         const std::filesystem::path &on_disk_file_name,
+                         const boost::filesystem::path &on_disk_file_name,
                         const Vector<Coordinate> &coordinate_list)
        : m_search_tree(std::move(search_tree_)),
          m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
@@ -554,12 +554,9 @@ class StaticRTree
        auto projected_coordinate = web_mercator::fromWGS84(input_coordinate);
        Coordinate fixed_projected_coordinate{projected_coordinate};

-        // we re-use queue for each query to avoid re-allocating memory
-        static thread_local util::BinaryHeap<QueryCandidate> traversal_queue;
-
-        traversal_queue.clear();
        // initialize queue with root element
-        traversal_queue.emplace(QueryCandidate{0, TreeIndex{}});
+        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.push(QueryCandidate{0, TreeIndex{}});

        while (!traversal_queue.empty())
        {
@@ -713,11 +710,10 @@ class StaticRTree
            // distance must be non-negative
            BOOST_ASSERT(0. <= squared_distance);
            BOOST_ASSERT(i < std::numeric_limits<std::uint32_t>::max());
-
-            traversal_queue.emplace(QueryCandidate{squared_distance,
-                                                   leaf_id,
-                                                   static_cast<std::uint32_t>(i),
-                                                   Coordinate{projected_nearest}});
+            traversal_queue.push(QueryCandidate{squared_distance,
+                                                leaf_id,
+                                                static_cast<std::uint32_t>(i),
+                                                Coordinate{projected_nearest}});
        }
    }

@@ -746,7 +742,7 @@ class StaticRTree
                child.minimum_bounding_rectangle.GetMinSquaredDist(
                    fixed_projected_input_coordinate);

-            traversal_queue.emplace(QueryCandidate{
+            traversal_queue.push(QueryCandidate{
                squared_lower_bound_to_element,
                TreeIndex(parent.level + 1, child_index - m_tree_level_starts[parent.level + 1])});
        }
@@ -3,13 +3,13 @@

 #include "util/log.hpp"

+#include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/index/rtree.hpp>

 #include <rapidjson/document.h>

 #include <chrono>
-#include <filesystem>
 #include <optional>

 namespace osrm::updater
@@ -32,7 +32,7 @@ class Timezoner
    Timezoner() = default;

    Timezoner(const char geojson[], std::time_t utc_time_now);
-    Timezoner(const std::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
+    Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);

    std::optional<struct tm> operator()(const point_t &point) const;

@@ -1,4 +1,5 @@
 import requests
+import sys
 import random
 from collections import defaultdict
 import os
@@ -7,13 +8,12 @@ import numpy as np
 import time
 import argparse

-
 class BenchmarkRunner:
-    def __init__(self, gps_traces_file_path):
+    def __init__(self):
        self.coordinates = []
        self.tracks = defaultdict(list)

-        gps_traces_file_path = os.path.expanduser(gps_traces_file_path)
+        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:
@@ -36,9 +36,10 @@ class BenchmarkRunner:
            response = requests.get(url)
            end_time = time.time()
            if response.status_code != 200:
-                code = response.json()['code']
-                if code in ['NoSegment', 'NoMatch', 'NoRoute', 'NoTrips']:
-                    continue
+                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
        
@@ -53,7 +54,7 @@ class BenchmarkRunner:
            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, 12)
+            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}"
@@ -76,63 +77,26 @@ class BenchmarkRunner:
        else:
            raise Exception(f"Unknown benchmark: {benchmark_name}")

-def bootstrap_confidence_interval(data, num_samples=1000, confidence_level=0.95):
-    means = []
-    for _ in range(num_samples):
-        sample = np.random.choice(data, size=len(data), replace=True)
-        means.append(np.mean(sample))
-    lower_bound = np.percentile(means, (1 - confidence_level) / 2 * 100)
-    upper_bound = np.percentile(means, (1 + confidence_level) / 2 * 100)
-    mean = np.mean(means)
-    return mean, lower_bound, upper_bound
-
-def calculate_confidence_interval(data, min_is_best=True):
-    mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(data) if min_is_best else np.max(data)
-    return mean, (upper - lower) / 2, min_value
-
-
 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')
-    parser.add_argument('--iterations', type=int, required=True, help='Number of iterations to run the benchmark')
-    parser.add_argument('--gps_traces_file_path', type=str, required=True, help='Path to the GPS traces file')

    args = parser.parse_args()

-    np.random.seed(42)
+    random.seed(42)

-    runner = BenchmarkRunner(args.gps_traces_file_path)
-    
-    all_times = []
-    for _ in range(args.iterations):
-        random.seed(42)
-        times = runner.run(args.method, args.host, args.num_requests)
-        all_times.append(times)
-    all_times = np.asarray(all_times)
+    runner = BenchmarkRunner()
+    times = runner.run(args.method, args.host, args.num_requests)

-    assert all_times.shape == (args.iterations, all_times.shape[1])
-
-
-    total_time, total_ci, total_best = calculate_confidence_interval(np.sum(all_times, axis=1))
-    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1), min_is_best=False)
-    min_time, min_ci, _ = calculate_confidence_interval(np.min(all_times, axis=1))
-    mean_time, mean_ci, _ = calculate_confidence_interval(np.mean(all_times, axis=1))
-    median_time, median_ci, _ = calculate_confidence_interval(np.median(all_times, axis=1))
-    perc_95_time, perc_95_ci, _ = calculate_confidence_interval(np.percentile(all_times, 95, axis=1))
-    perc_99_time, perc_99_ci, _ = calculate_confidence_interval(np.percentile(all_times, 99, axis=1))
-    max_time, max_ci, _ = calculate_confidence_interval(np.max(all_times, axis=1))
-
-    print(f'Ops: {ops_per_sec:.2f} ± {ops_per_sec_ci:.2f} ops/s. Best: {ops_per_sec_best:.2f} ops/s')
-    print(f'Total: {total_time:.2f}ms ± {total_ci:.2f}ms. Best: {total_best:.2f}ms')
-    print(f"Min time: {min_time:.2f}ms ± {min_ci:.2f}ms")
-    print(f"Mean time: {mean_time:.2f}ms ± {mean_ci:.2f}ms")
-    print(f"Median time: {median_time:.2f}ms ± {median_ci:.2f}ms")
-    print(f"95th percentile: {perc_95_time:.2f}ms ± {perc_95_ci:.2f}ms")
-    print(f"99th percentile: {perc_99_time:.2f}ms ± {perc_99_ci:.2f}ms")
-    print(f"Max time: {max_time:.2f}ms ± {max_ci:.2f}ms")
+    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()
@@ -1,121 +1,72 @@
 #!/bin/bash
 set -eou pipefail

-function usage {
-    echo "Usage: $0 -f <folder> -r <results_folder> -s <scripts_folder> -b <binaries_folder> -o <osm_pbf> -g <gps_traces>"
-    exit 1
-}
-
-while getopts ":f:r:s:b:o:g:" opt; do
-  case $opt in
-    f) FOLDER="$OPTARG"
-    ;;
-    r) RESULTS_FOLDER="$OPTARG"
-    ;;
-    s) SCRIPTS_FOLDER="$OPTARG"
-    ;;
-    b) BINARIES_FOLDER="$OPTARG"
-    ;;
-    o) OSM_PBF="$OPTARG"
-    ;;
-    g) GPS_TRACES="$OPTARG"
-    ;;
-    \?) echo "Invalid option -$OPTARG" >&2
-        usage
-    ;;
-    :) echo "Option -$OPTARG requires an argument." >&2
-        usage
-    ;;
-  esac
-done
-
-if [ -z "${FOLDER:-}" ] || [ -z "${RESULTS_FOLDER:-}" ] || [ -z "${SCRIPTS_FOLDER:-}" ] || [ -z "${BINARIES_FOLDER:-}" ] || [ -z "${OSM_PBF:-}" ] || [ -z "${GPS_TRACES:-}" ]; then
-    usage
-fi
-
 function measure_peak_ram_and_time {
    COMMAND=$1
    OUTPUT_FILE=$2
-    if [ "$(uname)" == "Darwin" ]; then
-        # on macOS time has different parameters, so simply run command on macOS
-        $COMMAND > /dev/null 2>&1
-    else
-        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
-    fi
+    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

-    BENCHMARKS_FOLDER="$BINARIES_FOLDER/src/benchmarks"
-    echo "Running match-bench MLD"
-    $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/match_mld.bench"
-    echo "Running match-bench CH"
-    $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/match_ch.bench"
-    echo "Running route-bench MLD"
-    $BENCHMARKS_FOLDER/route-bench "$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/route_mld.bench"
-    echo "Running route-bench CH"
-    $BENCHMARKS_FOLDER/route-bench "$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/route_ch.bench"
-    echo "Running alias"
-    $BENCHMARKS_FOLDER/alias-bench > "$RESULTS_FOLDER/alias.bench"
-    echo "Running json-render-bench"
-    $BENCHMARKS_FOLDER/json-render-bench  "$FOLDER/test/data/portugal_to_korea.json" > "$RESULTS_FOLDER/json-render.bench"
-    echo "Running packedvector-bench"
-    $BENCHMARKS_FOLDER/packedvector-bench > "$RESULTS_FOLDER/packedvector.bench"
-    echo "Running rtree-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"
+    BENCHMARKS_FOLDER="$FOLDER/build/src/benchmarks"

-    cp -rf $OSM_PBF $FOLDER/data.osm.pbf
+    ./$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"
+    ./$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

-    echo "Running osrm-extract"
    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-extract -p $FOLDER/profiles/car.lua $FOLDER/data.osm.pbf" "$RESULTS_FOLDER/osrm_extract.bench"
-    echo "Running osrm-partition"
    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-partition $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_partition.bench"
-    echo "Running osrm-customize"
    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-customize $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_customize.bench"
-    echo "Running osrm-contract"
    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-contract $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_contract.bench"

-    for ALGORITHM in ch mld; do
-        for BENCH in nearest table trip route match; do
-            echo "Running random $BENCH $ALGORITHM"
-            START=$(date +%s.%N)
-            $BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" $ALGORITHM $GPS_TRACES ${BENCH} > "$RESULTS_FOLDER/random_${BENCH}_${ALGORITHM}.bench" 5 || true
-            END=$(date +%s.%N)
-            DIFF=$(echo "$END - $START" | bc)
-            echo "Took: ${DIFF}s"
-        done
+    for BENCH in nearest table trip route match; do
+        ./$BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" mld ~/gps_traces.csv ${BENCH} > "$RESULTS_FOLDER/random_${BENCH}_mld.bench" || true
+        ./$BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" ch ~/gps_traces.csv ${BENCH}  > "$RESULTS_FOLDER/random_${BENCH}_ch.bench" || true
    done


    for ALGORITHM in ch mld; do
-        $BINARIES_FOLDER/osrm-routed --algorithm $ALGORITHM $FOLDER/data.osrm > /dev/null 2>&1 &
+        $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" > /dev/null 2>&1; then
+        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
-            echo "Running e2e benchmark for $METHOD $ALGORITHM"
-            START=$(date +%s.%N)
-            python3 $SCRIPTS_FOLDER/scripts/ci/e2e_benchmark.py --host http://localhost:5000 --method $METHOD --iterations 5 --num_requests 1000 --gps_traces_file_path $GPS_TRACES > $RESULTS_FOLDER/e2e_${METHOD}_${ALGORITHM}.bench
-            END=$(date +%s.%N)
-            DIFF=$(echo "$END - $START" | bc)
-            echo "Took: ${DIFF}s"
+            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
+run_benchmarks_for_folder $1 "${1}_results" $2
+run_benchmarks_for_folder $2 "${2}_results" $2

@@ -1,96 +0,0 @@
-@ECHO OFF
-SETLOCAL
-SET EL=0
-
-ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%
-
-SET PROJECT_DIR=%CD%
-SET CONFIGURATION=Release
-
-mkdir build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-cd build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-cmake -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "Visual Studio 17 2022" ..
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-msbuild OSRM.sln ^
-/p:Configuration=%CONFIGURATION% ^
-/p:Platform=x64 ^
-/p:nowarn="4244;4267;4365;4456;4514;4625;4626;4710;4711;4820;5026;5027" ^
-/t:rebuild ^
-/p:BuildInParallel=true ^
-/m:%NUMBER_OF_PROCESSORS% ^
-/toolsversion:Current ^
-/clp:Verbosity=quiet ^
-/nologo
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-CD %PROJECT_DIR%\build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running extractor-tests.exe ...
-unit_tests\%CONFIGURATION%\extractor-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running contractor-tests.exe ...
-unit_tests\%CONFIGURATION%\contractor-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running engine-tests.exe ...
-unit_tests\%CONFIGURATION%\engine-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running util-tests.exe ...
-unit_tests\%CONFIGURATION%\util-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running server-tests.exe ...
-unit_tests\%CONFIGURATION%\server-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running partitioner-tests.exe ...
-unit_tests\%CONFIGURATION%\partitioner-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO running customizer-tests.exe ...
-unit_tests\%CONFIGURATION%\customizer-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-SET test_region=monaco
-SET test_region_ch=ch\monaco
-SET test_region_corech=corech\monaco
-SET test_region_mld=mld\monaco
-SET test_osm=%test_region%.osm.pbf
-COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm%
-%CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-MKDIR ch
-XCOPY %test_region%.osrm.* ch\
-XCOPY %test_region%.osrm ch\
-MKDIR corech
-XCOPY %test_region%.osrm.* corech\
-XCOPY %test_region%.osrm corech\
-MKDIR mld
-XCOPY %test_region%.osrm.* mld\
-XCOPY %test_region%.osrm mld\
-%CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
-%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
-%CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
-%CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
-XCOPY /Y ch\*.* ..\test\data\ch\
-XCOPY /Y corech\*.* ..\test\data\corech\
-XCOPY /Y mld\*.* ..\test\data\mld\
-unit_tests\%CONFIGURATION%\library-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-:ERROR
-ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-ECHO ERRORLEVEL^: %ERRORLEVEL%
-SET EL=%ERRORLEVEL%
-
-:DONE
-ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-EXIT /b %EL%
@@ -45,12 +45,8 @@ class GPSTraces
    std::vector<osrm::util::Coordinate> coordinates;
    mutable std::mt19937 gen;

-    int seed;
-
  public:
-    GPSTraces(int seed) : gen(std::random_device{}()), seed(seed) { gen.seed(seed); }
-
-    void resetSeed() const { gen.seed(seed); }
+    GPSTraces(int seed) : gen(std::random_device{}()) { gen.seed(seed); }

    bool readCSV(const std::string &filename)
    {
@@ -105,203 +101,75 @@ class GPSTraces
        return coordinates[dis(gen)];
    }

-    std::vector<osrm::util::Coordinate> getRandomTrace() const
+    const std::vector<osrm::util::Coordinate> &getRandomTrace() const
    {
        std::uniform_int_distribution<> dis(0, trackIDs.size() - 1);
        auto it = trackIDs.begin();
        std::advance(it, dis(gen));
-
-        const auto &trace = traces.at(*it);
-
-        std::uniform_int_distribution<> length_dis(50, 100);
-        size_t length = length_dis(gen);
-        if (trace.size() <= length + 1)
-        {
-            return trace;
-        }
-
-        std::uniform_int_distribution<> start_dis(0, trace.size() - length - 1);
-        size_t start_index = start_dis(gen);
-
-        return std::vector<osrm::util::Coordinate>(trace.begin() + start_index,
-                                                   trace.begin() + start_index + length);
+        return traces.at(*it);
    }
 };

-// Struct to hold confidence interval data
-struct ConfidenceInterval
-{
-    double mean;
-    double confidence;
-    double min;
-    double max;
-};
-
-// Helper function to calculate the bootstrap confidence interval
-ConfidenceInterval confidenceInterval(const std::vector<double> &data,
-                                      int num_samples = 1000,
-                                      double confidence_level = 0.95)
-{
-    std::vector<double> means;
-    std::default_random_engine generator;
-    std::uniform_int_distribution<int> distribution(0, data.size() - 1);
-
-    for (int i = 0; i < num_samples; ++i)
-    {
-        std::vector<double> sample;
-        for (size_t j = 0; j < data.size(); ++j)
-        {
-            sample.push_back(data[distribution(generator)]);
-        }
-        double sample_mean = std::accumulate(sample.begin(), sample.end(), 0.0) / sample.size();
-        means.push_back(sample_mean);
-    }
-
-    std::sort(means.begin(), means.end());
-    double lower_bound = means[(int)((1 - confidence_level) / 2 * num_samples)];
-    double upper_bound = means[(int)((1 + confidence_level) / 2 * num_samples)];
-    double mean = std::accumulate(means.begin(), means.end(), 0.0) / means.size();
-
-    ConfidenceInterval ci = {mean,
-                             (upper_bound - lower_bound) / 2,
-                             *std::min_element(data.begin(), data.end()),
-                             *std::max_element(data.begin(), data.end())};
-    return ci;
-}
-
 class Statistics
 {
  public:
-    explicit Statistics(int iterations) : times(iterations) {}
-
-    void push(double timeMs, int iteration) { times[iteration].push_back(timeMs); }
-
-    ConfidenceInterval mean()
+    void push(double timeMs)
    {
-        std::vector<double> means;
-        means.reserve(times.size());
-        for (const auto &iter_times : times)
-        {
-            means.push_back(std::accumulate(iter_times.begin(), iter_times.end(), 0.0) /
-                            iter_times.size());
-        }
-        return confidenceInterval(means);
+        times.push_back(timeMs);
+        sorted = false;
    }

-    ConfidenceInterval total()
+    double mean() { return sum() / times.size(); }
+
+    double sum()
    {
-        std::vector<double> sums;
-        sums.reserve(times.size());
-        for (const auto &iter_times : times)
+        double sum = 0;
+        for (auto time : times)
        {
-            sums.push_back(std::accumulate(iter_times.begin(), iter_times.end(), 0.0));
+            sum += time;
        }
-        return confidenceInterval(sums);
+        return sum;
    }

-    ConfidenceInterval min()
-    {
-        std::vector<double> mins;
-        mins.reserve(times.size());
-        for (const auto &iter_times : times)
-        {
-            mins.push_back(*std::min_element(iter_times.begin(), iter_times.end()));
-        }
-        return confidenceInterval(mins);
-    }
+    double min() { return *std::min_element(times.begin(), times.end()); }

-    ConfidenceInterval max()
-    {
-        std::vector<double> maxs;
-        maxs.reserve(times.size());
-        for (const auto &iter_times : times)
-        {
-            maxs.push_back(*std::max_element(iter_times.begin(), iter_times.end()));
-        }
-        return confidenceInterval(maxs);
-    }
+    double max() { return *std::max_element(times.begin(), times.end()); }

-    ConfidenceInterval percentile(double p)
+    double percentile(double p)
    {
-        std::vector<double> percentiles;
-        percentiles.reserve(times.size());
-        for (const auto &iter_times : times)
-        {
-            auto sorted_times = iter_times;
-            std::sort(sorted_times.begin(), sorted_times.end());
-            percentiles.push_back(sorted_times[static_cast<size_t>(p * sorted_times.size())]);
-        }
-        return confidenceInterval(percentiles);
-    }
-
-    ConfidenceInterval ops_per_sec()
-    {
-        std::vector<double> ops;
-        ops.reserve(times.size());
-        for (const auto &iter_times : times)
-        {
-            double total_time = std::accumulate(iter_times.begin(), iter_times.end(), 0.0) / 1000.0;
-            ops.push_back(iter_times.size() / total_time);
-        }
-        return confidenceInterval(ops);
+        const auto &times = getTimes();
+        return times[static_cast<size_t>(p * times.size())];
    }

  private:
-    // vector of times for each iteration
-    std::vector<std::vector<double>> times;
+    std::vector<double> getTimes()
+    {
+        if (!sorted)
+        {
+            std::sort(times.begin(), times.end());
+            sorted = true;
+        }
+        return times;
+    }
+
+    std::vector<double> times;
+
+    bool sorted = false;
 };

 std::ostream &operator<<(std::ostream &os, Statistics &statistics)
 {
    os << std::fixed << std::setprecision(2);
-
-    ConfidenceInterval mean_ci = statistics.mean();
-    ConfidenceInterval total_ci = statistics.total();
-    ConfidenceInterval min_ci = statistics.min();
-    ConfidenceInterval max_ci = statistics.max();
-    ConfidenceInterval p99_ci = statistics.percentile(0.99);
-    ConfidenceInterval ops_ci = statistics.ops_per_sec();
-
-    os << "ops: " << ops_ci.mean << " ± " << ops_ci.confidence << " ops/s. "
-       << "best: " << ops_ci.max << "ops/s." << std::endl;
-    os << "total: " << total_ci.mean << " ± " << total_ci.confidence << "ms. "
-       << "best: " << total_ci.min << "ms." << std::endl;
-    os << "avg: " << mean_ci.mean << " ± " << mean_ci.confidence << "ms" << std::endl;
-    os << "min: " << min_ci.mean << " ± " << min_ci.confidence << "ms" << std::endl;
-    os << "max: " << max_ci.mean << " ± " << max_ci.confidence << "ms" << std::endl;
-    os << "p99: " << p99_ci.mean << " ± " << p99_ci.confidence << "ms" << std::endl;
-
+    os << "total: " << statistics.sum() << "ms" << std::endl;
+    os << "avg: " << statistics.mean() << "ms" << std::endl;
+    os << "min: " << statistics.min() << "ms" << std::endl;
+    os << "max: " << statistics.max() << "ms" << std::endl;
+    os << "p99: " << statistics.percentile(0.99) << "ms" << std::endl;
    return os;
 }

-template <typename Benchmark, typename BenchmarkBody>
-void runBenchmarks(const std::vector<Benchmark> &benchmarks,
-                   int iterations,
-                   int opsPerIteration,
-                   const OSRM &osrm,
-                   const GPSTraces &gpsTraces,
-                   const BenchmarkBody &benchmarkBody)
+void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
-    for (const auto &benchmark : benchmarks)
-    {
-        Statistics statistics{iterations};
-        for (int iteration = 0; iteration < iterations; ++iteration)
-        {
-            gpsTraces.resetSeed();
-
-            for (int i = 0; i < opsPerIteration; ++i)
-            {
-                benchmarkBody(iteration, benchmark, osrm, gpsTraces, statistics);
-            }
-        }
-        std::cout << benchmark.name << std::endl;
-        std::cout << statistics << std::endl;
-    }
-}
-
-void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
-{
-
    struct Benchmark
    {
        std::string name;
@@ -311,83 +179,114 @@ void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
        std::optional<size_t> alternatives = std::nullopt;
        std::optional<double> radius = std::nullopt;
    };
+
+    auto run_benchmark = [&](const Benchmark &benchmark)
+    {
+        Statistics statistics;
+
+        auto NUM = 10000;
+        for (int i = 0; i < NUM; ++i)
+        {
+            RouteParameters params;
+            params.overview = benchmark.overview;
+            params.steps = benchmark.steps;
+
+            for (size_t i = 0; i < benchmark.coordinates; ++i)
+            {
+                params.coordinates.push_back(gpsTraces.getRandomCoordinate());
+            }
+
+            if (benchmark.alternatives)
+            {
+                params.alternatives = *benchmark.alternatives;
+            }
+
+            if (benchmark.radius)
+            {
+                params.radiuses = std::vector<boost::optional<double>>(
+                    params.coordinates.size(), boost::make_optional(*benchmark.radius));
+            }
+
+            engine::api::ResultT result = json::Object();
+            TIMER_START(routes);
+            const auto rc = osrm.Route(params, result);
+            TIMER_STOP(routes);
+
+            statistics.push(TIMER_MSEC(routes));
+
+            auto &json_result = std::get<json::Object>(result);
+            if (rc != Status::Ok || json_result.values.find("routes") == json_result.values.end())
+            {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
+                if (code != "NoSegment" && code != "NoRoute")
+                {
+                    throw std::runtime_error{"Couldn't route: " + code};
+                }
+            }
+        }
+        std::cout << benchmark.name << std::endl;
+        std::cout << statistics << std::endl;
+    };
+
    std::vector<Benchmark> benchmarks = {
-        {"1000 routes, 3 coordinates, no alternatives, overview=full, steps=true",
+        {"10000 routes, 3 coordinates, no alternatives, overview=full, steps=true",
         3,
         RouteParameters::OverviewType::Full,
         true,
         std::nullopt},
-        {"1000 routes, 2 coordinates, 3 alternatives, overview=full, steps=true",
+        {"10000 routes, 2 coordinates, no alternatives, overview=full, steps=true",
+         2,
+         RouteParameters::OverviewType::Full,
+         true,
+         std::nullopt},
+        {"10000 routes, 2 coordinates, 3 alternatives, overview=full, steps=true",
         2,
         RouteParameters::OverviewType::Full,
         true,
         3},
-        {"1000 routes, 3 coordinates, no alternatives, overview=false, steps=false",
+        {"10000 routes, 3 coordinates, no alternatives, overview=false, steps=false",
         3,
         RouteParameters::OverviewType::False,
         false,
         std::nullopt},
-        {"1000 routes, 2 coordinates, 3 alternatives, overview=false, steps=false",
+        {"10000 routes, 2 coordinates, no alternatives, overview=false, steps=false",
         2,
         RouteParameters::OverviewType::False,
         false,
-         3}};
+         std::nullopt},
+        {"10000 routes, 2 coordinates, 3 alternatives, overview=false, steps=false",
+         2,
+         RouteParameters::OverviewType::False,
+         false,
+         3},
+        {"10000 routes, 3 coordinates, no alternatives, overview=false, steps=false, radius=750",
+         3,
+         RouteParameters::OverviewType::False,
+         false,
+         std::nullopt,
+         750},
+        {"10000 routes, 2 coordinates, no alternatives, overview=false, steps=false, radius=750",
+         2,
+         RouteParameters::OverviewType::False,
+         false,
+         std::nullopt,
+         750},
+        {"10000 routes, 2 coordinates, 3 alternatives, overview=false, steps=false, radius=750",
+         2,
+         RouteParameters::OverviewType::False,
+         false,
+         3,
+         750}

-    runBenchmarks(benchmarks,
-                  iterations,
-                  1000,
-                  osrm,
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      RouteParameters params;
-                      params.overview = benchmark.overview;
-                      params.steps = benchmark.steps;
+    };

-                      for (size_t i = 0; i < benchmark.coordinates; ++i)
-                      {
-                          params.coordinates.push_back(gpsTraces.getRandomCoordinate());
-                      }
-
-                      if (benchmark.alternatives)
-                      {
-                          params.alternatives = *benchmark.alternatives;
-                      }
-
-                      if (benchmark.radius)
-                      {
-                          params.radiuses = std::vector<std::optional<double>>(
-                              params.coordinates.size(), std::make_optional(*benchmark.radius));
-                      }
-
-                      engine::api::ResultT result = json::Object();
-                      TIMER_START(routes);
-                      const auto rc = osrm.Route(params, result);
-                      TIMER_STOP(routes);
-
-                      auto &json_result = std::get<json::Object>(result);
-                      if (rc != Status::Ok ||
-                          json_result.values.find("routes") == json_result.values.end())
-                      {
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
-                          if (code != "NoSegment" && code != "NoRoute")
-                          {
-                              throw std::runtime_error{"Couldn't route: " + code};
-                          }
-                      }
-                      else
-                      {
-
-                          statistics.push(TIMER_MSEC(routes), iteration);
-                      }
-                  });
+    for (const auto &benchmark : benchmarks)
+    {
+        run_benchmark(benchmark);
+    }
 }

-void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
    struct Benchmark
    {
@@ -395,56 +294,59 @@ void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
        std::optional<size_t> radius = std::nullopt;
    };

-    std::vector<Benchmark> benchmarks = {{"500 matches, default radius"},
-                                         {"500 matches, radius=10", 10},
-                                         {"500 matches, radius=20", 20}};
+    auto run_benchmark = [&](const Benchmark &benchmark)
+    {
+        Statistics statistics;

-    runBenchmarks(benchmarks,
-                  iterations,
-                  500,
-                  osrm,
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      engine::api::ResultT result = json::Object();
+        auto NUM = 1000;
+        for (int i = 0; i < NUM; ++i)
+        {
+            engine::api::ResultT result = json::Object();

-                      engine::api::MatchParameters params;
-                      params.coordinates = gpsTraces.getRandomTrace();
-                      params.radiuses = {};
-                      if (benchmark.radius)
-                      {
-                          for (size_t index = 0; index < params.coordinates.size(); ++index)
-                          {
-                              params.radiuses.emplace_back(*benchmark.radius);
-                          }
-                      }
+            engine::api::MatchParameters params;
+            params.coordinates = gpsTraces.getRandomTrace();
+            params.radiuses = {};
+            if (benchmark.radius)
+            {
+                for (size_t index = 0; index < params.coordinates.size(); ++index)
+                {
+                    params.radiuses.emplace_back(*benchmark.radius);
+                }
+            }

-                      TIMER_START(match);
-                      const auto rc = osrm.Match(params, result);
-                      TIMER_STOP(match);
+            TIMER_START(match);
+            const auto rc = osrm.Match(params, result);
+            TIMER_STOP(match);

-                      auto &json_result = std::get<json::Object>(result);
-                      if (rc != Status::Ok ||
-                          json_result.values.find("matchings") == json_result.values.end())
-                      {
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
-                          if (code != "NoSegment" && code != "NoMatch")
-                          {
-                              throw std::runtime_error{"Couldn't route: " + code};
-                          }
-                      }
-                      else
-                      {
-                          statistics.push(TIMER_MSEC(match), iteration);
-                      }
-                  });
+            statistics.push(TIMER_MSEC(match));
+
+            auto &json_result = std::get<json::Object>(result);
+            if (rc != Status::Ok ||
+                json_result.values.find("matchings") == json_result.values.end())
+            {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
+                if (code != "NoSegment" && code != "NoMatch")
+                {
+                    throw std::runtime_error{"Couldn't route: " + code};
+                }
+            }
+        }
+
+        std::cout << benchmark.name << std::endl;
+        std::cout << statistics << std::endl;
+    };
+
+    std::vector<Benchmark> benchmarks = {{"1000 matches, default radius"},
+                                         {"1000 matches, radius=10", 10},
+                                         {"1000 matches, radius=20", 20}};
+
+    for (const auto &benchmark : benchmarks)
+    {
+        run_benchmark(benchmark);
+    }
 }

-void runNearestBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runNearestBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
    struct Benchmark
    {
@@ -452,52 +354,54 @@ void runNearestBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int itera
        std::optional<size_t> number_of_results = std::nullopt;
    };

+    auto run_benchmark = [&](const Benchmark &benchmark)
+    {
+        Statistics statistics;
+        auto NUM = 10000;
+        for (int i = 0; i < NUM; ++i)
+        {
+            engine::api::ResultT result = json::Object();
+            NearestParameters params;
+            params.coordinates.push_back(gpsTraces.getRandomCoordinate());
+
+            if (benchmark.number_of_results)
+            {
+                params.number_of_results = *benchmark.number_of_results;
+            }
+
+            TIMER_START(nearest);
+            const auto rc = osrm.Nearest(params, result);
+            TIMER_STOP(nearest);
+
+            statistics.push(TIMER_MSEC(nearest));
+
+            auto &json_result = std::get<json::Object>(result);
+            if (rc != Status::Ok ||
+                json_result.values.find("waypoints") == json_result.values.end())
+            {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
+                if (code != "NoSegment")
+                {
+                    throw std::runtime_error{"Couldn't find nearest point"};
+                }
+            }
+        }
+
+        std::cout << benchmark.name << std::endl;
+        std::cout << statistics << std::endl;
+    };
+
    std::vector<Benchmark> benchmarks = {{"10000 nearest, number_of_results=1", 1},
                                         {"10000 nearest, number_of_results=5", 5},
                                         {"10000 nearest, number_of_results=10", 10}};

-    runBenchmarks(benchmarks,
-                  iterations,
-                  10000,
-                  osrm,
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      engine::api::ResultT result = json::Object();
-                      NearestParameters params;
-                      params.coordinates.push_back(gpsTraces.getRandomCoordinate());
-
-                      if (benchmark.number_of_results)
-                      {
-                          params.number_of_results = *benchmark.number_of_results;
-                      }
-
-                      TIMER_START(nearest);
-                      const auto rc = osrm.Nearest(params, result);
-                      TIMER_STOP(nearest);
-
-                      auto &json_result = std::get<json::Object>(result);
-                      if (rc != Status::Ok ||
-                          json_result.values.find("waypoints") == json_result.values.end())
-                      {
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
-                          if (code != "NoSegment")
-                          {
-                              throw std::runtime_error{"Couldn't find nearest point"};
-                          }
-                      }
-                      else
-                      {
-                          statistics.push(TIMER_MSEC(nearest), iteration);
-                      }
-                  });
+    for (const auto &benchmark : benchmarks)
+    {
+        run_benchmark(benchmark);
+    }
 }

-void runTripBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runTripBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
    struct Benchmark
    {
@@ -505,52 +409,54 @@ void runTripBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iteratio
        size_t coordinates;
    };

+    auto run_benchmark = [&](const Benchmark &benchmark)
+    {
+        Statistics statistics;
+        auto NUM = 1000;
+        for (int i = 0; i < NUM; ++i)
+        {
+            engine::api::ResultT result = json::Object();
+            TripParameters params;
+            params.roundtrip = true;
+
+            for (size_t i = 0; i < benchmark.coordinates; ++i)
+            {
+                params.coordinates.push_back(gpsTraces.getRandomCoordinate());
+            }
+
+            TIMER_START(trip);
+            const auto rc = osrm.Trip(params, result);
+            TIMER_STOP(trip);
+
+            statistics.push(TIMER_MSEC(trip));
+
+            auto &json_result = std::get<json::Object>(result);
+            if (rc != Status::Ok || json_result.values.find("trips") == json_result.values.end())
+            {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
+                if (code != "NoSegment")
+                {
+                    throw std::runtime_error{"Couldn't find trip"};
+                }
+            }
+        }
+
+        std::cout << benchmark.name << std::endl;
+        std::cout << statistics << std::endl;
+    };
+
    std::vector<Benchmark> benchmarks = {
-        {"250 trips, 3 coordinates", 3},
-        {"250 trips, 5 coordinates", 5},
+        {"1000 trips, 3 coordinates", 3},
+        {"1000 trips, 4 coordinates", 4},
+        {"1000 trips, 5 coordinates", 5},
    };

-    runBenchmarks(benchmarks,
-                  iterations,
-                  250,
-                  osrm,
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      engine::api::ResultT result = json::Object();
-                      TripParameters params;
-                      params.roundtrip = true;
-
-                      for (size_t i = 0; i < benchmark.coordinates; ++i)
-                      {
-                          params.coordinates.push_back(gpsTraces.getRandomCoordinate());
-                      }
-
-                      TIMER_START(trip);
-                      const auto rc = osrm.Trip(params, result);
-                      TIMER_STOP(trip);
-
-                      auto &json_result = std::get<json::Object>(result);
-                      if (rc != Status::Ok ||
-                          json_result.values.find("trips") == json_result.values.end())
-                      {
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
-                          if (code != "NoSegment")
-                          {
-                              throw std::runtime_error{"Couldn't find trip"};
-                          }
-                      }
-                      else
-                      {
-                          statistics.push(TIMER_MSEC(trip), iteration);
-                      }
-                  });
+    for (const auto &benchmark : benchmarks)
+    {
+        run_benchmark(benchmark);
+    }
 }
-void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
    struct Benchmark
    {
@@ -558,46 +464,51 @@ void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
        size_t coordinates;
    };

+    auto run_benchmark = [&](const Benchmark &benchmark)
+    {
+        Statistics statistics;
+        auto NUM = 250;
+        for (int i = 0; i < NUM; ++i)
+        {
+            engine::api::ResultT result = json::Object();
+            TableParameters params;
+
+            for (size_t i = 0; i < benchmark.coordinates; ++i)
+            {
+                params.coordinates.push_back(gpsTraces.getRandomCoordinate());
+            }
+
+            TIMER_START(table);
+            const auto rc = osrm.Table(params, result);
+            TIMER_STOP(table);
+
+            statistics.push(TIMER_MSEC(table));
+
+            auto &json_result = std::get<json::Object>(result);
+            if (rc != Status::Ok ||
+                json_result.values.find("durations") == json_result.values.end())
+            {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
+                if (code != "NoSegment")
+                {
+                    throw std::runtime_error{"Couldn't compute table"};
+                }
+            }
+        }
+
+        std::cout << benchmark.name << std::endl;
+        std::cout << statistics << std::endl;
+    };
+
    std::vector<Benchmark> benchmarks = {{"250 tables, 3 coordinates", 3},
                                         {"250 tables, 25 coordinates", 25},
-                                         {"250 tables, 50 coordinates", 50}};
+                                         {"250 tables, 50 coordinates", 50},
+                                         {"250 tables, 100 coordinates", 100}};

-    runBenchmarks(benchmarks,
-                  iterations,
-                  250,
-                  osrm,
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      engine::api::ResultT result = json::Object();
-                      TableParameters params;
-
-                      for (size_t i = 0; i < benchmark.coordinates; ++i)
-                      {
-                          params.coordinates.push_back(gpsTraces.getRandomCoordinate());
-                      }
-
-                      TIMER_START(table);
-                      const auto rc = osrm.Table(params, result);
-                      TIMER_STOP(table);
-
-                      statistics.push(TIMER_MSEC(table), iteration);
-
-                      auto &json_result = std::get<json::Object>(result);
-                      if (rc != Status::Ok ||
-                          json_result.values.find("durations") == json_result.values.end())
-                      {
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
-                          if (code != "NoSegment")
-                          {
-                              throw std::runtime_error{"Couldn't compute table"};
-                          }
-                      }
-                  });
+    for (const auto &benchmark : benchmarks)
+    {
+        run_benchmark(benchmark);
+    }
 }

 } // namespace
@@ -605,11 +516,11 @@ void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
 int main(int argc, const char *argv[])
 try
 {
-    if (argc < 6)
+    if (argc < 5)
    {
-        std::cerr << "Usage: " << argv[0]
-                  << " data.osrm <mld|ch> <path to GPS traces.csv> "
-                     "<route|match|trip|table|nearest> <number_of_iterations>\n";
+        std::cerr
+            << "Usage: " << argv[0]
+            << " data.osrm <mld|ch> <path to GPS traces.csv> <route|match|trip|table|nearest>\n";
        return EXIT_FAILURE;
    }

@@ -626,29 +537,27 @@ try
    GPSTraces gpsTraces{42};
    gpsTraces.readCSV(argv[3]);

-    int iterations = std::stoi(argv[5]);
-
    const auto benchmarkToRun = std::string{argv[4]};

    if (benchmarkToRun == "route")
    {
-        runRouteBenchmark(osrm, gpsTraces, iterations);
+        runRouteBenchmark(osrm, gpsTraces);
    }
    else if (benchmarkToRun == "match")
    {
-        runMatchBenchmark(osrm, gpsTraces, iterations);
+        runMatchBenchmark(osrm, gpsTraces);
    }
    else if (benchmarkToRun == "nearest")
    {
-        runNearestBenchmark(osrm, gpsTraces, iterations);
+        runNearestBenchmark(osrm, gpsTraces);
    }
    else if (benchmarkToRun == "trip")
    {
-        runTripBenchmark(osrm, gpsTraces, iterations);
+        runTripBenchmark(osrm, gpsTraces);
    }
    else if (benchmarkToRun == "table")
    {
-        runTableBenchmark(osrm, gpsTraces, iterations);
+        runTableBenchmark(osrm, gpsTraces);
    }
    else
    {
@@ -254,7 +254,7 @@ try
                  << std::endl;
    };

-    for (auto radius : std::vector<std::optional<double>>{std::nullopt, 10.0})
+    for (auto radius : std::vector<std::optional<double>>{std::nullopt, 5.0, 10.0, 15.0, 30.0})
    {
        run_benchmark(radius);
    }
@@ -66,8 +66,8 @@ try

        if (benchmark.radius)
        {
-            params.radiuses = std::vector<std::optional<double>>(
-                params.coordinates.size(), std::make_optional(*benchmark.radius));
+            params.radiuses = std::vector<boost::optional<double>>(
+                params.coordinates.size(), boost::make_optional(*benchmark.radius));
        }

        TIMER_START(routes);
@@ -96,6 +96,12 @@ try
         RouteParameters::OverviewType::Full,
         true,
         std::nullopt},
+        {"1000 routes, 2 coordinates, no alternatives, overview=full, steps=true",
+         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
+          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
+         RouteParameters::OverviewType::Full,
+         true,
+         std::nullopt},
        {"1000 routes, 2 coordinates, 3 alternatives, overview=full, steps=true",
         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
@@ -109,12 +115,40 @@ try
         RouteParameters::OverviewType::False,
         false,
         std::nullopt},
+        {"1000 routes, 2 coordinates, no alternatives, overview=false, steps=false",
+         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
+          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
+         RouteParameters::OverviewType::False,
+         false,
+         std::nullopt},
        {"1000 routes, 2 coordinates, 3 alternatives, overview=false, steps=false",
         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
         RouteParameters::OverviewType::False,
         false,
         3},
+        {"1000 routes, 3 coordinates, no alternatives, overview=false, steps=false, radius=750",
+         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
+          {FloatLongitude{7.421844922513342}, FloatLatitude{43.73690777888953}},
+          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
+         RouteParameters::OverviewType::False,
+         false,
+         std::nullopt,
+         750},
+        {"1000 routes, 2 coordinates, no alternatives, overview=false, steps=false, radius=750",
+         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
+          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
+         RouteParameters::OverviewType::False,
+         false,
+         std::nullopt,
+         750},
+        {"1000 routes, 2 coordinates, 3 alternatives, overview=false, steps=false, radius=750",
+         {{FloatLongitude{7.437602352715465}, FloatLatitude{43.75030522209604}},
+          {FloatLongitude{7.412303912230966}, FloatLatitude{43.72851046529198}}},
+         RouteParameters::OverviewType::False,
+         false,
+         3,
+         750}

    };

@@ -11,10 +11,11 @@
 #include "util/serialization.hpp"
 #include "util/timing_util.hpp"

-#include <fstream>
 #include <iostream>
 #include <random>

+#include <boost/filesystem/fstream.hpp>
+
 namespace osrm::benchmarks
 {

@@ -11,7 +11,7 @@
 #include "util/typedefs.hpp"

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

 #include <algorithm>
 #include <iterator>
@@ -44,22 +44,21 @@ util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection
 {
    BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1);
    util::json::Array result;
-    result.values.reserve(intersection.lane_description.size());
    LaneID lane_id = intersection.lane_description.size();

    for (const auto &lane_desc : intersection.lane_description)
    {
        --lane_id;
        util::json::Object lane;
-        lane.values.emplace("indications", toJSON(lane_desc));
+        lane.values["indications"] = toJSON(lane_desc);
        if (lane_id >= intersection.lanes.first_lane_from_the_right &&
            lane_id <
                intersection.lanes.first_lane_from_the_right + intersection.lanes.lanes_in_turn)
-            lane.values.emplace("valid", util::json::True());
+            lane.values["valid"] = util::json::True();
        else
-            lane.values.emplace("valid", util::json::False());
+            lane.values["valid"] = util::json::False();

-        result.values.emplace_back(std::move(lane));
+        result.values.push_back(lane);
    }

    return result;
@@ -78,7 +77,6 @@ std::string waypointTypeToString(const guidance::WaypointType waypoint_type)
 util::json::Value coordinateToLonLat(const util::Coordinate &coordinate)
 {
    util::json::Array array;
-    array.values.reserve(2);
    array.values.push_back(static_cast<double>(util::toFloating(coordinate.lon)));
    array.values.push_back(static_cast<double>(util::toFloating(coordinate.lat)));
    return util::json::Value{std::move(array)};
@@ -100,20 +98,17 @@ util::json::Object makeStepManeuver(const guidance::StepManeuver &maneuver)
    // These invalid responses should never happen: log if they do happen
    BOOST_ASSERT_MSG(maneuver_type != "invalid", "unexpected invalid maneuver type");

-    step_maneuver.values.emplace("type", std::move(maneuver_type));
+    step_maneuver.values["type"] = std::move(maneuver_type);

    if (detail::isValidModifier(maneuver))
-        step_maneuver.values.emplace(
-            "modifier",
-            osrm::guidance::instructionModifierToString(maneuver.instruction.direction_modifier));
+        step_maneuver.values["modifier"] =
+            osrm::guidance::instructionModifierToString(maneuver.instruction.direction_modifier);

-    step_maneuver.values.emplace("location", detail::coordinateToLonLat(maneuver.location));
-    step_maneuver.values.emplace("bearing_before",
-                                 detail::roundAndClampBearing(maneuver.bearing_before));
-    step_maneuver.values.emplace("bearing_after",
-                                 detail::roundAndClampBearing(maneuver.bearing_after));
+    step_maneuver.values["location"] = detail::coordinateToLonLat(maneuver.location);
+    step_maneuver.values["bearing_before"] = detail::roundAndClampBearing(maneuver.bearing_before);
+    step_maneuver.values["bearing_after"] = detail::roundAndClampBearing(maneuver.bearing_after);
    if (maneuver.exit != 0)
-        step_maneuver.values.emplace("exit", maneuver.exit);
+        step_maneuver.values["exit"] = maneuver.exit;

    return step_maneuver;
 }
@@ -142,16 +137,16 @@ util::json::Object makeIntersection(const guidance::IntermediateIntersection &in
                           return util::json::False();
                   });

-    result.values.emplace("location", detail::coordinateToLonLat(intersection.location));
-    result.values.emplace("bearings", bearings);
-    result.values.emplace("entry", entry);
+    result.values["location"] = detail::coordinateToLonLat(intersection.location);
+    result.values["bearings"] = bearings;
+    result.values["entry"] = entry;
    if (intersection.in != guidance::IntermediateIntersection::NO_INDEX)
-        result.values.emplace("in", intersection.in);
+        result.values["in"] = intersection.in;
    if (intersection.out != guidance::IntermediateIntersection::NO_INDEX)
-        result.values.emplace("out", intersection.out);
+        result.values["out"] = intersection.out;

    if (detail::hasValidLanes(intersection))
-        result.values.emplace("lanes", detail::lanesFromIntersection(intersection));
+        result.values["lanes"] = detail::lanesFromIntersection(intersection);

    if (!intersection.classes.empty())
    {
@@ -162,7 +157,7 @@ util::json::Object makeIntersection(const guidance::IntermediateIntersection &in
                       std::back_inserter(classes.values),
                       [](const std::string &class_name)
                       { return util::json::String{class_name}; });
-        result.values.emplace("classes", std::move(classes));
+        result.values["classes"] = std::move(classes);
    }

    return result;
@@ -171,64 +166,57 @@ util::json::Object makeIntersection(const guidance::IntermediateIntersection &in
 util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geometry)
 {
    util::json::Object route_step;
-    route_step.values.reserve(15);
-
-    route_step.values.emplace("distance", std::round(step.distance * 10) / 10.);
-    route_step.values.emplace("duration", step.duration);
-    route_step.values.emplace("weight", step.weight);
-    route_step.values.emplace("name", step.name);
-
+    route_step.values["distance"] = std::round(step.distance * 10) / 10.;
+    route_step.values["duration"] = step.duration;
+    route_step.values["weight"] = step.weight;
+    route_step.values["name"] = std::move(step.name);
    if (!step.ref.empty())
-        route_step.values.emplace("ref", step.ref);
+        route_step.values["ref"] = std::move(step.ref);
    if (!step.pronunciation.empty())
-        route_step.values.emplace("pronunciation", step.pronunciation);
+        route_step.values["pronunciation"] = std::move(step.pronunciation);
    if (!step.destinations.empty())
-        route_step.values.emplace("destinations", step.destinations);
+        route_step.values["destinations"] = std::move(step.destinations);
    if (!step.exits.empty())
-        route_step.values.emplace("exits", step.exits);
+        route_step.values["exits"] = std::move(step.exits);
    if (!step.rotary_name.empty())
    {
-        route_step.values.emplace("rotary_name", step.rotary_name);
+        route_step.values["rotary_name"] = std::move(step.rotary_name);
        if (!step.rotary_pronunciation.empty())
        {
-            route_step.values.emplace("rotary_pronunciation", step.rotary_pronunciation);
+            route_step.values["rotary_pronunciation"] = std::move(step.rotary_pronunciation);
        }
    }

-    route_step.values.emplace("mode", extractor::travelModeToString(step.mode));
-    route_step.values.emplace("maneuver", makeStepManeuver(step.maneuver));
-    route_step.values.emplace("geometry", std::move(geometry));
-    route_step.values.emplace("driving_side", step.is_left_hand_driving ? "left" : "right");
+    route_step.values["mode"] = extractor::travelModeToString(step.mode);
+    route_step.values["maneuver"] = makeStepManeuver(step.maneuver);
+    route_step.values["geometry"] = std::move(geometry);
+    route_step.values["driving_side"] = step.is_left_hand_driving ? "left" : "right";

    util::json::Array intersections;
    intersections.values.reserve(step.intersections.size());
-
    std::transform(step.intersections.begin(),
                   step.intersections.end(),
                   std::back_inserter(intersections.values),
                   makeIntersection);
-
-    route_step.values.emplace("intersections", std::move(intersections));
+    route_step.values["intersections"] = std::move(intersections);

    return route_step;
 }

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                             const char *weight_name)
 {
    util::json::Object json_route;
-    json_route.values.reserve(6);
-
-    json_route.values.emplace("distance", route.distance);
-    json_route.values.emplace("duration", route.duration);
-    json_route.values.emplace("weight", route.weight);
-    json_route.values.emplace("weight_name", weight_name);
-    json_route.values.emplace("legs", std::move(legs));
+    json_route.values["distance"] = route.distance;
+    json_route.values["duration"] = route.duration;
+    json_route.values["weight"] = route.weight;
+    json_route.values["weight_name"] = weight_name;
+    json_route.values["legs"] = std::move(legs);
    if (geometry)
    {
-        json_route.values.emplace("geometry", *std::move(geometry));
+        json_route.values["geometry"] = *std::move(geometry);
    }
    return json_route;
 }
@@ -237,11 +225,9 @@ util::json::Object
 makeWaypoint(const util::Coordinate &location, const double &distance, std::string name)
 {
    util::json::Object waypoint;
-    waypoint.values.reserve(3);
-
-    waypoint.values.emplace("location", detail::coordinateToLonLat(location));
-    waypoint.values.emplace("name", std::move(name));
-    waypoint.values.emplace("distance", distance);
+    waypoint.values["location"] = detail::coordinateToLonLat(location);
+    waypoint.values["name"] = std::move(name);
+    waypoint.values["distance"] = distance;
    return waypoint;
 }

@@ -251,29 +237,26 @@ util::json::Object makeWaypoint(const util::Coordinate &location,
                                const Hint &location_hints)
 {
    auto waypoint = makeWaypoint(location, distance, std::move(name));
-    waypoint.values.reserve(1);
-    waypoint.values.emplace("hint", location_hints.ToBase64());
+    waypoint.values["hint"] = location_hints.ToBase64();
    return waypoint;
 }

 util::json::Object makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps)
 {
    util::json::Object route_leg;
-    route_leg.values.reserve(5);
-
-    route_leg.values.emplace("distance", leg.distance);
-    route_leg.values.emplace("duration", leg.duration);
-    route_leg.values.emplace("weight", leg.weight);
-    route_leg.values.emplace("summary", std::move(leg.summary));
-    route_leg.values.emplace("steps", std::move(steps));
+    route_leg.values["distance"] = leg.distance;
+    route_leg.values["duration"] = leg.duration;
+    route_leg.values["weight"] = leg.weight;
+    route_leg.values["summary"] = std::move(leg.summary);
+    route_leg.values["steps"] = std::move(steps);
    return route_leg;
 }
+
 util::json::Object
 makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps, util::json::Object annotation)
 {
    util::json::Object route_leg = makeRouteLeg(std::move(leg), std::move(steps));
-    route_leg.values.reserve(1);
-    route_leg.values.emplace("annotation", std::move(annotation));
+    route_leg.values["annotation"] = std::move(annotation);
    return route_leg;
 }

@@ -44,7 +44,7 @@ MMapMemoryAllocator::MMapMemoryAllocator(const storage::StorageConfig &config)

    for (const auto &file : files)
    {
-        if (std::filesystem::exists(file.second))
+        if (boost::filesystem::exists(file.second))
        {
            std::unique_ptr<storage::BaseDataLayout> layout =
                std::make_unique<storage::TarDataLayout>();
@@ -12,13 +12,15 @@ bool EngineConfig::IsValid() const
    const auto unlimited_or_more_than = [](const auto v, const auto limit)
    { return v == -1 || v > limit; };

-    const bool limits_valid = unlimited_or_more_than(max_locations_distance_table, 2) &&
-                              unlimited_or_more_than(max_locations_map_matching, 2) &&
-                              unlimited_or_more_than(max_radius_map_matching, 0) &&
-                              unlimited_or_more_than(max_locations_trip, 2) &&
-                              unlimited_or_more_than(max_locations_viaroute, 2) &&
-                              unlimited_or_more_than(max_results_nearest, 0) &&
-                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 0;
+    const bool limits_valid =
+        unlimited_or_more_than(max_locations_distance_table, 2) &&
+        unlimited_or_more_than(max_locations_map_matching, 2) &&
+        unlimited_or_more_than(max_radius_map_matching, 0) &&
+        unlimited_or_more_than(max_locations_trip, 2) &&
+        unlimited_or_more_than(max_locations_viaroute, 2) &&
+        unlimited_or_more_than(max_results_nearest, 0) &&
+        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
+        max_alternatives >= 0;

    return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
            storage_config.IsValid()) &&
@@ -194,7 +194,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
            tidied.parameters.radiuses.begin(),
            tidied.parameters.radiuses.end(),
            search_radiuses.begin(),
-            [default_radius = this->default_radius](const std::optional<double> &maybe_radius)
+            [default_radius = this->default_radius](const boost::optional<double> &maybe_radius)
            {
                if (maybe_radius)
                {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Siarhei Fedartsou	96ae1e1320	wip	2024-06-10 22:46:30 +02:00
Siarhei Fedartsou	88708eedb0	Merge branch 'master' into sf-re-use-heap-in-getNetworkDistance	2024-06-10 22:41:39 +02:00
Siarhei Fedartsou	cd4de34f5f	wip	2024-05-29 08:24:25 +02:00
Siarhei Fedartsou	39c74498f7	wip	2024-05-28 21:08:01 +02:00
Siarhei Fedartsou	5b26eac258	wip	2024-05-28 20:41:59 +02:00
Siarhei Fedartsou	dcd615ef2a	reproduced	2024-05-28 19:37:11 +02:00
Siarhei Fedartsou	98e8c2e06c	reproduced	2024-05-28 19:24:53 +02:00
Siarhei Fedartsou	3eaa676626	wip	2024-05-26 12:36:45 +02:00
Siarhei Fedartsou	8b34d5b40c	wip	2024-05-26 12:19:58 +02:00
Siarhei Fedartsou	49cf294d2f	Merge branch 'master' into sf-re-use-heap-in-getNetworkDistance	2024-05-26 11:55:18 +02:00
Siarhei Fedartsou	45f64e672f	Draft: re-use forward heap in map matching	2024-05-21 20:41:25 +02:00
Siarhei Fedartsou	298a8e4d2f	use constexpr if	2024-05-21 20:38:34 +02:00
Siarhei Fedartsou	a37f43bf3f	use constexpr if	2024-05-21 20:36:16 +02:00
Siarhei Fedartsou	e562d34639	use constexpr if	2024-05-21 20:31:34 +02:00
Siarhei Fedartsou	e1d6a10fc6	use constexpr if	2024-05-21 20:29:12 +02:00
Siarhei Fedartsou	6b4665c7b2	use constexpr if	2024-05-21 20:23:56 +02:00
Siarhei Fedartsou	7e2fd63f0a	use constexpr if	2024-05-21 20:10:27 +02:00
Siarhei Fedartsou	ee7dcbbb5b	use constexpr if	2024-05-21 19:55:36 +02:00
Siarhei Fedartsou	09211b76e0	use constexpr if	2024-05-21 19:42:44 +02:00
Siarhei Fedartsou	8654b16d8b	use constexpr if	2024-05-21 19:32:27 +02:00
Siarhei Fedartsou	edc4522f9b	use constexpr if	2024-05-21 19:29:42 +02:00
Siarhei Fedartsou	5d2cd4d0f2	use constexpr if	2024-05-21 19:26:43 +02:00
Siarhei Fedartsou	cd2178905f	use constexpr if	2024-05-20 18:49:44 +02:00
Siarhei Fedartsou	aaf0c1ebb3	use constexpr if	2024-05-20 18:41:08 +02:00
Siarhei Fedartsou	d0ff3088e2	use constexpr if	2024-05-20 18:34:13 +02:00
Siarhei Fedartsou	51e1cbc658	trigger ci	2024-05-20 15:12:19 +02:00
Siarhei Fedartsou	4cdfae0a80	trigger ci	2024-05-20 12:51:31 +02:00
Siarhei Fedartsou	cc423f1de5	Optimise getNetworkDistance in MLD even more	2024-05-20 12:51:31 +02:00