Merge branch 'master' into sf-lto

.github/workflows/osrm-backend-docker.yml

@@ -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 }}
+          file: ./docker/Dockerfile
-          tags: ${{ steps.meta.outputs.tags  }}
+          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 ) }}            
+
+
+            

.github/workflows/osrm-backend.yml

@@ -116,10 +116,7 @@ jobs:
         npm run docs && ./scripts/error_on_dirty.sh
         npm audit --production
 
-  docker-image-matrix:
+  docker-image:
-    strategy:
-      matrix:
-        docker-base-image: ["debian", "alpine"]
     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"
 
@@ -166,103 +164,102 @@ jobs:
     strategy:
       matrix:
         include:
-          - name: gcc-13-debug-cov
+          # - name: gcc-13-debug-cov
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-24.04
+          #   runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
+          #   BUILD_TYPE: Debug
-            CCOMPILER: gcc-13
+          #   CCOMPILER: gcc-13
-            CUCUMBER_TIMEOUT: 20000
+          #   CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-13
+          #   CXXCOMPILER: g++-13
-            ENABLE_COVERAGE: ON
+          #   ENABLE_COVERAGE: ON
 
-          - name: clang-15-debug-asan-ubsan
+          # - name: clang-15-debug-asan-ubsan
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
+          #   BUILD_TYPE: Debug
-            CCOMPILER: clang-15
+          #   CCOMPILER: clang-15
-            CUCUMBER_TIMEOUT: 20000
+          #   CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-15
+          #   CXXCOMPILER: clang++-15
-            ENABLE_SANITIZER: ON
+          #   ENABLE_SANITIZER: ON
-            TARGET_ARCH: x86_64-asan-ubsan
+          #   TARGET_ARCH: x86_64-asan-ubsan
-            OSRM_CONNECTION_RETRIES: 10
+          #   OSRM_CONNECTION_RETRIES: 10
-            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
+          #   OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
 
-          - name: clang-15-release
+          # - name: clang-15-release
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang-15
+          #   CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+          #   CXXCOMPILER: clang++-15
-            CUCUMBER_TIMEOUT: 60000
+          #   CUCUMBER_TIMEOUT: 60000
 
-          - name: clang-15-debug
+          # - name: clang-15-debug
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
+          #   BUILD_TYPE: Debug
-            CCOMPILER: clang-15
+          #   CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+          #   CXXCOMPILER: clang++-15
-            CUCUMBER_TIMEOUT: 60000
+          #   CUCUMBER_TIMEOUT: 60000
 
-          - name: clang-18-debug-clang-tidy
+          # - name: clang-18-debug-clang-tidy
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-24.04
+          #   runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
+          #   BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+          #   CCOMPILER: clang-18
-            CXXCOMPILER: clang++-18
+          #   CXXCOMPILER: clang++-18
-            CUCUMBER_TIMEOUT: 60000
+          #   CUCUMBER_TIMEOUT: 60000
-            ENABLE_CLANG_TIDY: ON
+          #   ENABLE_CLANG_TIDY: ON
 
+          # - name: clang-14-release
+          #   continue-on-error: false
+          #   node: 18
+          #   runs-on: ubuntu-22.04
+          #   BUILD_TOOLS: ON
+          #   BUILD_TYPE: Release
+          #   CCOMPILER: clang-14
+          #   CXXCOMPILER: clang++-14
+          #   CUCUMBER_TIMEOUT: 60000
 
-          - name: clang-14-release
+          # - name: clang-13-release
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang-14
+          #   CCOMPILER: clang-13
-            CXXCOMPILER: clang++-14
+          #   CXXCOMPILER: clang++-13
-            CUCUMBER_TIMEOUT: 60000
+          #   CUCUMBER_TIMEOUT: 60000
 
-          - name: clang-13-release
+          # - name: conan-linux-debug-asan-ubsan
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang-13
+          #   CCOMPILER: clang-15
-            CXXCOMPILER: clang++-13
+          #   CXXCOMPILER: clang++-15
-            CUCUMBER_TIMEOUT: 60000
+          #   ENABLE_CONAN: ON
+          #   ENABLE_SANITIZER: ON
 
-          - name: conan-linux-debug-asan-ubsan
+          # - name: conan-linux-release
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 18
+          #   node: 18
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang-15
+          #   CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
+          #   CXXCOMPILER: clang++-15
-            ENABLE_CONAN: ON
+          #   ENABLE_CONAN: ON
-            ENABLE_SANITIZER: ON
-
-          - name: conan-linux-release
-            continue-on-error: false
-            node: 18
-            runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-15
-            ENABLE_CONAN: ON
 
           - name: gcc-14-release
             continue-on-error: false
@@ -274,72 +271,71 @@ jobs:
             CXXCOMPILER: g++-14
             CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
 
-          - name: gcc-13-release
+          # - name: gcc-13-release
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-24.04
+          #   runs-on: ubuntu-24.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: gcc-13
+          #   CCOMPILER: gcc-13
-            CXXCOMPILER: g++-13
+          #   CXXCOMPILER: g++-13
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
+          #   CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
 
-          - name: gcc-12-release
+          # - name: gcc-12-release
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TOOLS: ON
+          #   BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: gcc-12
+          #   CCOMPILER: gcc-12
-            CXXCOMPILER: g++-12
+          #   CXXCOMPILER: g++-12
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
+          #   CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
 
-          - name: conan-linux-release-node
+          # - name: conan-linux-release-node
-            build_node_package: true
+          #   build_node_package: true
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang-13
+          #   CCOMPILER: clang-13
-            CXXCOMPILER: clang++-13
+          #   CXXCOMPILER: clang++-13
-            ENABLE_CONAN: ON
+          #   ENABLE_CONAN: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
+          #   NODE_PACKAGE_TESTS_ONLY: ON
 
-          - name: conan-linux-debug-node
+          # - name: conan-linux-debug-node
-            build_node_package: true
+          #   build_node_package: true
-            continue-on-error: false
+          #   continue-on-error: false
-            node: 20
+          #   node: 20
-            runs-on: ubuntu-22.04
+          #   runs-on: ubuntu-22.04
-            BUILD_TYPE: Debug
+          #   BUILD_TYPE: Debug
-            CCOMPILER: clang-13
+          #   CCOMPILER: clang-13
-            CXXCOMPILER: clang++-13
+          #   CXXCOMPILER: clang++-13
-            ENABLE_CONAN: ON
+          #   ENABLE_CONAN: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
+          #   NODE_PACKAGE_TESTS_ONLY: ON
 
-          - name: conan-macos-x64-release-node
+          # - name: conan-macos-x64-release-node
-            build_node_package: true
+          #   build_node_package: true
-            continue-on-error: true
+          #   continue-on-error: true
-            node: 20
+          #   node: 20
-            runs-on: macos-13 # x86_64
+          #   runs-on: macos-13 # x86_64
-            BUILD_TYPE: Release
+          #   BUILD_TYPE: Release
-            CCOMPILER: clang
+          #   CCOMPILER: clang
-            CXXCOMPILER: clang++
+          #   CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
+          #   CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
+          #   ENABLE_ASSERTIONS: ON
-            ENABLE_CONAN: ON
+          #   ENABLE_CONAN: ON
-
-          - name: conan-macos-arm64-release-node
-            build_node_package: true
-            continue-on-error: true
-            node: 20
-            runs-on: macos-14 # arm64 
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_CONAN: ON
 
+          # - name: conan-macos-arm64-release-node
+          #   build_node_package: true
+          #   continue-on-error: true
+          #   node: 20
+          #   runs-on: macos-14 # arm64 
+          #   BUILD_TYPE: Release
+          #   CCOMPILER: clang
+          #   CXXCOMPILER: clang++
+          #   CUCUMBER_TIMEOUT: 60000
+          #   ENABLE_ASSERTIONS: ON
+          #   ENABLE_CONAN: ON
     name: ${{ matrix.name}}
     continue-on-error: ${{ matrix.continue-on-error }}
     runs-on: ${{ matrix.runs-on }}
@@ -640,10 +636,11 @@ jobs:
     needs: [format-taginfo-docs]
     runs-on: ubuntu-22.04
     env:
-      CCOMPILER: clang-13
+      CCOMPILER: gcc-12 #clang-13
-      CXXCOMPILER: clang++-13
+      CXXCOMPILER: g++-12 #clang++-13
-      CC: clang-13
+      CC: gcc-12 #clang-13
-      CXX: clang++-13
+      CXX: g++-12 #clang++-13
+      CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       PR_NUMBER: ${{ github.event.pull_request.number }}
       GITHUB_REPOSITORY: ${{ github.repository }}
@@ -678,7 +675,7 @@ jobs:
           path: pr
       - name: Install dependencies
         run: | 
-          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
+          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" #--break-system-packages
           sudo apt-get update -y && sudo apt-get install ccache
       - name: Prepare data
         run: |
@@ -700,6 +697,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:
@@ -714,23 +720,9 @@ jobs:
           make -j$(nproc) benchmarks
           cd ..
           make -C test/data 
