Skip to content

perf: decide polygon validity without Boost where it is certain; faster make_valid - #995

Open
dktue wants to merge 12 commits into
systemed:masterfrom
dktue:perf/planet-3min-03-validity-precheck
Open

dktue wants to merge 12 commits into
systemed:masterfrom
dktue:perf/planet-3min-03-validity-precheck

Conversation

@dktue

@dktue dktue commented Nov 15, 2026 •

Copy link
Copy Markdown
Contributor

Gain: planet (96 threads) about -16% wall for this PR, compounded over 10 rounds: precheck round 1 -12.5 s, deferred validity of big relations -11 s, ring point index -9 s (Lake Huron 16.6 s -> 1.7 s), precheck in writeMultiPolygon -8 s, rounds 2-4 -5/-3/-3 s, make_valid -3 s.

Series total: planet (in memory, 96 threads) about 9:50 for perf/shared-pieces + #989/#990 (Nov 8; glibc, Boost 1.74, GCC 11, Lua 5.3) -> 3:08 for the last commit (Nov 14; jemalloc with THP settings, Boost 1.83, GCC 14, Lua 5.4), -68%. Compounding the per-round A/B measurements, the code of this series accounts for about -63%; the newer toolchain (about -8%) and jemalloc (about -8%) for the rest.

Stacked on perf/shared-pieces (#1001) and the previous PR of this series (perf/planet-3min-02-reading-phase), so the diff of this PR on GitHub also shows the commits below it; review the last commit. The whole series is on perf/planet-3min.

What

Boost's is_valid and the repair (make_valid) were the largest geometry cost left, both while reading (relations, ways) and in the tile phase (clipped polygons). Output byte-identical.

  • Precheck (geom.cpp), rounds 1-4: a conservative test that answers "certainly valid" or "unsure" (then Boost decides, as before): bucketed segment sweeps instead of sorting, one-pass ring checks, monotone chunks, hole placement by crossing parity, orientation shortcuts. An "AfterClip" variant for rect_clip results uses Boost's own side test (rounding bound, no distance tolerance) and decides near-spikes the way Boost does. Verified with a build that also ran Boost on every "certainly valid": 1.5 billion planet calls, 0 mismatches.
  • The precheck now also runs before Boost in writeMultiPolygon and in the repair's acceptance test; a linestring with two distinct finite points is known valid without is_valid.
  • ring_point_index.h: point-in-ring through a y-band segment index for big rings, used inside Boost's validity and relate algorithms (Lake Huron r1205151: 16.6 s -> 1.7 s).
  • make_valid (correct.hpp): self-intersections found with an index (rtree fallback), adjacent pairs handled without Boost, rings clearly apart never intersected, results moved instead of copied; correct.hpp now includes geom.h, and the unit test links geom.o.
  • Repair: an orientation-only fault is fixed by reversing in place, also for polygons with holes (exact for integer tile coordinates).
  • Relations with >= 100k points that still need is_valid are checked in the background until the tiles start; a relation that needs no correction is checked in the cache and not copied.

Output

Byte-identical output: the precheck only ever answers "certainly valid" (otherwise Boost decides as before), and the faster make_valid paths produce the same rings. Verification builds that also ran Boost on every "certainly valid" answer found 0 mismatches in 1.5 billion planet calls (round 4) and in every earlier round.

Verification

  • Builds (CMake and Makefile, GCC 13, Boost 1.83, Lua 5.4) and passes the unit tests (make test, 18 suites, 0 failures). CI passes on Linux (Makefile with LuaJIT, CMake), macOS and Windows; locally also checked with LuaJIT 2.1 and Boost 1.87 headers.
  • Output on four extracts (Lake Huron, Canberra, Patagonia, Canary Islands; 4 threads, bundled profile, no shapefiles): byte-identical to the final commit of the series (sha256 Huron 40bba7e1, Canberra d916213b, Patagonia 6a1b4ca3, Canary 69fc28eb).
  • geom.cpp (which includes correct.hpp) also compiles against Boost.Geometry 1.87, which renamed segment_intersection_info's robust_ra/robust_rb to ra/rb (handled with a version check).

🤖 Generated with Claude Code

dktue and others added 6 commits November 7, 2026 14:48
systemed#983 (combined snapshot)

For testing only, not for merging. One commit with the combined tree that
built the planet in 14 min 03 s (in memory, 96 threads) for systemed#977:

master 2789651 + systemed#933, systemed#959, systemed#966, systemed#968, systemed#970, systemed#971, systemed#972, systemed#973, systemed#974, systemed#975,
systemed#976, systemed#978, systemed#979 (open performance PRs), systemed#981 (deterministic tile content),
systemed#942 (deterministic POI order) and systemed#983 (ordered .pmtiles/.mbtiles writer,
64 MB per thread). Each change is reviewed in its own PR.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Same change as systemed#986. With it, the sort before the tile phase takes ~13 s
instead of 2-5 minutes at 96 threads, so planet times no longer vary by
minutes between runs (14:12 / 14:08 in memory at 96 threads).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
end() woke every thread waiting in waitForRoom() after each batch it wrote,
although most of the time the held tiles were still over the limit. At 96
threads that meant dozens of threads waking, finding no room and sleeping
again for every batch: 125M context switches and 7,700 s of system time on
the planet. Now they are only woken once the held tiles are back under the
limit. Planet in memory, 96 threads, all open performance PRs:
14:05 -> 12:45 (-9.5%), system time 7,708 -> 2,868 s, context switches
125M -> 35M. Output unchanged (same batches, same order).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Every tile batch that needs a large polygon copied it from the store and
clipped it from scratch, at every zoom. Now polygons with at least 10,000
points are clipped once per z8 tile, before the tiles are written (all
threads, largest polygon first), and tiles below clip from that piece.
After that the pieces are only read, so there is no lock while tiles are
written; a z6 tile's pieces are freed once no tile in it is still to come.

