- extended/2-extension-mapf/lorr/: sortation_large, warehouse_large and warehouse_long_corridor_large, from LoRR's Benchmark-Archive at 1adae00 (src/bench/fetch_lorr.py). Each holds a plain grid, map/<map>.map, and LoRR's own file, original_format.map, with its pickup (S) and delivery (E) points. Each has 75 generated scenarios: 40,000 agents on sortation_large, 20,000 on the other two. Their poi files draw on the maps' own points. scen_selection.txt and scen_manifest.json list them. - extended/3-practical-mapf/lorr/: their 2.5D sites (tier-3 source lorr, converted from LoRR's file), 75 scenarios each at 10,000 agents, with exports and pictures. - core/: the three maps join the warehouse domain, as grids (core/grid/warehouse/) and as sites (core/sites/lorr/warehouse/), so core has 35 grid maps and 132 sites. - Tier 2's manifest now records each map's POI count, and the LoRR maps' POI source. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Th5rxjKCh5uRe5JGqnZwdF |
||
|---|---|---|
| core | ||
| extended | ||
| .gitignore | ||
| README.md | ||
Benchmark instances
Two folders:
| folder | holds | use it for |
|---|---|---|
core/ |
32 MAPF Tracker maps and 3 League of Robot Runners maps with tier 2's scenarios, and 132 2.5D sites | the benchmark to report on |
extended/ |
all three tiers, whole | scale studies, training data, other subsets |
core/ is small enough to run in full, and it covers both halves of the
benchmark:
core/grid/holds the maps MAPF Tracker reports results on: tier 1's 33, the MovingAI MAPF benchmark. They come with tier 2's generated scenarios (ext-random,ext-even,ext-poi; 25 files each, up to 40,000 agents, with a solvability bound), not the published ones. That is 32 maps:maze-128-128-1is a tree, where no multi-agent instance exists, so tier 2 generated none for it. Beside them are the League of Robot Runners' three large warehouse maps, with tier 2's scenarios for them and LoRR's own file.core/sites/holds 132 tier-3 sites: the same 36 maps as 2.5D sites, and 96 indoor sites, four from each of twelve layout groups. Each site has its 75 scenario files, the seven exported formats and a picture of every representation.
core/ is laid out to be read.
-
MovingAI maps keep their names and are grouped into the seven domains MAPF Tracker and the MAPF benchmark paper use:
domain maps cityBerlin_1_256,Boston_0_256,Paris_1_256emptyempty-8-8,empty-16-16,empty-32-32,empty-48-48gameDragon Age: Origins brc202d,den312d,den520d,lak303d,orz900d,ost003d; Dragon Age 2ht_chantry,ht_mansion_n,lt_gallowstemplar_n,w_woundedcoastmazemaze-32-32-2,maze-32-32-4,maze-128-128-2,maze-128-128-10(and, as a site only,maze-128-128-1)randomrandom-32-32-10,random-32-32-20,random-64-64-10,random-64-64-20roomroom-32-32-4,room-64-64-8,room-64-64-16warehousewarehouse-10-20-10-2-1,warehouse-10-20-10-2-2,warehouse-20-40-10-2-1,warehouse-20-40-10-2-2; and the League of Robot Runners'sortation_large,warehouse_large,warehouse_long_corridor_large(their sites incore/sites/lorr/warehouse/) -
Indoor sites are grouped by layout group and named
<source>-<group>-<rank>, for examplehouseexpo-M-open-compact-1. Rank 1 is the pick whose cluster holds most of its group (the groups are under Tier 3). -
Manifests:
core/sites/'s manifests are keyed by these names. Each entry gives the site'ssitekey in tier 3 and itsgroupordomain.core/grid/scen_manifest.jsongives each map'sdomain.
extended/ holds the three tiers as they are generated:
| tier | maps | scenarios | what it contributes |
|---|---|---|---|
extended/1-existing-mapf/ |
33 | 1,650 | the published MovingAI benchmark (MAPF Tracker's), frozen |
extended/2-extension-mapf/ |
845 | 809 upstream + generated | the other 809 MovingAI maps' scenarios, 3 League of Robot Runners maps, and every generated ext-* file |
extended/3-practical-mapf/ |
47,840 sites | 75 per site, in its zip | 2.5D raster sites |
core/ is a copy, never edited. src/bench/tiers.py --sync in the main
repository makes it from extended/, and --verify checks it byte for byte.
- Plain copies: the grid files and the MovingAI sites' zips. Git stores a file and its copy as one object, so these cost nothing in the repository.
- Renamed copies: an indoor site's zip is the tier-3 zip with its name in
place of the source id. That covers the folder, the site file, the
scenario, export and picture files, and the three export files that
mention the id (
export.json, the ROS.yaml, the DIMACS comments). Nothing else changes: the site's metadata and every scenario header still name its source id and hash. These 96 zips cost ~0.13 GB.
A checkout of core/ takes 2.4 GB. src/terrain/tier3.py states what is
core and how it is named.
Within extended/, maps are duplicated across tiers; scenarios are not.
Every tier carries every map it needs, so a solver pointed at one folder
finds its maps there. But each tier holds only the scenarios it
contributes. Tier 3's maps are its 2.5D sites, not grids.
Duplicating the maps costs about 250 MB per tier and buys a tree that works on its own. Duplicating the scenarios across tiers would buy nothing: a user who wants tier 1's scenarios has tier 1. So tier 2 does not re-ship tier 1's 1,650 files, and tier 3 does not re-ship tier 2's.
Tier 3 does not carry the grid .map files either. Its 842 MovingAI sites are
converted from tier 2's copies, and until 2026-10-24 it kept byte-identical
copies of all 842 beside its sites, which bought nothing.
Layout
benchmarks/
core/
grid/scen_manifest.json tier 2's manifest, for these 35 maps
grid/<domain>/<map>/map/<map>.map 32 MAPF Tracker maps and 3 LoRR maps, e.g. grid/room/room-64-64-8/
grid/warehouse/<lorr map>/original_format.map LoRR's own file, with pickup and delivery points
grid/<domain>/<map>/ext-random/<map>-ext-random-<i>.scen 25 each, copied from tier 2
grid/<domain>/<map>/ext-even/ ext-poi/
sites/site_manifest.json scen_manifest.json export_manifest.json keyed by name
sites/houseexpo/<group>/houseexpo-<group>-<rank>.zip 48, e.g. houseexpo/M-open-compact/houseexpo-M-open-compact-1.zip
sites/procthor/<group>/procthor-<group>-<rank>.zip 48
sites/movingai/<domain>/<map>.zip 33
sites/lorr/warehouse/<map>.zip 3
extended/
1-existing-mapf/<map>/map/<map>.map
1-existing-mapf/<map>/even/<map>-even-<i>.scen
1-existing-mapf/<map>/random/<map>-random-<i>.scen
2-extension-mapf/scen_selection.txt the 60 maps that get generated scenarios
2-extension-mapf/scen_manifest.json what was generated for them
2-extension-mapf/<collection>/<map>/map/
2-extension-mapf/<collection>/<map>/even/ 809 non-canonical maps only
2-extension-mapf/<collection>/<map>/ext-random/ generated
2-extension-mapf/<collection>/<map>/ext-even/ generated
2-extension-mapf/<collection>/<map>/ext-poi/ generated
2-extension-mapf/lorr/<map>/original_format.map LoRR's own file (src/bench/fetch_lorr.py)
3-practical-mapf/site_manifest.json every site and its content hash
3-practical-mapf/scen_manifest.json every site's scenario files
3-practical-mapf/export_manifest.json the sites with exports: the 132 core sites
3-practical-mapf/core_sites.json the 96 core indoor sites, and why each
3-practical-mapf/site_features.json every indoor site's layout features and group
3-practical-mapf/excluded_sites.json scenes dropped, and why
3-practical-mapf/houseexpo/<id>.zip 2.5D raster sites, one zip each
3-practical-mapf/procthor/<split>-<i>.zip
3-practical-mapf/movingai/<collection>/<map>.zip
3-practical-mapf/lorr/<map>.zip
Tier 1 is flat, and core/ groups tier 1's maps by domain; tier 2 and
tier 3's MovingAI sites are namespaced by collection. This is not inconsistency for its own sake. Tier
1's 33 map names are unique, and a flat tree is what the MAPF tooling and
everyone's habits expect. MovingAI map names, though, collide across
collections: AR0011SR is 224×216 in the Baldur's Gate originals and 512×512
in the scaled set. Flattening tiers 2 and 3 would silently drop one of every
such pair.
Either way --bench takes a directory holding <map>/map/<map>.map, so
--bench benchmarks/extended/1-existing-mapf and
--bench benchmarks/extended/2-extension-mapf/dao both work.
Keeping the copies honest
Tier 2 is the tree that is edited, and core/ is rebuilt from
extended/.
python3 src/bench/tiers.py --sync # promote tier 1's scens out of tier 2; rebuild core/
python3 src/bench/tiers.py --verify # check the invariants
fetch_movingai.py downloads everything into tier 2, including the canonical
maps' upstream scenarios, which belong to tier 1. --sync moves those out,
but only after confirming tier 1 already holds a byte-identical copy; if they
disagree it stops rather than delete. It then rebuilds core/: it copies
what is missing or different, and deletes what no longer belongs.
--verify checks:
- the duplicated maps really are identical across tiers, comparing with line endings normalised, since the same map ships with CRLF in one archive and LF in another;
- tier 1 holds nothing generated, and tier 2 has not picked tier 1's scenarios back up;
- every tier-2 map has its tier-3 site;
core/is exactly the copy--syncwould make.
Tier 1 — existing MAPF
The published benchmark, frozen: 33 maps × (25 even + 25 random). Other people's results are already reported against these, so they are exactly as MovingAI ships them and nothing is added.
Tier 2 — MAPF extension
| collection | maps | source |
|---|---|---|
dao |
156 | Dragon Age: Origins |
bgmaps |
120 | Baldur's Gate II, original size |
street |
90 | city / street maps |
bg512 |
75 | Baldur's Gate II, scaled to 512×512 |
sc1 |
75 | StarCraft |
random |
70 | artificial |
da2 |
67 | Dragon Age 2 |
maze |
60 | artificial |
room |
40 | artificial |
wc3maps512 |
36 | Warcraft III, scaled to 512×512 |
mapf |
33 | the tier 1 benchmark |
weighted |
20 | weighted terrain |
lorr |
3 | the League of Robot Runners' large warehouse maps, not MovingAI's |
809 of the MovingAI maps were never part of the MAPF benchmark, and they ship
with one scenario file each against tier 1's fifty. That is why the map
count rises 33 → 842 while scenarios only go 1,650 → 2,459. The three lorr
maps ship with none of their own; their scenarios are all generated.
Those single files are even scenarios by construction — 10 problems per
bucket, bucket == floor(optimal_length / 4), verified — so they are filed
under even/ and renamed to the numbering convention.
The League of Robot Runners maps
The lorr collection holds the League of Robot Runners' three large
warehouse maps, grid maps that are not part of MovingAI. All are 500 × 140.
sortation_large: the sortation map of the 2023 and 2024 main rounds.warehouse_large: their fulfillment-centre map.warehouse_long_corridor_large: the 2026 main round's fulfillment map.
src/bench/fetch_lorr.py in the main repository downloads them from the
competition's Benchmark-Archive repository at a pinned commit, and checks
each file against its git blob hash.
LoRR's letters differ from MovingAI's: @ and T are obstacles; ., E
(a delivery point) and S (a pickup point) are traversable. A MovingAI
reader would take S for swamp and not know E, so each map is stored
twice:
map/<map>.mapis a standard grid with every traversable cell.;original_format.mapis LoRR's file, byte for byte.
The pickup and delivery points are the maps' points of interest: ext-poi
draws on them instead of blobs. They cover 59–74% of the free space, against
the 15% that blobs cover elsewhere. All three maps are covered by the
solvability bound: N_TECC is their whole free space. sortation_large
reaches 40,000 agents, and the two fulfillment maps 20,000.
The archive states no licence, so like the game-derived MovingAI collections their redistribution terms are unaudited.
Generated scenarios
src/gen/scen_gen.py adds three scenario types, 25 files each, to the maps
listed in extended/2-extension-mapf/scen_selection.txt. They go in their own folders so
nothing upstream is touched and tier 1 stays byte-identical to MovingAI:
2-extension-mapf/<collection>/<map>/even/ upstream, untouched
2-extension-mapf/<collection>/<map>/random/ upstream, untouched
2-extension-mapf/<collection>/<map>/ext-random/<map>-ext-random-<i>.scen
2-extension-mapf/<collection>/<map>/ext-even/ <map>-ext-even-<i>.scen
2-extension-mapf/<collection>/<map>/ext-poi/ <map>-ext-poi-<i>.scen
| type | how endpoints are chosen |
|---|---|
ext-random |
uniform without replacement over the free space |
ext-even |
an equal floor of agents in every bucket floor(len/4) |
ext-poi |
15% of the free space is marked as points of interest, and endpoints are drawn with POI weighted 25× — without replacement. On the lorr maps the POI are the maps' own pickup and delivery points instead |
To run it, see Generating below.
Which maps, and how many agents
Sixty-three maps carry generated scenarios. Every other map in tier 2 keeps its
.map and its upstream .scen; users generate for those with the same code
and the same seed, so the result is byte-identical to what would have shipped.
Agent count comes from --agent-bands (default 10000,20000,40000): each map
gets the largest band it can hold, and a map too small for the smallest
band is generated to full occupancy. That puts 33 maps at 40k, six at 20k,
four at 10k, and twenty at their own ceiling.
A map's ceiling is min(largest connected component, N_TECC − 1), where
N_TECC counts free cells in a non-trivial 2-edge-connected component. By
Theorem 15 of Yu & Rus (WAFR 2012), an instance with fewer agents than that is
solvable whatever the start/goal assignment — and since every prefix of a
feasible instance is feasible, every prefix of every generated file is
provably solvable. It costs almost nothing: N_TECC runs 95–100% of the free
space on most of these maps.
Where it does not, the bound is reported rather than applied (--bound-min-ratio,
default 0.9), because Theorem 15 is sufficient and not necessary. On a
corridor-width-1 maze every free cell is a bridge, so N_TECC is 0 and the
bound would say "no agents" rather than "this map is hard". Those maps —
maze512-1-0 and maze-128-128-1 — are excluded from the selection outright:
they are trees, and not MAPF-able at these agent counts.
Why POI sampling is without replacement
A scenario file is a pool that users truncate to the first k rows, so the property has to hold at every k. Drawing without replacement gives exactly that: early agents come from a pool where POI dominate, and as the prefix grows the POI pool is drawn down, so the tail is whatever is left. Run the first 50 agents and you get heavy congestion around the interest points; run the file to full occupancy and it is a uniform random instance again. With two weight classes the sequential two-pool draw the script uses is exactly equivalent to Efraimidis–Spirakis weighted reservoir sampling, at O(agents) instead of O(free cells · log).
Measured on generated files: 80% of the first 50 agents' endpoints are POI
against a 15% base rate, falling to 15% — the base rate exactly — over a file
that runs to full occupancy. --verify reports this, so it is checked rather
than claimed.
POI are grown as connected blobs around spread-out seeds, not scattered cells:
an interest point is a place (a room, a depot, a junction), and scattering 15%
of cells uniformly would be indistinguishable from random.
How even scales
MovingAI's even puts 10 agents in each bucket, which self-sizes to about
10 × diameter / 4 — a few thousand agents even on a 1024×1024 map, far short
of a 40k band. --even-target band (the default) sets the floor to
ceil(target / buckets) instead, keeping the definition while scaling the
count. --even-target movingai keeps the upstream 10.
No map supplies that floor everywhere. Extreme buckets are rare by nature — a 256×256 map holds only so many pairs of cells 380 steps apart, and asking for 400 of them with distinct starts and distinct goals runs out. So the fill is two-stage: a flat floor in every bucket, then a top-up distributing the remainder over buckets that still have supply. Every bucket ends with at least the floor, the file reaches the target agent count, and the distribution is as flat as the map permits.
Generated even files are shuffled, not grouped by bucket — matching upstream,
and necessary for the prefix-pool semantics, since ordering by distance would
make every truncation a short-haul-only instance.
Excluded
The weighted collection (20 maps) is skipped. Its cells are terrain-cost
letters A–P rather than free/blocked, so octile length is not its metric:
Map1-even-1.scen and Map10-even-1.scen have identical endpoints and
different stored lengths.
Terrain
Passable is ., G and S; @, O, T and W are blocked. Not a guess —
across every shipped scenario, endpoints land only on those three, and swamp
really is used (8,511 of 21,980 endpoints in wc3maps512).
Generating
Sixty-three maps × three types is 189 jobs of 25 files each, and
scripts/generate_scenarios.py runs them as 4,725 one-file tasks, one
subprocess each, --workers at a time. The first sixty maps' 4,500 took 54 h
on 63 cores; the three LoRR maps' 225 took 36 min on 50.
python3 scripts/generate_scenarios.py --plan # job list and memory, instant
python3 scripts/generate_scenarios.py --dry-run # size it by generating one file per job
python3 scripts/generate_scenarios.py # 50 workers, 25 files each
python3 scripts/generate_scenarios.py --workers 63
python3 scripts/generate_scenarios.py --extend 25 # add files 26-50 later
python3 scripts/generate_scenarios.py --verify # check what was written
python3 src/bench/tiers.py --verify # tiers still consistent
Growing the set later. --count N is a target ("make sure N files exist");
--extend N is a delta ("add N more on top of what is there"). Files are
independent — each carries its own seed blake2b(seed, map, type, index) — so
generating 25 now and 25 more when disk allows produces byte-identical output
to a single 50-file run. Verified by diffing the two trees.
Each task is a plain gen.scen_gen call restricted to one map, one type and a
range of file numbers, so anything the runner produces can be reproduced by
hand:
python3 src/gen/scen_gen.py --maps street/Paris_1_1024 --types poi --count 25
python3 src/gen/scen_gen.py --maps street/Paris_1_1024 --types poi --start-index 7 --count 7
Why one file per task. A job writes its 25 files one after another, so a
run of whole jobs can finish no sooner than its slowest job — and a 512×512
maze job is 70–120 core-hours on its own, several times the length of the
whole run spread over 64 cores. Splitting by file changes when a file is
written, never what is in it (the seed is per file); verified by diffing a
one-file-task tree against the single-call output. Per-task setup — loading
the map, the N_TECC bound, the even scaffolding — is under ten seconds even
on Paris_1_1024, against hours for the file. --files-per-task N groups files
if you would rather have fewer processes.
Subprocesses rather than a pool inside one interpreter: a task that dies takes
down only itself, the survivors keep going, and the failure is isolated in
that task's own log under scen_gen_logs/. A long server run should not lose
hours because one task crashed.
Resumable. A task whose output files all exist is skipped without starting a
process, and each file is written under a temporary name and renamed into
place, so an interrupt never leaves a half-written .scen.
Deterministic. Each file's seed is blake2b(--seed, map, type, index), so
output does not depend on the worker count, on scheduling order, or on how many
times the run was interrupted. A run on 64 workers produces the same bytes as
one on 4.
Memory. Peak RSS per job is about 25 B × grid cells + 500 B × free cells
(700 B for even, which also holds a per-cell eccentricity bound) plus the
interpreter — measured against Paris_1_1024 at 570 MB, TheFrozenSea 534 MB,
maze512-32-0 178 MB, Denver_2_256 52 MB. Agent count barely matters: 476 pairs
to 40,008 moved the peak by 5 MB. The heaviest single task is under 600 MB.
With one-file tasks the heaviest files can all run at once — the 63 heaviest
are all Paris_1_1024, TheFrozenSea and Expedition — so the worst case is
35.5 GB at 63 workers (29.1 GB at 50). The runner prints this estimate for
your chosen --workers before it starts.
Cost. About 1,092 core-hours for the full run on an Apple-silicon laptop,
88% of it computing the exact optimal path length behind each of the 110
million rows. That figure does not transfer between machines. On a 64-core
AMD EPYC-Milan server the same A* runs about 2.2× slower on an idle machine
(8room_000 56 ms/pair against 24, maze512-32-0 243, Paris_1_1024 128), and
with 63 workers busy the mazes slow by another 2× (491 ms) while open maps
lose only 10% — maze search is memory-bound. An even file also costs
2.6× a random one, measured on Expedition. Together that is about
5,600–5,900 core-hours, or ~90 hours on 63 workers, half of it the five
512×512 mazes. Measure on the target machine before planning around a number.
Parallel efficiency is not linear either — 4.0× on 4 workers but 9.5× on 14
on the laptop.
--verify re-runs the exact octile search on a sample of rows in every file
and checks distinct starts, distinct goals, start ≠ goal, bucket == floor(len/4), no empty bucket below the last full one, and POI concentration.
The search kernel in src/gen/octile.py is differentially tested against the
obvious implementation in src/gen/core.py, and reproduces the optimal lengths
stored in the shipped MovingAI files exactly — 60/60 rows on each of mapf,
dao, street, sc1 and wc3maps512.
A note on map names
Map names are not unique across collections: 88 of 754 names appear in more
than one, and 75 of those are genuinely different maps — every one a bg512
(512×512 rescale) against a bgmaps (original size) pair. AR0011SR is
512×512 in one and 224×216 in the other. The remaining 13 are byte-identical
duplicates, the MAPF benchmark reusing maps from dao, da2 and street.
So scen_selection.txt addresses maps as collection/map, and a bare name
matching more than one map is a hard error rather than an arbitrary pick.
Tier 3 — practical MAPF
47,840 2.5D raster sites in extended/3-practical-mapf/, in the
ground-truth format described in the top-level README.md. 132 of them are
also in core/sites/.
| source | sites | core | raster | from |
|---|---|---|---|---|
movingai |
842 | 33 | 0.25 m (1 m grid cells, 4:1) | tier 2's MovingAI maps |
lorr |
3 | 3 | 0.25 m (1 m grid cells, 4:1) | tier 2's League of Robot Runners maps |
houseexpo |
35,107 | 48 | 0.05 m | HouseExpo floor plans (MIT) |
procthor |
11,888 | 48 | 0.05 m | ProcTHOR-10k houses (Apache-2.0) |
Core sites. The 33 MovingAI ones are tier 1's maps, the ones MAPF Tracker
reports results on, grouped in core/ by its seven domains, and the 3 lorr
ones are the League of Robot Runners' warehouses. So core/ has all 36 maps
both as grids, with tier 2's scenarios, and as metric sites, and the
abstraction error can be measured on maps everyone knows.
A lorr site is converted from LoRR's own file, so its pickup and delivery
points become the semantic classes terrain:Pickup and terrain:Delivery.
Its poi scenarios draw on them, as tier 2's do for the same maps.
Most HouseExpo and ProcTHOR sites look alike, so core takes 48 from each source, four from each of twelve layout groups. Each group combines size with two axes that vary independently of it. Every feature is measured on the free space of the scenarios' 0.5 m robot.
| axis | HouseExpo (empty plans, never a loop) | ProcTHOR (furnished) |
|---|---|---|
| size (free area) | S < 50 m², M < 150, L ≥ 150 | S < 20 m², M < 70, L ≥ 70 |
| second | open: at most one single-lane chokepoint; doors: more |
noloop; loops: robots can drive round an obstacle of ≥ 1 m² |
| third | compact or elongated (geodesic diameter / √area at 2.0) |
sparse or cluttered (furniture on 20% of the floor) |
Within a group, the four are its k-medoids, so they are typical of the
group and spread across it. Each records how many of the group's sites its
cluster holds. Each is named <source>-<group>-<rank>, rank 1 holding the
most, and sits in core/sites/<source>/<group>/ under that name.
core_sites.jsonlists them, with their names and every parameter that chose them.site_features.jsongives every indoor site's features and group, so other subsets can be drawn from it.- The main repository's
scripts/select_core_sites.pyregenerates both byte for byte;src/terrain/site_features.pydefines the features.
One folder per site, in one zip per site:
extended/3-practical-mapf/houseexpo/<id>/ (procthor/<split>-<i>/, movingai/<collection>/<map>/)
<id>.site the 2.5D raster: three layers + metadata, one file
original_format.<ext> the scene it was converted from, byte for byte
random/ even/ poi/ 25 scenario files each, <id>-<type>-<n>.sscen
exports/ the seven derived formats (core sites)
viz/ one picture per representation,
and <id>-overview.png of them all (core sites)
original_format.<ext> is the source's own file, in the source's own format
(the name says so: it is not the benchmark's raster): the HouseExpo plan
(.json), the ProcTHOR house, i.e. its line of the split (.json), or the
MovingAI grid (.map, the same file as tier 2's). It converts back to the
site's content_sha256 with src/terrain/to_raster.py.
Every core site ships exports/, the seven abstraction formats, and viz/.
viz/ holds a picture of the raster and of each export, plus the
overview, a 2 × 4 figure of all eight. Other sites ship neither; the
main repository's scripts/export_sites.py --all makes them, the same byte
for byte.
<id>.site is a 64-byte header, the metadata as JSON, then the layers as raw
little-endian arrays. The main repository's c/mapf_site.h reads it, and the
scenario files, in C and C++ (c/README.md has the byte layout), and
src/terrain/site_file.py reads it in Python.
Sites ship zipped. Each site's zip holds its whole folder:
| tier 3, unpacked | tier 3, zipped | of which core sites, zipped | |
|---|---|---|---|
| site files | 76.5 GB | 0.24 GB | 0.001 GB |
| original files | 0.79 GB | 0.11 GB | 0.0003 GB |
| scenario files (3,588,000) | 53.1 GB | 18.8 GB | 0.27 GB |
| exports (132 core sites) | 0.67 GB | 0.076 GB | 0.076 GB |
| pictures (132 core sites) | 0.18 GB | 0.17 GB | 0.17 GB |
| total | 131 GB | 20.2 GB | 0.52 GB (2.2 GB unpacked) |
Most of the exports' size is one file: lorr/sortation_large's visibility
graph, 4.9 M edges and 196 MB of text, because its floor is 15,620 one-cell
pillars that see one another across the aisles.
The layers take 10 bytes per raster cell but are mostly constant planes, so they deflate ~300 to one; the scenarios are numbers in text, ~3 to one, and PNGs barely at all. Git holds only the zips; the unpacked sites are gitignored. After cloning, from the main repository:
python3 scripts/pack_sites.py --unpack --core # core/sites/ only: seconds, 2.2 GB
python3 scripts/pack_sites.py --unpack # all of tier 3: ~5 min, ~130 GB
python3 scripts/pack_sites.py --verify # every zip reproduces its manifest hash
Each zip unpacks into a directory of the same name beside it, exactly the
layout scripts/convert_sites.py writes. The zips are reproducible: fixed
entry order, timestamps and permissions. So repacking an unchanged site
leaves git with nothing to commit.
site_manifest.json lists every site with its content_sha256, so a site
converted locally can be checked with to_raster.py --expect-sha256.
scen_manifest.json lists each site's scenario files, and
export_manifest.json each exported site. core/sites/ has the same three
for its 132.
Dropped scenes. 131 scenes (112 ProcTHOR, 19 HouseExpo) were converted and
then dropped because fewer than ten 0.5 m robots fit: single-robot search in a
confined space rather than MAPF. excluded_sites.json lists each with its
capacity and the parameters that decided it, and convert_sites.py skips
them unless --include-excluded. The verdict depends on the robot; see
scripts/sweep_sites.py.
Refetching
python3 src/bench/fetch_movingai.py --list
python3 src/bench/fetch_movingai.py --all # downloads into tier 2
python3 src/bench/tiers.py --sync
Nothing is overwritten without --force, and a name collision whose content
differs is reported rather than silently resolved.