-      - name: Build PR Branch
+      - name: Run Benchmarks
         run: |
-          mkdir -p pr/build
+          ./pr/scripts/ci/run_benchmarks.sh base pr
-          cd pr/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
-          make -j$(nproc) 
-          make -j$(nproc) benchmarks
-          cd ..
-          make -C test/data 
-      - name: Run PR Benchmarks 
-        run: |
-          ./pr/scripts/ci/run_benchmarks.sh -f $(pwd)/pr -r $(pwd)/pr_results -s $(pwd)/pr -b $(pwd)/pr/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-      - name: Run Base Benchmarks
-        run: |
-          # 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 $(pwd)/base -r $(pwd)/base_results -s $(pwd)/pr -b $(pwd)/base/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-
       - name: Post Benchmark Results
         run: |
           python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
@@ -741,7 +733,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"
-

.github/workflows/stale.yml

@@ -1,24 +0,0 @@
-name: 'Close stale issues'
-on:
-  schedule:
-    - cron: '30 1 * * *' # every day at 1:30am
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/stale@v9
-        with:
-          stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
-          stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
-          days-before-issue-stale: 180 # 6 months
-          days-before-issue-close: 30 # 1 month
-          days-before-pr-stale: 180 # 6 months
-          days-before-pr-close: -1 # never close PRs
-          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
-
-  
-

CHANGELOG.md

@@ -24,14 +24,6 @@
     - NodeJS:
       - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
     - Misc:
-      - 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)
@@ -45,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)

CMakeLists.txt

@@ -31,7 +31,7 @@ option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" 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_LTO "Use LTO if available" ON)
 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)
@@ -122,7 +122,7 @@ 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
@@ -330,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_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
+  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")
+  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
@@ -348,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
   )
 
