Mixed depth with one or two layers per cell size is an estimated 18–20% faster per training step than halo

In mixed depth, big cells hear from the fine region only after it is pooled to their size

A 2 m × 4 m slice across a seam: 1 m cells on the left, 0.25 m cells on the right. Arrows are reads across the seam within a layer. Halo reads both ways at every layer. Mixed depth reads only fine-from-coarse at fine resolution; the two sides first exchange both ways at 1 m, after the fine cells are pooled twice.

For a waiting 1 m cell to be readable at the 0.25 m level it must already be in feature space, so the shared input encoder runs on every cell first, as a pointwise (1×1) layer that mixes nothing across sizes.

Where a training step's time goes, by design

Estimated ms per H=2 training window (forward, backward, AdamW) on the median deck. Halo is the measured profile; mixed-depth rows rescale each category by its own work count. The line marks halo's total.

Mixed depth wins by running fewer layers per level, not fewer rows

Native-stack convolution work, in units of "halo's corners × one 32-channel layer" (a 64-channel layer counts 4×), split by cell size. Halo runs 4 layers on every corner. Mixed depth runs each level's layers only on the cells at that level (native plus pooled finer cells); its 2 m level is one dense grid of the whole domain. It saves time only when each level runs fewer layers. Native 1 m cells are ~42% of corners, so widening at 1 m is expensive; widening at 2 m is cheaper.

Every cell still gets at least halo's depth

Encoder convolutions a cell passes through before the 4 m pool, by its native size. A fine cell also runs every coarser level's layers, which is why M3 can cut each level to one encoder and one decoder layer.

The estimate holds across decks

M3 step time relative to halo (bf16) for each of the 80 decks, against the share of corners at 0.25 m.

Pre-build checks from the same decks

Every FDS mesh is 16³ cells; pooling lines up (cell counts divisible, origins on the level lattice) in decks. Pooled blocks re-tile into full 16³ tiles for most cells, which keeps the halo ring near halo's 0.40 slots per row.

Design and method

• Shared weights across cell sizes. One set of native conv weights for 0.25, 0.5, 1 and 2 m, told the cell size by log2(dx) at the input (constant over a level, so a free per-level bias). A pointwise input encoder runs on every cell first, so waiting cells can be read through the halo, and a per-level scale and shift (FiLM) after each LayerNorm. The dense 4 / 16 / 64 m levels keep their own weights.
• A 1×1 at each level junction. At each level, newly entering native cells (encoder output only) sit beside pooled finer cells (already through convs). A 1×1 on the pooled cells maps them into the level's feature space before they join, and is where the width changes (e.g. 32 → 64 at 2 m). The pooled side is usually the smaller, each junction has its own small weights, and it costs about 1/27 of a 3³ conv.
• 2 m is the uniform target. The largest native cell is 2 m (in all 80 decks; a median 11% of corners). Mixed depth brings every cell to 2 m: 0.25, 0.5 and 1 m are block levels with halo gathers; at 2 m the whole domain (median 140 × 140 × 134 m; meshes fill 98% of its bounding box) is one dense grid of 0.14× halo's corners, run as plain conv3d like the 4 m level, with no halo gather and a strided-average pool to 4 m. Channels can then step 32 → 64 → 128 → 256 from 2 m up.
• Where the saving comes from. Halo's per-layer gather averages fine corners into coarse ones at every size change ( of its gather nonzeros); mixed depth never needs that. The 4 m pool reads the dense 2 m grid by strided average instead of a sparse product over every corner. The rest is fewer layers per row.
• Method. Rows, halo slots and halo nonzeros counted from the &MESH lines of 80 production decks. Each category of the measured H100 profile (median validation deck, 2.13 M corners) is scaled by its own count: convolutions by rows × input × output channels, LayerNorm / GELU / elementwise / copy by rows × channels (80% assumed native), cuSPARSE by nonzeros × channels. Wall time outside those categories is held fixed. Every conv is priced at the native 32-channel block convs' speed; the measured dense 4 m convs at 128 channels did roughly 3–4× more work per ms, so wide dense 2 m levels are likely overcharged.
• Not modelled. Per-level kernel launch overhead; the 0.5 m level's small size (0.12 of the rows) may not fill the GPU; memory. The next step is a one-hour H100 benchmark of halo against M3 in bf16.