Repository navigation
perf(lua): replay way_function and node_function from a memo; native MercatorArea and MinZoomByArea - #993
perf(lua): replay way_function and node_function from a memo; native MercatorArea and MinZoomByArea#993dktue wants to merge 10 commits into
Conversation
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>
f2f670e to
160e4f9
Compare
…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>
160e4f9 to
b56bf1c
Compare
…s-b36pcl dktue's 3-minute planet series (systemed#993–systemed#1000) on relslow-patched; Lua 5.4 and jemalloc in the image
|
I love (what I understand to be) the direction of this work: let someone author flexible profiles in user-friendly Lua while also avoiding the runtime cost where possible. I'm wrapping my head around the work here, so apologies if some of these questions are dumb! Some of these are more just to understand the space vs a suggestion for a change in the current PR.
I think this would avoid the user having to author an I think if tilemaker/src/osm_lua_processing.cpp Line 434 in 2789651
Especially if (1) is possible, this seems like a mechanical transformation that would benefit anyone who uses tilemaker. Could tilemaker just decree that it will preprocess your profile to add this line at the top of every file? Any runtime errors that quote lua file line numbers would need to have their line numbers decreased by 1 to still point to the right line in the user's profile, but I think that'd be manageable.
If I understand correctly, Could it be added? I think https://github.com/hikeratlas/basemap/blob/main/slices/buildings.lua would trivially be ready to use memo if For completeness, I think maybe it'd make sense to include:
My ways profile isn't currently a candidate for the memo system. One of the issues is its use of Wikidata IDs (high cardinality) and the That module is a SQLite database that maps a Wikidata ID to a popularity score. We then branch based on whether the popularity score is above or below a threshold of 1000. Conceptually, this feels very similar to the problem solved by I wonder if there's some way to unlock this? For example, if tilemaker offered a local get_route_and_highway = MakeMemoizable(function()
local on_route = false
local highway = ''
while true do
local rel = NextRelation()
if not rel then break end
local route = FindInRelation('route')
local network = FindInRelation('network')
local wikidata = FindInRelation('wikidata')
local rank = qrank.get(wikidata)
if route == 'road' and rank > 1000 then
highway = 'motorway'
end
if route == 'hiking' or route == 'foot' then on_route = true end
end
return on_route, highway
end)
function way_function():
local on_route, highway = get_route_and_highway()
...
endtilemaker would still have to invoke the Lua interpreter, but now its scope is just for Maybe this wouldn't provide enough savings? I don't know if the benefit of memoizing is avoiding the Lua interpreter entirely, or if you still get a savings if you just reduce the amount of Lua code being interpeted, and the number of Lua -> tilemaker transitions for the tilemaker functions. Aside:
This is sort of a thought experiment. Could the config knobs for They're quite powerful, but using them correctly seems a bit fraught. (I pause here to note that I'm a hypocrite: I added tilemaker controls the environment and sees all the lua profiles. In theory, I think a tilemaker could do static analysis of any given profile to decide whether its usage is safe for memoization or not. Such analysis would allow more things to be automatically supported, e.g. in: Attribute("osm_id", Id())it could understand that In some cases, the analysis would be uncertain, and tilemaker would have to err on the side of caution and decline to memoize, e.g. if a user's profile imports a native library whose code isn't visible to tilemaker. That could be communicated to the user, who might then be able to apply a workaround to hint to tilemaker that the thing is truly safe to memoize. On the one hand, the static analysis approach feels quite ambitious. On the other hand, if it could deliver speedups with no effort from the user, while also avoiding the risk of the user introducing errors through misconfiguration, I wouldn't mind throwing Claude tokens at building and testing it. |
|
Thanks, these are good questions, not dumb ones. Short answers, in your order: 1. Registering the functions before the profile is loaded. Yes. Today 2. Adding the locals automatically. Possible, but I'd rather not rewrite the user's source: besides the line numbers, a profile may already define a local or global with one of those names. With (1), it is one line a profile can opt into, and the bundled profile would show it. 3. 4. Opting other state in. As I read it, your 5. No knobs. Agreed that the knobs are easy to get wrong. Part of the checking is already there at run time: calls the memo can't replay (geometry queries, |
…+ 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>
b56bf1c to
463c11b
Compare
Gain: planet (96 threads) about -21% wall for this PR alone, compounded over its rounds: native MercatorArea 9:07 -> 8:53, memo v3 8:51 -> 8:05 (user CPU -16%), memo node cap 8:05 -> 7:57, memo values 7:51 -> 7:42, then -4.5 s, -6.6 s, -3.8 s, -4.5 s in later rounds. way_function replayed for ~1.17 of 1.22 billion ways, node_function for ~211 million nodes. Memory: memo trees of at most 2^18 nodes per thread.
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 commit 00 of this series (perf/planet-3min-00-store-finalize-pmtiles-close: #989 and #990 adapted to that base, no PR of its own), so the diff of this PR on GitHub also shows the commits below it; review the last commit. The whole series is onperf/planet-3min.What
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 = truein 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.Output
This is the only commit of the series that changes the output, through the bundled profile's area: the old profile computed
MercatorArea()in Lua asArea() / 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 fall on the other side of it, so some landuse, water, building and bridge polygons appear one zoom earlier or later. The memo itself replays exactly what Lua would do (it records only deterministic reads; anything it cannot record runs through Lua), so with a profile that doesn't use the new functions the output is unchanged. Every later commit keeps the output of this one.Verification
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.🤖 Generated with Claude Code