@@ -377,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}")
 
 
@@ -453,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_)
@@ -462,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}
@@ -482,6 +500,7 @@ endif()
 
 set(EXTRACTOR_LIBRARIES
     ${BZIP2_LIBRARIES}
+    ${Boost_REGEX_LIBRARY}
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${EXPAT_LIBRARIES}

docker/Dockerfile

@@ -1 +0,0 @@
-Dockerfile-debian

docker/Dockerfile

@@ -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

docker/Dockerfile-alpine

@@ -1,62 +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" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM alpine-mimalloc as runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apk add --no-cache \
-    boost-program_options boost-date_time boost-iostreams boost-thread \
-    expat lua5.4 onetbb && \
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000

docker/Dockerfile-debian

@@ -1,67 +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" && \
-    echo "Building OSRM ${DOCKER_TAG}" && \
-    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
-    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
-    mkdir -p build && \
-    cd build && \
-    BUILD_TYPE="Release" && \
-    ENABLE_ASSERTIONS="Off" && \
-    BUILD_TOOLS="Off" && \
-    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
-    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
-    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
-    make -j${NPROC} install && \
-    cd ../profiles && \
-    cp -r * /opt && \
-    strip /usr/local/bin/* && \
-    rm -rf /src
-
-
-# Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
-# Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:bookworm-slim as runstage
-
-COPY --from=builder /usr/local /usr/local
-COPY --from=builder /opt /opt
-
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        libboost-program-options1.81.0 libboost-date-time1.81.0 libboost-iostreams1.81.0 libboost-thread1.81.0 \
-        expat liblua5.4-0 && \
-    rm -rf /var/lib/apt/lists/* && \
-# add /usr/local/lib to ldconfig to allow loading libraries from there
-    ldconfig /usr/local/lib
-
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
-
-WORKDIR /opt
-
-EXPOSE 5000

docker/hooks/build

@@ -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 --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
-DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
-
-$DOCKER_BUILD Dockerfile ..
-$DOCKER_BUILD Dockerfile-alpine ..

features/support/env.js

@@ -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}`;
 

include/contractor/contractor_config.hpp

@@ -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);

include/contractor/files.hpp

@@ -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)
 {

include/customizer/customizer_config.hpp

@@ -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);

include/customizer/edge_based_graph.hpp

@@ -9,7 +9,7 @@
 
 #include "storage/shared_memory_ownership.hpp"
 
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 
 namespace osrm::customizer
 {

include/customizer/files.hpp

@@ -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)
 {

include/engine/api/match_api.hpp

@@ -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);
+            route.values["confidence"] = sub_matchings[index].confidence;
-            routes.values.emplace_back(std::move(route));
+            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["matchings"] = std::move(routes);
-        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;
         }
     }
 
@@ -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["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values.emplace("waypoint_index", matching_index.point_index);
+            waypoint.values["waypoint_index"] = matching_index.point_index;
-            waypoint.values.emplace("alternatives_count",
+            waypoint.values["alternatives_count"] =
-                                    sub_matchings[matching_index.sub_matching_index]
+                sub_matchings[matching_index.sub_matching_index]
-                                        .alternatives_count[matching_index.point_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;

include/engine/api/nearest_api.hpp

@@ -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.push_back(node_values.first);
-                               nodes.values.emplace_back(node_values.second);
+                               nodes.values.push_back(node_values.second);
-                               waypoint.values.emplace("nodes", std::move(nodes));
+                               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;
         }
     }
 

include/engine/api/route_api.hpp

@@ -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["routes"] = std::move(jsRoutes);
-        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;
         }
     }
 
@@ -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::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
         auto route = guidance::assembleRoute(legs);
 
         // Fill legs
@@ -716,8 +716,8 @@ class RouteAPI : public BaseAPI
                                   unpacked_path_segments,
                                   source_traversed_in_reverse,
                                   target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
 
         auto route = guidance::assembleRoute(legs);
         boost::optional<util::json::Value> json_overview =
@@ -784,57 +784,49 @@ class RouteAPI : public BaseAPI
                 if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                 {
                     double prev_speed = 0;
-                    annotation.values.emplace(
+                    annotation.values["speed"] = GetAnnotations(
-                        "speed",
+                        leg_geometry,
-                        GetAnnotations(leg_geometry,
+                        [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                        {
-                                       {
+                            if (anno.duration < std::numeric_limits<double>::min())
-                                           if (anno.duration < std::numeric_limits<double>::min())
+                            {
-                                           {
+                                return prev_speed;
-                                               return prev_speed;
+                            }
-                                           }
+                            else
-                                           else
+                            {
-                                           {
+                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                                               auto speed =
+                                prev_speed = speed;
-                                                   std::round(anno.distance / anno.duration * 10.) /
+                                return util::json::clamp_float(speed);
-                                                   10.;
+                            }
-                                               prev_speed = speed;
+                        });
-                                               return util::json::clamp_float(speed);
-                                           }
-                                       }));
                 }
 
                 if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                 {
-                    annotation.values.emplace(
+                    annotation.values["duration"] =
-                        "duration",
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; }));
+                                       { return anno.duration; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                 {
-                    annotation.values.emplace(
+                    annotation.values["distance"] =
-                        "distance",
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; }));
+                                       { return anno.distance; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                 {
-                    annotation.values.emplace(
+                    annotation.values["weight"] = GetAnnotations(
-                        "weight",
+                        leg_geometry,
-                        GetAnnotations(leg_geometry,
+                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
-                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.weight; }));
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                 {
-                    annotation.values.emplace(
+                    annotation.values["datasources"] =
-                        "datasources",
                         GetAnnotations(leg_geometry,
                                        [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; }));
+                                       { return anno.datasource; });
                 }
                 if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                 {
@@ -845,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)
@@ -861,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);
+                    metadata.values["datasource_names"] = datasource_names;
-                    annotation.values.emplace("metadata", metadata);
+                    annotation.values["metadata"] = metadata;
                 }
 
                 annotations.push_back(std::move(annotation));

include/engine/api/table_api.hpp

@@ -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",
+                response.values["destinations"] =
-                                        MakeWaypoints(candidates, parameters.destinations));
+                    MakeWaypoints(candidates, parameters.destinations);
             }
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Duration)
         {
-            response.values.emplace(
+            response.values["durations"] =
-                "durations",
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
-                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
         }
 
         if (parameters.annotations & TableParameters::AnnotationsType::Distance)
         {
-            response.values.emplace(
+            response.values["distances"] =
-                "distances",
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
-                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",
+            response.values["fallback_speed_cells"] = MakeEstimatesTable(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;
         }
     }
 

include/engine/api/trip_api.hpp

@@ -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["trips"] = std::move(routes);
-        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;
         }
     }
 
@@ -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["trips_index"] = trip_index.sub_trip_index;
-            waypoint.values.emplace("waypoint_index", trip_index.point_index);
+            waypoint.values["waypoint_index"] = trip_index.point_index;
             waypoints.values.push_back(std::move(waypoint));
         }
 

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -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;
 

include/engine/engine_config.hpp

@@ -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>
 
@@ -82,7 +83,7 @@ struct EngineConfig final
     boost::optional<double> default_radius = -1.0;
     int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
     bool use_shared_memory = true;
-    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;

include/engine/guidance/collapsing_utility.hpp

@@ -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 exit_intersection = exit_step.intersections.front();
-    const auto &entry_intersection = entry_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];

include/extractor/extractor_config.hpp

@@ -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;
+    boost::filesystem::path input_path;
-    std::filesystem::path profile_path;
+    boost::filesystem::path profile_path;
-    std::vector<std::filesystem::path> location_dependent_data_paths;
+    std::vector<boost::filesystem::path> location_dependent_data_paths;
     std::string data_version;
 
     unsigned requested_num_threads = 0;

include/extractor/files.hpp

@@ -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,
+inline void writeIntersections(const boost::filesystem::path &path,
-                        const IntersectionBearingsT &intersection_bearings,
+                               const IntersectionBearingsT &intersection_bearings,
-                        const EntryClassVectorT &entry_classes)
+                               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,
+inline void readIntersections(const boost::filesystem::path &path,
-                       IntersectionBearingsT &intersection_bearings,
+                              IntersectionBearingsT &intersection_bearings,
-                       EntryClassVectorT &entry_classes)
+                              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,
+inline void readNodes(const boost::filesystem::path &path,
-               CoordinatesT &coordinates,
+                      CoordinatesT &coordinates,
-               PackedOSMIDsT &osm_node_ids)
+                      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,
+inline void writeNodes(const boost::filesystem::path &path,
-                const CoordinatesT &coordinates,
+                       const CoordinatesT &coordinates,
-                const PackedOSMIDsT &osm_node_ids)
+                       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};

include/extractor/location_dependent_data.hpp

@@ -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;

include/extractor/node_based_graph_factory.hpp

@@ -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>

include/extractor/raster_source.hpp

@@ -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;

include/extractor/scripting_environment_lua.hpp

@@ -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;

include/extractor/segment_data_container.hpp

@@ -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

include/guidance/files.hpp

@@ -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)
 {

include/partitioner/edge_based_graph_reader.hpp

@@ -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
+                    // we only need to save the forward edges, since the read method will
-                    // will convert from forward to bi-directional edges again
+                    // 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;

include/partitioner/files.hpp

@@ -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)
 {

include/partitioner/partitioner_config.hpp

@@ -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);
     }

include/storage/io.hpp

@@ -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;
+    const boost::filesystem::path filepath;
-    std::ifstream input_stream;
+    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;
+    const boost::filesystem::path filepath;
-    std::ofstream output_stream;
+    boost::filesystem::ofstream output_stream;
     FingerprintFlag fingerprint;
 };
 

include/storage/io_config.hpp

@@ -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_,
+    IOConfig(std::vector<boost::filesystem::path> required_input_files_,
-             std::vector<std::filesystem::path> optional_input_files_,
+             std::vector<boost::filesystem::path> optional_input_files_,
-             std::vector<std::filesystem::path> output_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<boost::filesystem::path> required_input_files;
-    std::vector<std::filesystem::path> optional_input_files;
+    std::vector<boost::filesystem::path> optional_input_files;
-    std::vector<std::filesystem::path> output_files;
+    std::vector<boost::filesystem::path> output_files;
 };
 } // namespace osrm::storage
 

include/storage/shared_memory.hpp

@@ -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();
+        boost::filesystem::path temp_dir = boost::filesystem::temp_directory_path();
-        std::filesystem::path lock_file = temp_dir / ("osrm-" + std::to_string(id) + ".lock");
+        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);

include/storage/storage.hpp

@@ -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, boost::filesystem::path>> GetUpdatableFiles();
-    std::vector<std::pair<bool, std::filesystem::path>> GetStaticFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> GetStaticFiles();
 
   private:
     StorageConfig config;

include/storage/storage_config.hpp

@@ -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_)
     {

include/storage/tar.hpp

@@ -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

include/storage/view_factory.hpp

@@ -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);

include/updater/csv_file_parser.hpp

@@ -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);

include/updater/updater_config.hpp

@@ -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 <boost/filesystem/path.hpp>
-#include "storage/storage_config.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);
     }

include/util/lua_util.hpp

@@ -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());

include/util/mmap_file.hpp

@@ -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(file);
-        mmap_container.open(path_string);
         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>
+util::vector_view<T> mmapFile(const boost::filesystem::path &file,
-mmapFile(const std::filesystem::path &file, MmapContainerT &mmap_container, const std::size_t size)
+                              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)
 {

include/util/mmap_tar.hpp

@@ -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;

include/util/static_rtree.hpp

@@ -20,6 +20,7 @@
 #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()),

include/util/timezones.hpp

@@ -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;
 

scripts/ci/e2e_benchmark.py

@@ -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 benchmark_name == 'match':
-                if code in ['NoSegment', 'NoMatch', 'NoRoute', 'NoTrips']:
+                    code = response.json()['code']
-                    continue
+                    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):
-    mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(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)
+    runner = BenchmarkRunner()
-    
+    times = runner.run(args.method, args.host, args.num_requests)
-    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)
 
-    assert all_times.shape == (args.iterations, all_times.shape[1])
+    print(f'Total: {np.sum(times)}ms')
-
+    print(f"Min time: {np.min(times)}ms")
-
+    print(f"Mean time: {np.mean(times)}ms")
-    total_time, total_ci, total_best = calculate_confidence_interval(np.sum(all_times, axis=1))
+    print(f"Median time: {np.median(times)}ms")
-    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))
+    print(f"95th percentile: {np.percentile(times, 95)}ms")
-    min_time, min_ci, _ = calculate_confidence_interval(np.min(all_times, axis=1))
+    print(f"99th percentile: {np.percentile(times, 99)}ms")
-    mean_time, mean_ci, _ = calculate_confidence_interval(np.mean(all_times, axis=1))
+    print(f"Max time: {np.max(times)}ms")
-    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")
 
 if __name__ == '__main__':
     main()

scripts/ci/run_benchmarks.sh

@@ -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}')
+    OUTPUT=$(/usr/bin/time -f "%e %M" $COMMAND 2>&1 | tail -n 1)
-        PEAK_RAM_KB=$(echo $OUTPUT | awk '{print $2}')
+
-        PEAK_RAM_MB=$(echo "scale=2; $PEAK_RAM_KB / 1024" | bc)
+    TIME=$(echo $OUTPUT | awk '{print $1}')
-        echo "Time: ${TIME}s Peak RAM: ${PEAK_RAM_MB}MB" > $OUTPUT_FILE
+    PEAK_RAM_KB=$(echo $OUTPUT | awk '{print $2}')
-    fi
+    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"
+    BENCHMARKS_FOLDER="$FOLDER/build/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/src/benchmarks/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"
 
-    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
-        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
-            echo "Running random $BENCH $ALGORITHM"
+        ./$BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" ch ~/gps_traces.csv ${BENCH}  > "$RESULTS_FOLDER/random_${BENCH}_ch.bench" || true
-            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
     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"
+            python3 $SCRIPTS_FOLDER/scripts/ci/e2e_benchmark.py --host http://localhost:5000 --method $METHOD --num_requests 1000 > $RESULTS_FOLDER/e2e_${METHOD}_${ALGORITHM}.bench
-            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"
         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
 

scripts/ci/windows-build.bat

@@ -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%

src/benchmarks/bench.cpp

@@ -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); }
+    GPSTraces(int seed) : gen(std::random_device{}()) { gen.seed(seed); }
-
-    void resetSeed() const { gen.seed(seed); }
 
     bool readCSV(const std::string &filename)
     {
@@ -105,200 +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));
-
+        return traces.at(*it);
-        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);
     }
 };
 
-// Struct to hold confidence interval data
-struct ConfidenceInterval
-{
-    double mean;
-    double confidence;
-    double min;
-};
-
-// 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())};
-    return ci;
-}
-
 class Statistics
 {
   public:
-    explicit Statistics(int iterations) : times(iterations) {}
+    void push(double timeMs)
-
-    void push(double timeMs, int iteration) { times[iteration].push_back(timeMs); }
-
-    ConfidenceInterval mean()
     {
-        std::vector<double> means;
+        times.push_back(timeMs);
-        means.reserve(times.size());
+        sorted = false;
-        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);
     }
 
-    ConfidenceInterval total()
+    double mean() { return sum() / times.size(); }
+
+    double sum()
     {
-        std::vector<double> sums;
+        double sum = 0;
-        sums.reserve(times.size());
+        for (auto time : times)
-        for (const auto &iter_times : times)
         {
-            sums.push_back(std::accumulate(iter_times.begin(), iter_times.end(), 0.0));
+            sum += time;
         }
-        return confidenceInterval(sums);
+        return sum;
     }
 
-    ConfidenceInterval min()
+    double min() { return *std::min_element(times.begin(), times.end()); }
-    {
-        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);
-    }
 
-    ConfidenceInterval max()
+    double max() { return *std::max_element(times.begin(), times.end()); }
-    {
-        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);
-    }
 
-    ConfidenceInterval percentile(double p)
+    double percentile(double p)
     {
-        std::vector<double> percentiles;
+        const auto &times = getTimes();
-        percentiles.reserve(times.size());
+        return times[static_cast<size_t>(p * 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);
     }
 
   private:
-    // vector of times for each iteration
+    std::vector<double> getTimes()
-    std::vector<std::vector<double>> times;
+    {
+        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);
-
+    os << "total: " << statistics.sum() << "ms" << std::endl;
-    ConfidenceInterval mean_ci = statistics.mean();
+    os << "avg: " << statistics.mean() << "ms" << std::endl;
-    ConfidenceInterval total_ci = statistics.total();
+    os << "min: " << statistics.min() << "ms" << std::endl;
-    ConfidenceInterval min_ci = statistics.min();
+    os << "max: " << statistics.max() << "ms" << std::endl;
-    ConfidenceInterval max_ci = statistics.max();
+    os << "p99: " << statistics.percentile(0.99) << "ms" << std::endl;
-    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.min << "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;
-
     return os;
 }
 
-template <typename Benchmark, typename BenchmarkBody>
+void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
-void runBenchmarks(const std::vector<Benchmark> &benchmarks,
-                   int iterations,
-                   int opsPerIteration,
-                   const OSRM &osrm,
-                   const GPSTraces &gpsTraces,
-                   const BenchmarkBody &benchmarkBody)
 {
-    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;
@@ -308,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)
+    for (const auto &benchmark : benchmarks)
-                      {
+    {
-                          params.coordinates.push_back(gpsTraces.getRandomCoordinate());
+        run_benchmark(benchmark);
-                      }
+    }
-
-                      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);
-
-                      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);
-                      }
-                  });
 }
 
-void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
     struct Benchmark
     {
@@ -392,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"},
+    auto run_benchmark = [&](const Benchmark &benchmark)
-                                         {"500 matches, radius=10", 10},
+    {
-                                         {"500 matches, radius=20", 20}};
+        Statistics statistics;
 
-    runBenchmarks(benchmarks,
+        auto NUM = 1000;
-                  iterations,
+        for (int i = 0; i < NUM; ++i)
-                  500,
+        {
-                  osrm,
+            engine::api::ResultT result = json::Object();
-                  gpsTraces,
-                  [](int iteration,
-                     const Benchmark &benchmark,
-                     const OSRM &osrm,
-                     const GPSTraces &gpsTraces,
-                     Statistics &statistics)
-                  {
-                      engine::api::ResultT result = json::Object();
 
-                      engine::api::MatchParameters params;
+            engine::api::MatchParameters params;
-                      params.coordinates = gpsTraces.getRandomTrace();
+            params.coordinates = gpsTraces.getRandomTrace();
-                      params.radiuses = {};
+            params.radiuses = {};
-                      if (benchmark.radius)
+            if (benchmark.radius)
-                      {
+            {
-                          for (size_t index = 0; index < params.coordinates.size(); ++index)
+                for (size_t index = 0; index < params.coordinates.size(); ++index)
-                          {
+                {
-                              params.radiuses.emplace_back(*benchmark.radius);
+                    params.radiuses.emplace_back(*benchmark.radius);
-                          }
+                }
-                      }
+            }
 
-                      TIMER_START(match);
+            TIMER_START(match);
-                      const auto rc = osrm.Match(params, result);
+            const auto rc = osrm.Match(params, result);
-                      TIMER_STOP(match);
+            TIMER_STOP(match);
 
-                      auto &json_result = std::get<json::Object>(result);
+            statistics.push(TIMER_MSEC(match));
-                      if (rc != Status::Ok ||
+
-                          json_result.values.find("matchings") == json_result.values.end())
+            auto &json_result = std::get<json::Object>(result);
-                      {
+            if (rc != Status::Ok ||
-                          auto code = std::get<json::String>(json_result.values["code"]).value;
+                json_result.values.find("matchings") == json_result.values.end())
-                          if (code != "NoSegment" && code != "NoMatch")
+            {
-                          {
+                auto code = std::get<json::String>(json_result.values["code"]).value;
-                              throw std::runtime_error{"Couldn't route: " + code};
+                if (code != "NoSegment" && code != "NoMatch")
-                          }
+                {
-                      }
+                    throw std::runtime_error{"Couldn't route: " + code};
-                      else
+                }
-                      {
+            }
-                          statistics.push(TIMER_MSEC(match), iteration);
+        }
-                      }
+
-                  });
+        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
     {
@@ -449,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,
+    for (const auto &benchmark : benchmarks)
-                  iterations,
+    {
-                  10000,
+        run_benchmark(benchmark);
-                  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);
-                      }
-                  });
 }
 
-void runTripBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runTripBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
     struct Benchmark
     {
@@ -502,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},
+        {"1000 trips, 3 coordinates", 3},
-        {"250 trips, 5 coordinates", 5},
+        {"1000 trips, 4 coordinates", 4},
+        {"1000 trips, 5 coordinates", 5},
     };
 
-    runBenchmarks(benchmarks,
+    for (const auto &benchmark : benchmarks)
-                  iterations,
+    {
-                  250,
+        run_benchmark(benchmark);
-                  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);
-                      }
-                  });
 }
-void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterations)
+void runTableBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces)
 {
     struct Benchmark
     {
@@ -555,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,
+    for (const auto &benchmark : benchmarks)
-                  iterations,
+    {
-                  250,
+        run_benchmark(benchmark);
-                  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"};
-                          }
-                      }
-                  });
 }
 
 } // namespace
@@ -602,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]
+        std::cerr
-                  << " data.osrm <mld|ch> <path to GPS traces.csv> "
+            << "Usage: " << argv[0]
-                     "<route|match|trip|table|nearest> <number_of_iterations>\n";
+            << " data.osrm <mld|ch> <path to GPS traces.csv> <route|match|trip|table|nearest>\n";
         return EXIT_FAILURE;
     }
 
@@ -623,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
     {

src/benchmarks/match.cpp

@@ -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);
     }

src/benchmarks/route.cpp

@@ -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}
 
     };
 

src/benchmarks/static_rtree.cpp

@@ -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
 {
 

src/engine/api/json_factory.cpp

@@ -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(
+        step_maneuver.values["modifier"] =
-            "modifier",
+            osrm::guidance::instructionModifierToString(maneuver.instruction.direction_modifier);
-            osrm::guidance::instructionModifierToString(maneuver.instruction.direction_modifier));
 
-    step_maneuver.values.emplace("location", detail::coordinateToLonLat(maneuver.location));
+    step_maneuver.values["location"] = detail::coordinateToLonLat(maneuver.location);
-    step_maneuver.values.emplace("bearing_before",
+    step_maneuver.values["bearing_before"] = detail::roundAndClampBearing(maneuver.bearing_before);
-                                 detail::roundAndClampBearing(maneuver.bearing_before));
+    step_maneuver.values["bearing_after"] = detail::roundAndClampBearing(maneuver.bearing_after);
-    step_maneuver.values.emplace("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["location"] = detail::coordinateToLonLat(intersection.location);
-    result.values.emplace("bearings", bearings);
+    result.values["bearings"] = bearings;
-    result.values.emplace("entry", entry);
+    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,44 +166,39 @@ 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["distance"] = std::round(step.distance * 10) / 10.;
-
+    route_step.values["duration"] = step.duration;
-    route_step.values.emplace("distance", std::round(step.distance * 10) / 10.);
+    route_step.values["weight"] = step.weight;
-    route_step.values.emplace("duration", step.duration);
+    route_step.values["name"] = std::move(step.name);
-    route_step.values.emplace("weight", step.weight);
-    route_step.values.emplace("name", 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["mode"] = extractor::travelModeToString(step.mode);
-    route_step.values.emplace("maneuver", makeStepManeuver(step.maneuver));
+    route_step.values["maneuver"] = makeStepManeuver(step.maneuver);
-    route_step.values.emplace("geometry", std::move(geometry));
+    route_step.values["geometry"] = std::move(geometry);
-    route_step.values.emplace("driving_side", step.is_left_hand_driving ? "left" : "right");
+    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["intersections"] = std::move(intersections);
-    route_step.values.emplace("intersections", std::move(intersections));
 
     return route_step;
 }
@@ -219,16 +209,14 @@ util::json::Object makeRoute(const guidance::Route &route,
                              const char *weight_name)
 {
     util::json::Object json_route;
-    json_route.values.reserve(6);
+    json_route.values["distance"] = route.distance;
-
+    json_route.values["duration"] = route.duration;
-    json_route.values.emplace("distance", route.distance);
+    json_route.values["weight"] = route.weight;
-    json_route.values.emplace("duration", route.duration);
+    json_route.values["weight_name"] = weight_name;
-    json_route.values.emplace("weight", route.weight);
+    json_route.values["legs"] = std::move(legs);
-    json_route.values.emplace("weight_name", weight_name);
-    json_route.values.emplace("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["location"] = detail::coordinateToLonLat(location);
-
+    waypoint.values["name"] = std::move(name);
-    waypoint.values.emplace("location", detail::coordinateToLonLat(location));
+    waypoint.values["distance"] = distance;
-    waypoint.values.emplace("name", std::move(name));
-    waypoint.values.emplace("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["hint"] = location_hints.ToBase64();
-    waypoint.values.emplace("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["distance"] = leg.distance;
-
+    route_leg.values["duration"] = leg.duration;
-    route_leg.values.emplace("distance", leg.distance);
+    route_leg.values["weight"] = leg.weight;
-    route_leg.values.emplace("duration", leg.duration);
+    route_leg.values["summary"] = std::move(leg.summary);
-    route_leg.values.emplace("weight", leg.weight);
+    route_leg.values["steps"] = std::move(steps);
-    route_leg.values.emplace("summary", std::move(leg.summary));
-    route_leg.values.emplace("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["annotation"] = std::move(annotation);
-    route_leg.values.emplace("annotation", std::move(annotation));
     return route_leg;
 }
 

src/engine/datafacade/mmap_memory_allocator.cpp

@@ -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>();

src/extractor/compressed_edge_container.cpp

@@ -2,11 +2,10 @@
 #include "util/log.hpp"
 
 #include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
-#include <filesystem>
-#include <fstream>
-#include <iostream>
 #include <limits>
 #include <string>
 

src/extractor/location_dependent_data.cpp

@@ -7,17 +7,17 @@
 #include <rapidjson/error/en.h>
 #include <rapidjson/istreamwrapper.h>
 
+#include <boost/filesystem.hpp>
 #include <boost/geometry/algorithms/equals.hpp>
 #include <boost/iterator/function_output_iterator.hpp>
 
-#include <filesystem>
 #include <fstream>
 #include <string>
 
 namespace osrm::extractor
 {
 
-LocationDependentData::LocationDependentData(const std::vector<std::filesystem::path> &file_paths)
+LocationDependentData::LocationDependentData(const std::vector<boost::filesystem::path> &file_paths)
 {
     std::vector<rtree_t::value_type> bounding_boxes;
     for (const auto &path : file_paths)
@@ -32,12 +32,12 @@ LocationDependentData::LocationDependentData(const std::vector<std::filesystem::
 }
 
 void LocationDependentData::loadLocationDependentData(
-    const std::filesystem::path &file_path, std::vector<rtree_t::value_type> &bounding_boxes)
+    const boost::filesystem::path &file_path, std::vector<rtree_t::value_type> &bounding_boxes)
 {
     if (file_path.empty())
         return;
 
-    if (!std::filesystem::exists(file_path) || !std::filesystem::is_regular_file(file_path))
+    if (!boost::filesystem::exists(file_path) || !boost::filesystem::is_regular_file(file_path))
     {
         throw osrm::util::exception(std::string("File with location-dependent data ") +
                                     file_path.string() + " does not exists");

src/extractor/raster_source.cpp

@@ -103,8 +103,8 @@ int RasterContainer::LoadRasterSource(const std::string &path_string,
     util::Log() << "[source loader] Loading from " << path_string << "  ... ";
     TIMER_START(loading_source);
 
-    std::filesystem::path filepath(path_string);
+    boost::filesystem::path filepath(path_string);
-    if (!std::filesystem::exists(filepath))
+    if (!boost::filesystem::exists(filepath))
     {
         throw util::RuntimeError(
             path_string, ErrorCode::FileOpenError, SOURCE_REF, "File not found");

src/extractor/scripting_environment_lua.cpp

@@ -113,7 +113,7 @@ void handle_lua_error(const sol::protected_function_result &luares)
 
 Sol2ScriptingEnvironment::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)
     : file_name(file_name), location_dependent_data(location_dependent_data_paths)
 {
     util::Log() << "Using script " << file_name;
@@ -1254,7 +1254,7 @@ void Sol2ScriptingEnvironment::ProcessSegment(ExtractionSegment &segment)
 
     if (context.has_segment_function)
     {
-        std::optional<sol::protected_function_result> luares;
+        sol::protected_function_result luares;
         switch (context.api_version)
         {
         case 4:
@@ -1274,8 +1274,8 @@ void Sol2ScriptingEnvironment::ProcessSegment(ExtractionSegment &segment)
             break;
         }
 
-        if (luares && !luares->valid())
+        if (!luares.valid())
-            handle_lua_error(*luares);
+            handle_lua_error(luares);
     }
 }
 
@@ -1285,7 +1285,7 @@ void LuaScriptingContext::ProcessNode(const osmium::Node &node,
 {
     BOOST_ASSERT(state.lua_state() != nullptr);
 
-    std::optional<sol::protected_function_result> luares;
+    sol::protected_function_result luares;
 
     // TODO check for api version, make sure luares is always set
     switch (api_version)
@@ -1302,12 +1302,10 @@ void LuaScriptingContext::ProcessNode(const osmium::Node &node,
     case 0:
         luares = node_function(std::cref(node), std::ref(result));
         break;
-    default:
-        BOOST_ASSERT(false && "Invalid API version");
     }
 
-    if (luares && !luares->valid())
+    if (!luares.valid())
-        handle_lua_error(*luares);
+        handle_lua_error(luares);
 }
 
 void LuaScriptingContext::ProcessWay(const osmium::Way &way,
@@ -1316,7 +1314,7 @@ void LuaScriptingContext::ProcessWay(const osmium::Way &way,
 {
     BOOST_ASSERT(state.lua_state() != nullptr);
 
-    std::optional<sol::protected_function_result> luares;
+    sol::protected_function_result luares;
 
     // TODO check for api version, make sure luares is always set
     switch (api_version)
@@ -1333,12 +1331,10 @@ void LuaScriptingContext::ProcessWay(const osmium::Way &way,
     case 0:
         luares = way_function(std::cref(way), std::ref(result));
         break;
-    default:
-        BOOST_ASSERT(false && "Invalid API version");
     }
 
-    if (luares && !luares->valid())
+    if (!luares.valid())
-        handle_lua_error(*luares);
+        handle_lua_error(luares);
 }
 
 } // namespace osrm::extractor

src/partitioner/partitioner.cpp

@@ -19,16 +19,17 @@
 #include "util/json_container.hpp"
 #include "util/log.hpp"
 #include "util/mmap_file.hpp"
-#include "util/timing_util.hpp"
-
-#include <boost/assert.hpp>
-#include <tbb/global_control.h>
 
 #include <algorithm>
-#include <filesystem>
 #include <iterator>
 #include <vector>
 
+#include <boost/assert.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <tbb/global_control.h>
+
+#include "util/timing_util.hpp"
+
 namespace osrm::partitioner
 {
 auto getGraphBisection(const PartitionerConfig &config)
@@ -170,11 +171,11 @@ int Partitioner::Run(const PartitionerConfig &config)
 
         extractor::files::writeManeuverOverrides(filename, maneuver_overrides, node_sequences);
     }
-    if (std::filesystem::exists(config.GetPath(".osrm.hsgr")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
     {
         util::Log(logWARNING) << "Found existing .osrm.hsgr file, removing. You need to re-run "
                                  "osrm-contract after osrm-partition.";
-        std::filesystem::remove(config.GetPath(".osrm.hsgr"));
+        boost::filesystem::remove(config.GetPath(".osrm.hsgr"));
     }
     TIMER_STOP(renumber);
     util::Log() << "Renumbered data in " << TIMER_SEC(renumber) << " seconds";

src/storage/io_config.cpp

@@ -2,12 +2,14 @@
 
 #include "util/log.hpp"
 
-#include <filesystem>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/path.hpp>
 
 namespace osrm::storage
 {
 
-namespace fs = std::filesystem;
+namespace fs = boost::filesystem;
 
 bool IOConfig::IsValid() const
 {

src/storage/storage.cpp

@@ -23,11 +23,13 @@
 #endif
 
 #include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/filesystem/path.hpp>
 #include <boost/interprocess/sync/file_lock.hpp>
 #include <boost/interprocess/sync/scoped_lock.hpp>
 
 #include <cstdint>
-#include <filesystem>
+
 #include <fstream>
 #include <iterator>
 #include <new>
@@ -162,7 +164,7 @@ bool swapData(Monitor &monitor,
 }
 } // namespace
 
-void populateLayoutFromFile(const std::filesystem::path &path, storage::BaseDataLayout &layout)
+void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout)
 {
     tar::FileReader reader(path, tar::FileReader::VerifyFingerprint);
 
@@ -188,11 +190,11 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
 
     util::LogPolicy::GetInstance().Unmute();
 
-    std::filesystem::path lock_path =
+    boost::filesystem::path lock_path =
-        std::filesystem::temp_directory_path() / "osrm-datastore.lock";
+        boost::filesystem::temp_directory_path() / "osrm-datastore.lock";
-    if (!std::filesystem::exists(lock_path))
+    if (!boost::filesystem::exists(lock_path))
     {
-        std::ofstream ofs(lock_path);
+        boost::filesystem::ofstream ofs(lock_path);
     }
 
     boost::interprocess::file_lock file_lock(lock_path.string().c_str());
@@ -255,7 +257,7 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
         std::unique_ptr<storage::BaseDataLayout> static_layout =
             std::make_unique<storage::ContiguousDataLayout>();
         Storage::PopulateLayoutWithRTree(*static_layout);
-        std::vector<std::pair<bool, std::filesystem::path>> files = Storage::GetStaticFiles();
+        std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetStaticFiles();
         Storage::PopulateLayout(*static_layout, files);
         auto static_handle = setupRegion(shared_register, *static_layout);
         regions.push_back({static_handle.data_ptr, std::move(static_layout)});
@@ -264,7 +266,7 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
 
     std::unique_ptr<storage::BaseDataLayout> updatable_layout =
         std::make_unique<storage::ContiguousDataLayout>();
-    std::vector<std::pair<bool, std::filesystem::path>> files = Storage::GetUpdatableFiles();
+    std::vector<std::pair<bool, boost::filesystem::path>> files = Storage::GetUpdatableFiles();
     Storage::PopulateLayout(*updatable_layout, files);
     auto updatable_handle = setupRegion(shared_register, *updatable_layout);
     regions.push_back({updatable_handle.data_ptr, std::move(updatable_layout)});
@@ -283,12 +285,12 @@ int Storage::Run(int max_wait, const std::string &dataset_name, bool only_metric
     return EXIT_SUCCESS;
 }
 
-std::vector<std::pair<bool, std::filesystem::path>> Storage::GetStaticFiles()
+std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
 {
     constexpr bool IS_REQUIRED = true;
     constexpr bool IS_OPTIONAL = false;
 
-    std::vector<std::pair<bool, std::filesystem::path>> files = {
+    std::vector<std::pair<bool, boost::filesystem::path>> files = {
         {IS_OPTIONAL, config.GetPath(".osrm.cells")},
         {IS_OPTIONAL, config.GetPath(".osrm.partition")},
         {IS_REQUIRED, config.GetPath(".osrm.ebg_nodes")},
@@ -308,7 +310,7 @@ std::vector<std::pair<bool, std::filesystem::path>> Storage::GetStaticFiles()
 
     for (const auto &file : files)
     {
-        if (file.first == IS_REQUIRED && !std::filesystem::exists(file.second))
+        if (file.first == IS_REQUIRED && !boost::filesystem::exists(file.second))
         {
             throw util::exception("Could not find required file(s): " + std::get<1>(file).string());
         }
@@ -317,12 +319,12 @@ std::vector<std::pair<bool, std::filesystem::path>> Storage::GetStaticFiles()
     return files;
 }
 
-std::vector<std::pair<bool, std::filesystem::path>> Storage::GetUpdatableFiles()
+std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetUpdatableFiles()
 {
     constexpr bool IS_REQUIRED = true;
     constexpr bool IS_OPTIONAL = false;
 
-    std::vector<std::pair<bool, std::filesystem::path>> files = {
+    std::vector<std::pair<bool, boost::filesystem::path>> files = {
         {IS_OPTIONAL, config.GetPath(".osrm.mldgr")},
         {IS_OPTIONAL, config.GetPath(".osrm.cell_metrics")},
         {IS_OPTIONAL, config.GetPath(".osrm.hsgr")},
@@ -333,7 +335,7 @@ std::vector<std::pair<bool, std::filesystem::path>> Storage::GetUpdatableFiles()
 
     for (const auto &file : files)
     {
-        if (file.first == IS_REQUIRED && !std::filesystem::exists(file.second))
+        if (file.first == IS_REQUIRED && !boost::filesystem::exists(file.second))
         {
             throw util::exception("Could not find required file(s): " + std::get<1>(file).string());
         }
@@ -345,9 +347,9 @@ std::vector<std::pair<bool, std::filesystem::path>> Storage::GetUpdatableFiles()
 std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
 {
     // Figure out the path to the rtree file (it's not a tar file)
-    auto absolute_file_index_path = std::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
+    auto absolute_file_index_path = boost::filesystem::absolute(config.GetPath(".osrm.fileIndex"));
 
-    // Convert the std::filesystem::path object into a plain string
+    // Convert the boost::filesystem::path object into a plain string
     // that can then be stored as a member of an allocator object
     auto rtree_filename = absolute_file_index_path.string();
 
@@ -364,11 +366,11 @@ std::string Storage::PopulateLayoutWithRTree(storage::BaseDataLayout &layout)
  * in that big block.  It updates the fields in the layout parameter.
  */
 void Storage::PopulateLayout(storage::BaseDataLayout &layout,
-                             const std::vector<std::pair<bool, std::filesystem::path>> &files)
+                             const std::vector<std::pair<bool, boost::filesystem::path>> &files)
 {
     for (const auto &file : files)
     {
-        if (std::filesystem::exists(file.second))
+        if (boost::filesystem::exists(file.second))
         {
             populateLayoutFromFile(file.second, layout);
         }
@@ -387,7 +389,7 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
                   file_index_path_ptr + index.GetBlockSize("/common/rtree/file_index_path"),
                   0);
         const auto absolute_file_index_path =
-            std::filesystem::absolute(config.GetPath(".osrm.fileIndex")).string();
+            boost::filesystem::absolute(config.GetPath(".osrm.fileIndex")).string();
         BOOST_ASSERT(static_cast<std::size_t>(index.GetBlockSize(
                          "/common/rtree/file_index_path")) >= absolute_file_index_path.size());
         std::copy(
@@ -480,13 +482,13 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
         metric_name = profile_properties_ptr->GetWeightName();
     }
 
-    if (std::filesystem::exists(config.GetPath(".osrm.partition")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.partition")))
     {
         auto mlp = make_partition_view(index, "/mld/multilevelpartition");
         partitioner::files::readPartition(config.GetPath(".osrm.partition"), mlp);
     }
 
-    if (std::filesystem::exists(config.GetPath(".osrm.cells")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.cells")))
     {
         auto storage = make_cell_storage_view(index, "/mld/cellstorage");
         partitioner::files::readCells(config.GetPath(".osrm.cells"), storage);
@@ -539,7 +541,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         metric_name = properties.GetWeightName();
     }
 
-    if (std::filesystem::exists(config.GetPath(".osrm.hsgr")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.hsgr")))
     {
         const std::string metric_prefix = "/ch/metrics/" + metric_name;
         auto contracted_metric = make_contracted_metric_view(index, metric_prefix);
@@ -565,7 +567,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         }
     }
 
-    if (std::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
     {
         auto exclude_metrics = make_cell_metric_view(index, "/mld/metrics/" + metric_name);
         std::unordered_map<std::string, std::vector<customizer::CellMetricView>> metrics = {
@@ -574,7 +576,7 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         customizer::files::readCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
     }
 
-    if (std::filesystem::exists(config.GetPath(".osrm.mldgr")))
+    if (boost::filesystem::exists(config.GetPath(".osrm.mldgr")))
     {
         auto graph_view = make_multi_level_graph_view(index, "/mld/multilevelgraph");
         std::uint32_t graph_connectivity_checksum = 0;

src/tools/components.cpp

@@ -10,6 +10,7 @@
 #include "util/tarjan_scc.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/iterator/function_output_iterator.hpp>
 
 #include <tbb/parallel_sort.h>
@@ -18,7 +19,6 @@
 #include <cstdlib>
 
 #include <algorithm>
-#include <filesystem>
 #include <fstream>
 #include <memory>
 #include <ostream>
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
     const std::string inpath{argv[1]};
     const std::string outpath{argv[2]};
 
-    if (std::filesystem::exists(outpath))
+    if (boost::filesystem::exists(outpath))
     {
         util::Log(logWARNING) << "Components file " << outpath << " already exists";
         return EXIT_FAILURE;

src/tools/contract.cpp

@@ -6,12 +6,12 @@
 #include "util/timezones.hpp"
 #include "util/version.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <boost/program_options/errors.hpp>
 
 #include <cstdlib>
 #include <exception>
-#include <filesystem>
 #include <new>
 #include <ostream>
 #include <thread>
@@ -86,7 +86,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<std::filesystem::path>(&contractor_config.base_path),
+        boost::program_options::value<boost::filesystem::path>(&contractor_config.base_path),
         "Input file in .osm, .osm.bz2 or .osm.pbf format");
 
     // positional option
@@ -99,7 +99,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        "Usage: " + std::filesystem::path(executable).filename().string() +
+        "Usage: " + boost::filesystem::path(executable).filename().string() +
         " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 

src/tools/customize.cpp

@@ -5,9 +5,9 @@
 #include "util/meminfo.hpp"
 #include "util/version.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
-#include <filesystem>
 #include <iostream>
 #include <thread>
 
@@ -76,7 +76,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<std::filesystem::path>(&customization_config.base_path),
+        boost::program_options::value<boost::filesystem::path>(&customization_config.base_path),
         "Input base file path");
 
     // positional option
@@ -89,7 +89,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        std::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
+        boost::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options

src/tools/extract.cpp

@@ -2,17 +2,19 @@
 #include "osrm/extractor.hpp"
 #include "osrm/extractor_config.hpp"
 #include "util/log.hpp"
-#include "util/meminfo.hpp"
 #include "util/version.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
+
 #include <cstdlib>
 #include <exception>
-#include <filesystem>
 #include <iostream>
 #include <new>
 #include <thread>
 
+#include "util/meminfo.hpp"
+
 using namespace osrm;
 
 enum class return_code : unsigned
@@ -38,7 +40,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description config_options("Configuration");
     config_options.add_options()(
         "profile,p",
-        boost::program_options::value<std::filesystem::path>(&extractor_config.profile_path)
+        boost::program_options::value<boost::filesystem::path>(&extractor_config.profile_path)
             ->default_value("profiles/car.lua"),
         "Path to LUA routing profile")(
         "data_version,d",
@@ -65,7 +67,7 @@ return_code parseArguments(int argc,
             ->default_value(false),
         "Save conditional restrictions found during extraction to disk for use "
         "during contraction")("location-dependent-data",
-                              boost::program_options::value<std::vector<std::filesystem::path>>(
+                              boost::program_options::value<std::vector<boost::filesystem::path>>(
                                   &extractor_config.location_dependent_data_paths)
                                   ->composing(),
                               "GeoJSON files with location-dependent data")(
@@ -86,7 +88,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<std::filesystem::path>(&extractor_config.input_path),
+        boost::program_options::value<boost::filesystem::path>(&extractor_config.input_path),
         "Input file in .osm, .osm.bz2 or .osm.pbf format")(
         "generate-edge-lookup",
         boost::program_options::bool_switch(&dummy)->implicit_value(true)->default_value(false),
@@ -102,7 +104,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        std::filesystem::path(executable).filename().string() +
+        boost::filesystem::path(executable).filename().string() +
         " <input.osm/.osm.bz2/.osm.pbf> [options]");
     visible_options.add(generic_options).add(config_options);
 
@@ -174,14 +176,14 @@ try
         return EXIT_FAILURE;
     }
 
-    if (!std::filesystem::is_regular_file(extractor_config.input_path))
+    if (!boost::filesystem::is_regular_file(extractor_config.input_path))
     {
         util::Log(logERROR) << "Input file " << extractor_config.input_path.string()
                             << " not found!";
         return EXIT_FAILURE;
     }
 
-    if (!std::filesystem::is_regular_file(extractor_config.profile_path))
+    if (!boost::filesystem::is_regular_file(extractor_config.profile_path))
     {
         util::Log(logERROR) << "Profile " << extractor_config.profile_path.string()
                             << " not found!";

src/tools/io-benchmark.cpp

@@ -3,6 +3,9 @@
 #include "util/log.hpp"
 #include "util/timing_util.hpp"
 
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
 #include <cmath>
 #include <cstdio>
 #include <fcntl.h>
@@ -12,8 +15,6 @@
 
 #include <algorithm>
 #include <chrono>
-#include <filesystem>
-#include <fstream>
 #include <iomanip>
 #include <numeric>
 #include <random>
@@ -44,7 +45,7 @@ void runStatistics(std::vector<double> &timings_vector, Statistics &stats)
 }
 } // namespace osrm::tools
 
-std::filesystem::path test_path;
+boost::filesystem::path test_path;
 
 int main(int argc, char *argv[])
 {
@@ -65,7 +66,7 @@ int main(int argc, char *argv[])
         return -1;
     }
 
-    test_path = std::filesystem::path(argv[1]);
+    test_path = boost::filesystem::path(argv[1]);
     test_path /= "osrm.tst";
     osrm::util::Log(logDEBUG) << "temporary file: " << test_path.string();
 
@@ -73,7 +74,7 @@ int main(int argc, char *argv[])
     if (2 == argc)
     {
         // create file to test
-        if (std::filesystem::exists(test_path))
+        if (boost::filesystem::exists(test_path))
         {
             throw osrm::util::exception("Data file already exists: " + test_path.string() +
                                         SOURCE_REF);
@@ -119,7 +120,7 @@ int main(int argc, char *argv[])
     else
     {
         // Run Non-Cached I/O benchmarks
-        if (!std::filesystem::exists(test_path))
+        if (!boost::filesystem::exists(test_path))
         {
             throw osrm::util::exception("data file does not exist" + SOURCE_REF);
         }
@@ -297,9 +298,9 @@ int main(int argc, char *argv[])
                           << "max: " << stats.max << "ms, "
                           << "dev: " << stats.dev << "ms";
 
-        if (std::filesystem::exists(test_path))
+        if (boost::filesystem::exists(test_path))
         {
-            std::filesystem::remove(test_path);
+            boost::filesystem::remove(test_path);
             osrm::util::Log(logDEBUG) << "removing temporary files";
         }
     }

src/tools/partition.cpp

@@ -8,10 +8,10 @@
 #include "util/version.hpp"
 
 #include <boost/algorithm/string/join.hpp>
+#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 #include <boost/range/adaptor/transformed.hpp>
 
-#include <filesystem>
 #include <iostream>
 #include <iterator>
 #include <regex>
@@ -119,7 +119,7 @@ return_code parseArguments(int argc,
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
         "input,i",
-        boost::program_options::value<std::filesystem::path>(&config.base_path),
+        boost::program_options::value<boost::filesystem::path>(&config.base_path),
         "Input base file path");
 
     // positional option
@@ -132,7 +132,7 @@ return_code parseArguments(int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        std::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
+        boost::filesystem::path(executable).filename().string() + " <input.osrm> [options]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options
@@ -216,9 +216,9 @@ try
         return EXIT_FAILURE;
     }
 
-    auto check_file = [](const std::filesystem::path &path)
+    auto check_file = [](const boost::filesystem::path &path)
     {
-        if (!std::filesystem::is_regular_file(path))
+        if (!boost::filesystem::is_regular_file(path))
         {
             util::Log(logERROR) << "Input file " << path << " not found!";
             return false;

src/tools/routed.cpp

@@ -12,6 +12,7 @@
 
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/any.hpp>
+#include <boost/filesystem.hpp>
 #include <boost/optional/optional_io.hpp>
 #include <boost/program_options.hpp>
 
@@ -21,7 +22,6 @@
 
 #include <chrono>
 #include <exception>
-#include <filesystem>
 #include <future>
 #include <iostream>
 #include <new>
@@ -102,7 +102,7 @@ void validate(boost::any &v, const std::vector<std::string> &values, double *, d
 // generate boost::program_options object for the routing part
 inline unsigned generateServerProgramOptions(const int argc,
                                              const char *argv[],
-                                             std::filesystem::path &base_path,
+                                             boost::filesystem::path &base_path,
                                              std::string &ip_address,
                                              int &ip_port,
                                              bool &trial,
@@ -110,8 +110,8 @@ inline unsigned generateServerProgramOptions(const int argc,
                                              int &requested_thread_num,
                                              short &keepalive_timeout)
 {
+    using boost::filesystem::path;
     using boost::program_options::value;
-    using std::filesystem::path;
 
     const auto hardware_threads = std::max<int>(1, std::thread::hardware_concurrency());
 
@@ -148,7 +148,7 @@ inline unsigned generateServerProgramOptions(const int argc,
          value<bool>(&config.use_shared_memory)->implicit_value(true)->default_value(false),
          "Load data from shared memory") //
         ("memory_file",
-         value<std::filesystem::path>(&config.memory_file),
+         value<boost::filesystem::path>(&config.memory_file),
          "DEPRECATED: Will behave the same as --mmap.")(
             "mmap,m",
             value<bool>(&config.use_mmap)->implicit_value(true)->default_value(false),
@@ -192,7 +192,7 @@ inline unsigned generateServerProgramOptions(const int argc,
     // hidden options, will be allowed on command line, but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()(
-        "base,b", value<std::filesystem::path>(&base_path), "base path to .osrm file");
+        "base,b", value<boost::filesystem::path>(&base_path), "base path to .osrm file");
 
     // positional option
     boost::program_options::positional_options_description positional_options;
@@ -204,7 +204,7 @@ inline unsigned generateServerProgramOptions(const int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        std::filesystem::path(executable).filename().string() + " <base.osrm> [<options>]");
+        boost::filesystem::path(executable).filename().string() + " <base.osrm> [<options>]");
     visible_options.add(generic_options).add(config_options);
 
     // parse command line options
@@ -267,7 +267,7 @@ try
     int ip_port;
 
     EngineConfig config;
-    std::filesystem::path base_path;
+    boost::filesystem::path base_path;
 
     int requested_thread_num = 1;
     short keepalive_timeout = 5;

src/tools/store.cpp

@@ -11,11 +11,11 @@
 #include "util/version.hpp"
 
 #include <boost/algorithm/string/case_conv.hpp>
+#include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
 #include <csignal>
 #include <cstdlib>
-#include <filesystem>
 
 using namespace osrm;
 
@@ -97,7 +97,7 @@ void springClean()
 bool generateDataStoreOptions(const int argc,
                               const char *argv[],
                               std::string &verbosity,
-                              std::filesystem::path &base_path,
+                              boost::filesystem::path &base_path,
                               int &max_wait,
                               std::string &dataset_name,
                               bool &list_datasets,
@@ -155,7 +155,7 @@ bool generateDataStoreOptions(const int argc,
     // hidden options, will be allowed on command line but will not be shown to the user
     boost::program_options::options_description hidden_options("Hidden options");
     hidden_options.add_options()("base,b",
-                                 boost::program_options::value<std::filesystem::path>(&base_path),
+                                 boost::program_options::value<boost::filesystem::path>(&base_path),
                                  "base path to .osrm file");
 
     // positional option
@@ -168,7 +168,7 @@ bool generateDataStoreOptions(const int argc,
 
     const auto *executable = argv[0];
     boost::program_options::options_description visible_options(
-        std::filesystem::path(executable).filename().string() + " [<options>] <configuration>");
+        boost::filesystem::path(executable).filename().string() + " [<options>] <configuration>");
     visible_options.add(generic_options).add(config_options);
 
     // print help options if no infile is specified
@@ -242,7 +242,7 @@ try
     util::LogPolicy::GetInstance().Unmute();
 
     std::string verbosity;
-    std::filesystem::path base_path;
+    boost::filesystem::path base_path;
     int max_wait = -1;
     std::string dataset_name;
     bool list_datasets = false;

src/updater/updater.cpp

@@ -25,6 +25,7 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
+#include <boost/filesystem/fstream.hpp>
 
 #include <tbb/blocked_range.h>
 #include <tbb/concurrent_vector.h>
@@ -37,7 +38,6 @@
 #include <atomic>
 #include <bitset>
 #include <cstdint>
-#include <fstream>
 #include <iterator>
 #include <memory>
 #include <tuple>
@@ -408,7 +408,7 @@ void saveDatasourcesNames(const UpdaterConfig &config)
     // for rendering in the debug tiles.
     for (auto const &name : config.segment_speed_lookup_paths)
     {
-        sources.SetSourceName(source, std::filesystem::path(name).stem().string());
+        sources.SetSourceName(source, boost::filesystem::path(name).stem().string());
         source++;
     }
 

src/util/timezones.cpp

@@ -3,11 +3,13 @@
 #include "util/geojson_validation.hpp"
 #include "util/log.hpp"
 
+#include <boost/filesystem/fstream.hpp>
+#include <boost/filesystem/path.hpp>
+
 #include <rapidjson/document.h>
 #include <rapidjson/error/en.h>
 #include <rapidjson/istreamwrapper.h>
 
-#include <filesystem>
 #include <fstream>
 #include <optional>
 #include <regex>
@@ -38,7 +40,7 @@ Timezoner::Timezoner(const char geojson[], std::time_t utc_time_now)
     LoadLocalTimesRTree(doc, utc_time_now);
 }
 
-Timezoner::Timezoner(const std::filesystem::path &tz_shapes_filename, std::time_t utc_time_now)
+Timezoner::Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now)
 {
     util::Log() << "Time zone validation based on UTC time : " << utc_time_now;
 

unit_tests/common/temporary_file.hpp

@@ -1,39 +1,16 @@
 #ifndef UNIT_TESTS_TEMPORARY_FILE_HPP
 #define UNIT_TESTS_TEMPORARY_FILE_HPP
 
-#include <cstdlib>
+#include <boost/filesystem.hpp>
-#include <filesystem>
-#include <random>
-#include <string>
-
-inline std::string random_string(std::string::size_type length)
-{
-    static auto &chrs = "0123456789"
-                        "abcdefghijklmnopqrstuvwxyz"
-                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-    thread_local static std::mt19937 rg{std::random_device{}()};
-    thread_local static std::uniform_int_distribution<std::string::size_type> pick(
-        0, sizeof(chrs) - 2);
-
-    std::string s;
-    s.reserve(length);
-
-    while (length--)
-    {
-        s += chrs[pick(rg)];
-    }
-    return s;
-}
 
 struct TemporaryFile
 {
-    TemporaryFile() : path(std::filesystem::temp_directory_path() / random_string(8)) {}
+    TemporaryFile() : path(boost::filesystem::unique_path()) {}
     TemporaryFile(const std::string &path) : path(path) {}
 
-    ~TemporaryFile() { std::filesystem::remove(path); }
+    ~TemporaryFile() { boost::filesystem::remove(path); }
 
-    std::filesystem::path path;
+    boost::filesystem::path path;
 };
 
 #endif // UNIT_TESTS_TEMPORARY_FILE_HPP

unit_tests/extractor/location_dependent_data_tests.cpp

@@ -1,14 +1,11 @@
 #include "extractor/location_dependent_data.hpp"
 
 #include "../common/range_tools.hpp"
-#include "../common/temporary_file.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <cstdlib>
-#include <filesystem>
 #include <fstream>
-#include <random>
 #include <vector>
 
 BOOST_AUTO_TEST_SUITE(location_dependent_data_tests)
@@ -19,13 +16,14 @@ using point_t = LocationDependentData::point_t;
 
 struct LocationDataFixture
 {
-    LocationDataFixture(const std::string &json)
+    LocationDataFixture(const std::string &json) : temporary_file(boost::filesystem::unique_path())
     {
-        std::ofstream file(temporary_file.path.string());
+        std::ofstream file(temporary_file.string());
         file << json;
     }
+    ~LocationDataFixture() { remove(temporary_file); }
 
-    TemporaryFile temporary_file;
+    boost::filesystem::path temporary_file;
 };
 
 BOOST_AUTO_TEST_CASE(polygon_tests)
@@ -52,7 +50,7 @@ BOOST_AUTO_TEST_CASE(polygon_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file.path});
+    LocationDependentData data({fixture.temporary_file});
 
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, 0)).empty());
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(1, 1)), 0);
@@ -88,7 +86,7 @@ BOOST_AUTO_TEST_CASE(multy_polygon_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file.path});
+    LocationDependentData data({fixture.temporary_file});
 
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, 2)).empty());
     BOOST_CHECK(data.GetPropertyIndexes(point_t(0, -3)).empty());
@@ -119,7 +117,7 @@ BOOST_AUTO_TEST_CASE(polygon_merging_tests)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file.path});
+    LocationDependentData data({fixture.temporary_file});
 
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(-3, 3)), 0);
     CHECK_EQUAL_RANGE(data.GetPropertyIndexes(point_t(-3, 1)), 0);
@@ -155,7 +153,7 @@ BOOST_AUTO_TEST_CASE(staircase_polygon)
 }
 ]})json");
 
