- Rating
- 2
- Confidence
- 2
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
This paper presetns Loom, a GPU compiler for scalar functions over finite index maps. The user supplies a fixed-shape JAX function and a description of where each array element lives; Loom fuses the computation into GPU kernels specialized around one contiguous axis of independent lanes for vectorization. It accepts declared algebraic constants such as √3/2 and rewrites polynomial arithmetic so that it can apply exact cancellations. Loom lowers programs, including those built by JAX automatic differentiation, through StableHLO, generates many PTX implementations and selects one based on timing. Evaluation on NVIDIA B200 and A100 GPUs shows that Loom-generated hot kernels are up to approximately 2× faster than SoTA baseline.
Critical strengths
- THis paper identifies why existing tools struggle: a sequence of indexed reads, scalar arithmetic, and reductions emitted as separate kernels can cost more in kernel launch overhead and intermediate data movement than arithmetic computations. The opening example is concrete and illustrative.
- On the benchmark cases where Loom’s assumptions hold, the results are compelling: 1.16–3.11× faster than cuEquivariance in 8/8 cases (except one EP variant), 2.1–182.9× faster than OpenEquivariance, and 3.2–16× faster than FlashTP. The ablation (Table 2) credibly attributes these gains to specific mechanisms.
Critical weaknesses
- This paper may be out of the scope of the ICLR conference; reviewers can not find out the direct contributions to the AI applications and AI systems.
- The discussion of why Loom’s search chose fiber walks here and whether this is a systematic limitation of the search heuristic is insufficient.
- in Table 6, Loom’s first call takes 37–535 seconds, versus 2~7 seconds for the domain baselines. This is an order-of-magnitude difference.
Questions for authors
- How does Loom’s compilation time scale with program complexity such teh number of StableHLO ops, number of polynomial terms...
- The benchmark graphs use arithmetic sequence index maps (the paper acknowledges this is Loom’s best case). How does Loom perform on truly irregular graphs (random wiring, power-law degree distributions) where fiber sizes vary widely?
- To better understand the performance gain, it would help to show some critical PTX (Parallel Thread Execution) and SASS (Streaming Assembler).
- The real-arithmetic contract means Loom’s output may differ from IEEE-754 JAX by more than rounding. Could you discuss on the guarantees users have about the maximum deviation, and whether this is acceptable for physics-critical applications ?
5 comments
THe responses address most of my concerns, particularly regarding irregular graphs, the search strategy, and the practical relevance to MACE-MP-0. The additional results have strengthened my confidence in the paper. , I still encourage the authors to clarify the limitations of the numerical accuracy checks, eps. for physics-critical applications.
I was impressed by the SASS profiling results for typical computations e.g. FMUL2 and FFMA2.
the authors clarified the paper's fit with ICLR (e.p., by adding references), which was my main concern.
Thank you for your review.
Scope (weakness 1). Loom accelerates the equivariant graph neural networks used as interatomic potentials, under three topics of ICLR's call for papers: "infrastructure, software libraries, hardware, etc.", "learning on graphs and other geometries & topologies" and "applications to physical sciences". GPU kernels for ML operators appear at ML venues: FlashAttention (NeurIPS 2022), FlashAttention-2 (ICLR 2024). Equivariant networks are an ICLR line since Spherical CNNs (ICLR 2018), with MACE (NeurIPS 2022), Equiformer (ICLR 2023) and now foundation models such as MACE-MP-0 and UMA (NeurIPS 2025), run for millions of molecular-dynamics (MD) steps. Their cost lies in two operators, the tensor product along edges and the symmetric contraction, and in their derivatives: forces are a gradient, and training needs a second derivative. Tensor products take up to 75% of training time (FlashTP, ICML 2025), and speeding them up is an ML-venue topic: eSCN (ICML 2023), the Gaunt tensor product (ICLR 2024), FlashTP. Loom compiles these operators and all their derivatives from the model's JAX code. In the public pre-trained MACE-MP-0, it makes the force step 11–23% faster, graph construction included, and MD 26–28% faster than with cuEquivariance (cuEq).
First call (weakness 3). The first call compiles and tunes once per program and size, and its result is cached. On the B200 it now takes 10–37 s for the edge product and 37–400 s for the symmetric contraction, against 37–535 s in the submission, mostly because the float64 reference that checks each new program now runs on the GPU. A later process, reusing the tuned kernels and check verdicts, takes 5–13 s and 24–218 s. In exchange, Loom's kernels are 1.1–2.0× faster than cuEq's on the eight benchmark programs with edges sorted by receiver, the order neighbour lists usually come in and cuEq's best case, and 1.5–2.5× in the submission's order. In MD with MACE-MP-0 on 10k atoms (35 against 28 steps/s), the first call is repaid after 16,600–17,300 steps (8.3–8.6 ps), while production runs last nanoseconds.
Compile time and program size (question 1). Raising the edge product's L from 1 to 5, compile time grows sublinearly with the number of polynomial terms, about as cuEq's does: as terms^0.60–0.91 for Loom and terms^0.67–0.90 for cuEq; at L = 5, Loom takes 62–429 s and cuEq 35–546 s.
Why fiber walks, and the search (weakness 2). Loom chooses by measurement: it picks a fiber walk only when it ran faster than the alternatives it generated. A walk is at a disadvantage when a derivative also sums along the second index map: the Full and Second VJPs sum along senders as well as receivers, and a walk along receivers needs atomic additions for the sender sums. There the search had one systematic limitation: of the algebraically equivalent forms of such a derivative that compile, it timed plans for the first only. Timing all of them turns the radius graph's Full VJP from 0.87× to 1.08× of cuEq's speed, and water's from 0.91× to 1.10×. What remains is a gap in the space of plans, not in the search: at L = 4 and 5, the Feature VJP keeps a whole receiver's terms in registers (221–255 per thread, against cuEq's 56–64) and runs at 0.81× and 0.73×.
Irregular graphs (question 2). On random, radius, power-law (hubs of up to 5,074 edges) and water graphs of 10k atoms and 50k edges, Loom wins 14 of 16 cases and ties the other 2, both on the power-law graph (0.98× and 1.00×). Its speedup over the best baseline is 1.10–1.81× on random, 1.08–1.41× on radius, 0.98–1.46× on power-law and 1.10–1.44× on water.
PTX and SASS (question 3). On the edge product's Forward, Loom issues half of cuEq's instructions (48 M against 95 M for the same 3.3 GFLOP; main kernel 190 against 221 µs). Its SASS pairs channels in two-wide FMAs, with Clebsch–Gordan coefficients as immediates:
On the Full VJP it reads 916 MB from memory against cuEq's 2,845 MB, close to the 902 MB that must be read.
Accuracy (question 4). Loom's rewrites are identities over the reals, so its output differs from the program as written only by float32 rounding, which grows with the number of terms summed. Beyond that a priori bound, Loom checks: at its first call, each compiled program is compared with a float64 evaluation of the program as written, and refused if its error exceeds the larger of 32 float32 roundings and four times that of the program as written in float32 (error: largest deviation over largest float64 value, in units of 2^-24). On the benchmark, Loom's worst error is 4.4–6.4 such roundings, below cuEq's 7.7–39. In MACE-MP-0, float32 forces differ from float64 by 0.006–0.037 meV/Å RMS, the same with cuEq or Loom.