A piece only depends on the polygon and the z8 tile, so the output stays
the same for any thread count. A piece whose clip needed the repair path is
not used: once one came out empty and a lake vanished from all tiles below.

Planet in memory, 96 threads, all open performance PRs + systemed#983's wake-up
fix: 12:45 -> 10:55 (-14.4%), user CPU -27%, peak RSS +7.5 GB.
Germany byte-identical at 32 and 8 threads; planet sample: same feature
counts, area within 0.003%.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
At 96 threads the one thread that writes batches in order became the
bottleneck of the tile phase: busy 260 s of a 323 s tile phase, with the
others waiting for room for 5,100 thread-seconds. Writing the bytes was
more than half of its work (ofstream::write, and a tellp() per tile).

- The writer keeps its own tile data offset instead of calling tellp() for
  every tile, and the stream gets a 4 MB buffer.
- OrderedBatches can take a second step, flushItem: also in batch order and
  one thread at a time, but run by whichever thread is free, so it doesn't
  hold up the first step. PMTiles places tiles (offset, repeated tiny tiles,
  index) in the first step and writes their bytes in the second.

The file is byte-identical. Planet in memory, 96 threads, all open
performance PRs: 10:41 -> 9:54 (-7.3%); tile phase 323 -> 245 s, threads
busy 76 -> 94 of 96 on average. New test: the second step runs in order,
never twice at once, and always after the first (also clean under TSan).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The pieces used to be computed in a pass of their own before the tile phase,
which ended with one thread on the largest piece (~6 s on the planet) while
all others waited. Now the tile threads compute them before their first
tile, largest polygon first, and go on to tiles once no piece is left to
start; a tile that needs a piece still being computed waits for just that
one (shared_future). A piece is known before the tiles start, so the map
doesn't change and tiles look pieces up without a lock as before.

Output byte-identical (Germany at 32 and 8 threads).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
- polylabel.h: rename edgeDistBound's parameter `near` to `nearCell`.
  tile_data.h includes boost/asio since systemed#972, which pulls in windows.h on
  Windows, and windows.h defines `near` as an empty macro.