-    LocationDependentData data({fixture.temporary_file.path});
+    LocationDependentData data({fixture.temporary_file});
 
     // all corners
     BOOST_CHECK(!data.GetPropertyIndexes(point_t(0, 0)).empty());

unit_tests/extractor/name_table.cpp

@@ -3,9 +3,9 @@
 
 #include "../common/temporary_file.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <filesystem>
 #include <iomanip>
 #include <iostream>
 #include <sstream>

unit_tests/extractor/raster_source.cpp

@@ -4,10 +4,9 @@
 
 #include <osrm/coordinate.hpp>
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <filesystem>
-
 BOOST_AUTO_TEST_SUITE(raster_source)
 
 using namespace osrm;

unit_tests/storage/data_layout.cpp

@@ -3,10 +3,10 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <cmath>
-#include <filesystem>
 
 BOOST_AUTO_TEST_SUITE(data_layout)
 

unit_tests/storage/serialization.cpp

@@ -5,9 +5,9 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <filesystem>
 #include <random>
 
 BOOST_AUTO_TEST_SUITE(serialization)

unit_tests/updater/timezoner.cpp

@@ -2,10 +2,9 @@
 #include "util/geojson_validation.hpp"
 #include "util/timezones.hpp"
 
+#include <boost/filesystem/path.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <filesystem>
-
 BOOST_AUTO_TEST_SUITE(timezoner)
 
 using namespace osrm;
@@ -23,7 +22,7 @@ BOOST_AUTO_TEST_CASE(timezoner_test)
     std::time_t now = time(0);
     BOOST_CHECK_NO_THROW(Timezoner tz(json, now));
 
-    std::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
+    boost::filesystem::path test_path(TEST_DATA_DIR "/test.geojson");
     BOOST_CHECK_NO_THROW(Timezoner tz(test_path, now));
 
     // missing opening bracket

unit_tests/util/serialization.cpp

@@ -3,10 +3,9 @@
 #include "../common/range_tools.hpp"
 #include "../common/temporary_file.hpp"
 
+#include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
-#include <filesystem>
-
 BOOST_AUTO_TEST_SUITE(serialization)
 
 using namespace osrm;

unit_tests/util/static_rtree.cpp

@@ -227,7 +227,7 @@ void sampling_verify_rtree(RTreeT &rtree,
 }
 
 template <typename RTreeT, typename FixtureT>
-auto make_rtree(const std::filesystem::path &path, FixtureT &fixture)
+auto make_rtree(const boost::filesystem::path &path, FixtureT &fixture)
 {
     return RTreeT(fixture.edges, fixture.coords, path);
 }