Refreshed benchmark numbers and tightened apples-to-apples

Author: gistrec

.github/workflows/ci.yml

@@ -71,3 +71,13 @@ jobs:
 
       - name: Test
         run: ctest --test-dir build -C Release --output-on-failure
+
+      # Smoke-build the dependency-free portion of the benchmarks so that
+      # changes to benchmarks/CMakeLists.txt or the bench source files can't
+      # silently break the build. We don't run the benchmarks here — that
+      # requires installing S2/Boost/GeographicLib and is intentionally
+      # out-of-scope for CI.
+      - name: Smoke-build benchmarks (no external deps)
+        run: |
+          cmake -S . -B build-bench -DGEO_UTILS_CPP_BUILD_BENCHMARKS=ON -DGEO_UTILS_CPP_BUILD_TESTS=OFF -DGEO_UTILS_CPP_BUILD_EXAMPLES=OFF -DCMAKE_BUILD_TYPE=Release
+          cmake --build build-bench --config Release --target bench_geo_utils bench_naive

README.md

@@ -126,18 +126,21 @@ int main() {
 `geo-utils-cpp` is a near-zero-overhead wrapper over the math itself, with a
 tiny disk footprint thanks to header-only + zero dependencies.
 
-| Library              | `distance_between` (M pairs/s) | `contains` (poly N=100, M qps) | Install size  |
-| -------------------- | -----------------------------: | -----------------------------: | ------------: |
-| **geo-utils-cpp**    |                       **36.7** |                       **2.17** |     **32 KB** |
-| naive haversine      |                           37.0 |                            —   |             0 |
-| S2 Geometry          |                           14.3 |                          18.0  |       32.8 MB |
-| Boost.Geometry       |                           40.0 |                           0.23 |       12.3 MB |
-| GeographicLib        |                            1.2 |                  no native PIP |        4.6 MB |
-
-Apple M1 · clang 17 · `-O2 -DNDEBUG`. We're tied with hand-written haversine
-on raw math, ~7× faster than Boost.Geometry on point-in-polygon, and have a
-**144–1000× smaller install footprint** than the alternatives. S2 wins on
-large-polygon containment thanks to spatial indexing.
+| Library              | `distance_between` (M pairs/s) | `contains` (poly N=10, M qps) | Install size  |
+| -------------------- | -----------------------------: | ----------------------------: | ------------: |
+| **geo-utils-cpp**    |                       **39.5** |                      **15.9** |     **32 KB** |
+| naive haversine      |                           37.4 |                            —  |             0 |
+| S2 Geometry          |                           15.1 |                          12.9 |       32.8 MB |
+| Boost.Geometry       |                           38.4 |                           1.85|       12.3 MB |
+| GeographicLib        |                            1.2 |                 no native PIP |        4.6 MB |
+
+Apple M1 · clang 17 · `-O2 -DNDEBUG`. Tied with Boost.Geometry on
+per-pair ops (`distance`, `heading`) within noise; ahead on polygon ops
+(`area`, `path_length`, `contains` for tiny polygons). Faster than S2 on
+`distance`, `heading`, `area`, `path_length`, and on `contains` against
+~10-vertex polygons. **S2 wins `contains` from ~100 vertices onward** via
+its bounding-rectangle prefilter. **144–1000× smaller install footprint**
+than the alternatives. Zero overhead over hand-written haversine.
 
 See [docs/benchmarks.md](docs/benchmarks.md) for the full methodology, all
 operations, and a discussion of when to reach for each library.

benchmarks/CMakeLists.txt

@@ -19,7 +19,8 @@ set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE BOOL "" FORCE)
 
 FetchContent_Declare(
     google_benchmark
-    URL https://github.com/google/benchmark/archive/v1.8.4.tar.gz
+    URL      https://github.com/google/benchmark/archive/v1.8.4.tar.gz
+    URL_HASH SHA256=3e7059b6b11fb1bbe28e33e02519398ca94c1818874ebed18e504dc6f709be45
     DOWNLOAD_EXTRACT_TIMESTAMP ON
 )
 FetchContent_MakeAvailable(google_benchmark)
@@ -54,8 +55,9 @@ _geo_utils_cpp_add_bench(naive     speed/bench_naive.cpp)
 # --- Optional: S2 Geometry --------------------------------------------------
 #
 # vcpkg port name: `s2geometry`. Homebrew formula: `s2geometry`. The CMake
-# package is conventionally exported as `s2`.
-find_package(s2 QUIET)
+# package is conventionally exported as `s2`, but case-sensitive filesystems
+# may also see `S2Config.cmake` from some installs — accept either.
+find_package(s2 NAMES s2 S2 QUIET)
 if(s2_FOUND)
     _geo_utils_cpp_add_bench(s2 speed/bench_s2.cpp s2::s2)
     message(STATUS "geo-utils-cpp benchmarks: S2 found — bench_s2 enabled.")
@@ -73,9 +75,9 @@ if(POLICY CMP0167)
     cmake_policy(SET CMP0167 NEW)
 endif()
 
-find_package(Boost 1.70 QUIET CONFIG)
+find_package(Boost 1.71 QUIET CONFIG)
 if(NOT Boost_FOUND)
-    find_package(Boost 1.70 QUIET)
+    find_package(Boost 1.71 QUIET)
 endif()
 
 if(Boost_FOUND)

benchmarks/size/consumer_boost.cpp

@@ -14,8 +14,9 @@ using Poly = bg::model::polygon<Pt>;
 
 int main(int argc, char** argv) {
     if (argc < 5) return 1;
-    Pt a(std::atof(argv[2]), std::atof(argv[1]));  // (lng, lat)
-    Pt b(std::atof(argv[4]), std::atof(argv[3]));
+    char* end;
+    Pt a(std::strtod(argv[2], &end), std::strtod(argv[1], &end));  // (lng, lat)
+    Pt b(std::strtod(argv[4], &end), std::strtod(argv[3], &end));
     Poly poly;
     bg::append(poly.outer(), Pt{-74.1, 40.7});
     bg::append(poly.outer(), Pt{-74.1, 40.8});

benchmarks/size/consumer_geo_utils.cpp

@@ -6,12 +6,14 @@
 #include <cstdlib>
 #include <vector>
 
-#include <geo/geo.hpp>
+#include <geo/poly.hpp>
+#include <geo/spherical.hpp>
 
 int main(int argc, char** argv) {
     if (argc < 5) return 1;
-    geo::LatLng a(std::atof(argv[1]), std::atof(argv[2]));
-    geo::LatLng b(std::atof(argv[3]), std::atof(argv[4]));
+    char* end;
+    geo::LatLng a(std::strtod(argv[1], &end), std::strtod(argv[2], &end));
+    geo::LatLng b(std::strtod(argv[3], &end), std::strtod(argv[4], &end));
     std::vector<geo::LatLng> poly = {
         {40.7, -74.1}, {40.8, -74.1}, {40.8, -74.0}, {40.7, -74.0},
     };

benchmarks/size/consumer_geographiclib.cpp

@@ -12,9 +12,10 @@
 int main(int argc, char** argv) {
     if (argc < 5) return 1;
     double s12 = 0.0;
+    char* end;
     GeographicLib::Geodesic::WGS84().Inverse(
-        std::atof(argv[1]), std::atof(argv[2]),
-        std::atof(argv[3]), std::atof(argv[4]),
+        std::strtod(argv[1], &end), std::strtod(argv[2], &end),
+        std::strtod(argv[3], &end), std::strtod(argv[4], &end),
         s12);
     std::printf("%.1f -1\n", s12);
     return 0;

benchmarks/size/consumer_naive.cpp

@@ -49,8 +49,9 @@ bool contains(LL p, const std::vector<LL>& poly) {
 
 int main(int argc, char** argv) {
     if (argc < 5) return 1;
-    LL a{std::atof(argv[1]), std::atof(argv[2])};
-    LL b{std::atof(argv[3]), std::atof(argv[4])};
+    char* end;
+    LL a{std::strtod(argv[1], &end), std::strtod(argv[2], &end)};
+    LL b{std::strtod(argv[3], &end), std::strtod(argv[4], &end)};
     std::vector<LL> poly = {
         {40.7, -74.1}, {40.8, -74.1}, {40.8, -74.0}, {40.7, -74.0},
     };

benchmarks/size/consumer_s2.cpp

@@ -13,8 +13,9 @@
 
 int main(int argc, char** argv) {
     if (argc < 5) return 1;
-    const auto a = S2LatLng::FromDegrees(std::atof(argv[1]), std::atof(argv[2])).ToPoint();
-    const auto b = S2LatLng::FromDegrees(std::atof(argv[3]), std::atof(argv[4])).ToPoint();
+    char* end;
+    const auto a = S2LatLng::FromDegrees(std::strtod(argv[1], &end), std::strtod(argv[2], &end)).ToPoint();
+    const auto b = S2LatLng::FromDegrees(std::strtod(argv[3], &end), std::strtod(argv[4], &end)).ToPoint();
     std::vector<S2Point> verts = {
         S2LatLng::FromDegrees(40.7, -74.1).ToPoint(),
         S2LatLng::FromDegrees(40.8, -74.1).ToPoint(),

benchmarks/size/measure.sh

@@ -22,6 +22,8 @@ fi
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ROOT_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
 TMP="$(mktemp -d)"
+LOG_DIR="${ROOT_DIR}/build-bench/size-logs"
+ANY_FAILURE=0
 trap 'rm -rf "${TMP}"' EXIT
 
 is_macos() { [ "$(uname)" = "Darwin" ]; }
@@ -62,11 +64,18 @@ build() {
     # name, source, extra_flags...
     local name="$1"; shift
     local source="$1"; shift
-    local out="${TMP}/${name// /_}"
-    if "${CXX}" ${CXXFLAGS} ${EXTRA_LD} "${source}" -o "${out}" "$@" 2>"${TMP}/${name}.log"; then
+    local safe_name="${name// /_}"
+    local out="${TMP}/${safe_name}"
+    local log="${TMP}/${safe_name}.log"
+    if "${CXX}" ${CXXFLAGS} ${EXTRA_LD} "${source}" -o "${out}" "$@" 2>"${log}"; then
         strip "${out}" 2>/dev/null || true
         file_size "${out}"
     else
+        # Persist the failure log so the user can diagnose after the trap
+        # cleans up TMP.
+        mkdir -p "${LOG_DIR}"
+        cp "${log}" "${LOG_DIR}/${safe_name}.log"
+        ANY_FAILURE=1
         echo ""  # signals "skipped"
     fi
 }
@@ -154,4 +163,6 @@ echo "  - 'Installed' for geo-utils-cpp is the include/ directory (everything"
 echo "    you ship). For other libraries it's the package install prefix on"
 echo "    Homebrew (or the geometry subset for Boost) — what the user must"
 echo "    have on disk to consume the library."
-echo "  - Build logs (if any) are in: ${TMP} (kept until script exit)"
+if [ "${ANY_FAILURE}" = "1" ]; then
+    echo "  - Some builds failed. Diagnostic logs preserved in: ${LOG_DIR}"
+fi

benchmarks/speed/bench_boost.cpp

@@ -4,8 +4,19 @@
 // Boost.Geometry equivalents using `cs::spherical_equatorial<degree>` —
 // the same sphere-based model we use, so this is a fair head-to-head.
 //
+// Conversion policy (matches bench_s2.cpp):
+//   * Streams of points: converted INSIDE the timed loop.
+//   * Long-lived polygon: pre-converted ONCE outside the loop.
+//
 // Coordinate convention reminder: Boost.Geometry expects (lng, lat) order
 // for spherical_equatorial points.
+//
+// Strategy note for `contains`: bg::within with cs::spherical_equatorial
+// auto-selects strategy::within::spherical_winding, which traces great-circle
+// edges and classifies crossings carefully. Our own `geo::contains` defaults
+// to rhumb-line edges (geodesic=false), which is significantly cheaper.
+// The performance gap on `contains` reflects this algorithmic difference,
+// not a Boost misconfiguration.
 
 #include <benchmark/benchmark.h>
 
@@ -85,24 +96,21 @@ static void BM_Boost_Heading(benchmark::State& state) {
 }
 BENCHMARK(BM_Boost_Heading)->Arg(1000)->Arg(100000);
 
-// --- contains (within) -----------------------------------------------------
+// --- contains: polygon converted once; queries converted inside the loop --
 
 static void BM_Boost_Contains(benchmark::State& state) {
     const auto poly_ll = geo::bench::regular_polygon(
         static_cast<std::size_t>(state.range(0)), 40.0, -74.0, 5.0);
     const Polygon poly = to_boost_polygon(poly_ll);
 
     const auto queries_ll = geo::bench::queries_around(40.0, -74.0, 5.0, 1000);
-    std::vector<Point> queries;
-    queries.reserve(queries_ll.size());
-    for (const auto& q : queries_ll) queries.push_back(to_boost_point(q));
 
     for (auto _ : state) {
-        for (const auto& q : queries) {
-            benchmark::DoNotOptimize(bg::within(q, poly));
+        for (const auto& q : queries_ll) {
+            benchmark::DoNotOptimize(bg::within(to_boost_point(q), poly));
         }
     }
-    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(queries.size()));
+    state.SetItemsProcessed(state.iterations() * static_cast<std::int64_t>(queries_ll.size()));
 }
 BENCHMARK(BM_Boost_Contains)->Arg(10)->Arg(100)->Arg(1000);
 
@@ -122,13 +130,13 @@ static void BM_Boost_Area(benchmark::State& state) {
 }
 BENCHMARK(BM_Boost_Area)->Arg(10)->Arg(100)->Arg(1000);
 
-// --- path_length -----------------------------------------------------------
+// --- path_length: input is lat/lng; convert + sum inside the timed loop ---
 
 static void BM_Boost_PathLength(benchmark::State& state) {
     const auto path_ll = geo::bench::random_points(static_cast<std::size_t>(state.range(0)));
-    const LineString ls = to_boost_linestring(path_ll);
     bg::strategy::distance::haversine<double> haversine(kEarthRadius);
     for (auto _ : state) {
+        LineString ls = to_boost_linestring(path_ll);
         benchmark::DoNotOptimize(bg::length(ls, haversine));
     }
     state.SetItemsProcessed(state.iterations() * state.range(0));