- test/shp_mem_tiles.test.cpp (systemed#979): include shp_mem_tiles.h before
  minunit.h. minunit.h sets _POSIX_C_SOURCE, which on macOS hides ip_mreq,
  and boost/asio (through tile_data.h) needs it.

Renames and include order only; output unchanged.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
@dktue
dktue force-pushed the perf/planet-3min-03-validity-precheck branch from 0619313 to eca3284 Compare November 15, 2026 13:38
…uctors have run (macOS)

On macOS the main thread's thread-local destructors run after the static
destructors. Two of them touched objects that were already gone, and the
unit tests aborted at exit with "mutex lock failed: Invalid argument":

- mmap_allocator.cpp: thread_regions_t's destructor locks
  mmap_allocator_mutex and appends to free_mmap_files /
  free_mmap_shm_regions. These three are now allocated once and never
  destroyed. ~mmap_dir_t clears free_mmap_files first, so --store files
  are still released and deleted as before (that list used to be destroyed
  just before mmap_dir).
- LeasedStore (tile_data.cpp): a thread gives its store leases back to
  the TileDataSource when it ends; the main thread does that at exit, after
  the sources (locals of main(), or of a unit test such as
  test_shp_mem_tiles) are destroyed, locking a destroyed storeMutex. The
  sources are now registered while alive (an immortal registry), and a
  lease goes back only to a live source. Sources are also numbered: a new
  source at the address of a destroyed one no longer gets that one's
  lease.

No change in output.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
dktue and others added 4 commits November 16, 2026 13:27
…+ systemed#990)

systemed#989 and systemed#990 adapted to perf/shared-pieces, as the base of this series.

- SortedNodeStore/SortedWayStore::finalize publish the leftover groups
  (groups split between worker batches) from all threads instead of one
  after the other. On the planet that was ~10 s after the ways pass with
  every other thread idle. Same store content. (systemed#989, unchanged)
- PMTiles::close collects the directory entries and cuts them into leaves
  exactly as before, then serializes and compresses the leaves on all
  cores and writes them in order: ~9 s -> 3 s on the planet, byte-identical
  file. (systemed#990; on perf/shared-pieces the two-step writer already holds the
  file, so the leaf writes need no lock and fileMutex goes.)

Planet (in memory, 96 threads): -9 s and -6 s. Output byte-identical to
perf/shared-pieces.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
…atorArea

Most ways run exactly the same Lua as many ways before them: the same tag
reads give the same results and the same calls. With `way_memo = true` in
the profile, tilemaker records, per thread, a tree of what way_function
read (Find, Holds, IsClosed, NextRelation, ...) and which tilemaker
functions it then called (Layer, Attribute..., MinZoom), and replays the
calls for a way whose reads give the same results, without entering Lua.
Ways with anything else (geometry queries, Id, relation tags, globals)
run through Lua as before.

- Opt-in declarations, documented in CONFIGURATION.md: way_memo_values
  (tags only tested for being empty and copied, e.g. name; replayed with
  the way's own value, optionally its length), way_memo_area (MercatorArea
  only compared with given numbers), way_memo_relations (NextRelation only
  tested, relation tags only via FindInRelation), and node_memo* for
  node_function. Multipolygon relations get a record of their own.
- The walk reads the way's tags once into small key slots (memo_keys.h);
  TagMap builds its hash only when Lua asks for a tag.
- Bounded: 2^18 nodes per thread, at most 256 children per node, full trees
  are compacted; a value-heavy branch (a name, a house number) falls back
  to Lua.
- New Lua functions MercatorArea() (planar Web Mercator area) and
  MinZoomByArea(limit, thresholds): the minimum-zoom-by-area rule worked
  out in C++, so that way_function stays replayable.
- The bundled OpenMapTiles profile uses all of this, and keeps tilemaker's
  functions in locals.
- The Makefile compiles as C++17, like CMake since systemed#953 (memo_keys.h
  uses std::string_view). Works with Lua 5.1/LuaJIT too (lua_objlen where
  luaL_len is missing).

Output: the only change in this series. The old profile computed
MercatorArea in Lua as Area() / cos^2(latitude of the centroid); the
native function is the planar area on the Web Mercator plane. Areas close
to a minimum-zoom threshold can land on the other side of it, so some
landuse, water and building polygons start one zoom earlier or later.
Everything else is identical; the memo itself does not change the output.

Planet (96 threads): way_function replayed for ~1.17 billion of 1.22
billion ways, node_function for ~211 million nodes; together with the
native area about -21% wall.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
…erts)

Exact speed-ups of reading the .pbf and filling the stores and indexes;
output byte-identical.

- PBF: packed varints decoded in one SWAR pass; latitude to latp through a
  polynomial with an exact fallback (checked against the old function for
  every E7 latitude).
- Node/way stores: chunks decoded lazily with a fused SSSE3 decoder,
  uncompressed chunks kept in the per-thread cache, ways decoded in one
  pass, a small linestring cache; leftover way groups are moved, not
  copied, at finalize. Node/way block batches handed out guided.
- Relations: UsedWays collects the member ways per thread (a global lock
  per member way was the main kernel spin-lock cost) and is finalized into
  a bitmap on all threads (atomic OR; _InterlockedOr64 on MSVC); a
  thread's list is found by the UsedWays' own number, not its address (a
  new UsedWays at the address of a destroyed one picked up the old list -
  seen in the unit test).
  RelationScanStore finds a way's relations by a hash index, then by
  sorted shard arrays with a per-reader cursor. Heavy relation blocks go
  first and the last blocks are split, so the pass doesn't end on one
  thread. Multipolygon rings are joined in one buffer (no deque, no
  std::map of done ways), reading each way's coordinates once.
- Tags and attributes: TagMap compares keys by an 8-byte prefix;
  DequeMap gets an open-addressing hash index, hashed once per lookup; the
  hot attribute-pair shard is read without its lock once it is full.
- Output index: small-index adds are staged per thread and appended per
  shard in bulk (one lock per z6 tile run instead of one per tile); the
  tiles of a linestring are found faster.
- Memory: way pieces are handed to the orphanage in a vector of their own
  size; the thread's buffer keeps its capacity for the next pieces.

Planet (96 threads): about -18% wall over the rounds (e.g. UsedWays
-21 s, node decode -18 s, attribute store -9 s).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
…e_valid

Boost's is_valid and the repair (make_valid) were the largest geometry
cost left, both while reading (relations, ways) and in the tile phase
(clipped polygons). Output byte-identical.

- Precheck (geom.cpp), rounds 1-4: a conservative test that answers
  "certainly valid" or "unsure" (then Boost decides, as before): bucketed
  segment sweeps instead of sorting, one-pass ring checks, monotone
  chunks, hole placement by crossing parity, orientation shortcuts. An
  "AfterClip" variant for rect_clip results uses Boost's own side test
  (rounding bound, no distance tolerance) and decides near-spikes the way
  Boost does. Verified with a build that also ran Boost on every
  "certainly valid": 1.5 billion planet calls, 0 mismatches.
- The precheck now also runs before Boost in writeMultiPolygon and in the
  repair's acceptance test; a linestring with two distinct finite points is
  known valid without is_valid.
- ring_point_index.h: point-in-ring through a y-band segment index for
  big rings, used inside Boost's validity and relate algorithms
  (Lake Huron r1205151: 16.6 s -> 1.7 s).
- make_valid (correct.hpp): self-intersections found with an index (rtree
  fallback), adjacent pairs handled without Boost, rings clearly apart
  never intersected, results moved instead of copied; correct.hpp now
  includes geom.h, and the unit test links geom.o. Works with Boost before
  and after 1.87, which renamed segment_intersection_info's
  robust_ra/robust_rb to ra/rb.
- Repair: an orientation-only fault is fixed by reversing in place, also
  for polygons with holes (exact for integer tile coordinates).
- Relations with >= 100k points that still need is_valid are checked in
  the background until the tiles start; a relation that needs no
  correction is checked in the cache and not copied.

Planet (96 threads): about -16% wall over the rounds (e.g. ring index
-9 s, precheck round 1 -12 s, deferred validity -11 s).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
@dktue
dktue force-pushed the perf/planet-3min-03-validity-precheck branch from e0536de to 3222454 Compare November 16, 2026 12:27
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant