Pith. sign in

REVIEW 2 major objections 59 references

SOLAR: AI-Powered Speed-of-Light Performance Analysis

T0 review · 2 major / 0 minor · reviewed 2026-06-26 · grok-4.3

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A framework automatically derives validated speed-of-light performance bounds from deep learning source code.

desk verdict SOLAR automates SOL bound derivation via LLM-to-IR translation but the validation only checks outputs, not the loop semantics needed for the bounds. read the letter →

arxiv 2606.26383 v1 pith:2CNMHRLP submitted 2026-06-24 cs.LG cs.AIcs.ARcs.MAcs.PF

Qijing Huang , Sana Damani , Zhifan Ye , Athinagoras Skiadopoulos , Siva Kumar Sastry Hari , Jason Clemons , Sahil Modi , Jingquan Wang
show 4 more authors
Aditya Kane Edward C Lin Humphrey Shi Christos Kozyrakis
This is my paper · ORCID
classification cs.LGcs.AIcs.ARcs.MAcs.PF
keywords speed-of-lightanalysisperformanceboundsautomaticderivationdeeplearningoptimizationcodetranslationmulti-fidelityanalyticalmodelingboundvalidation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper presents a method to automatically compute the theoretical minimum execution time of a workload on target hardware by processing its source code. An LLM component first converts the code into an executable intermediate representation that is checked for correctness through output matching, after which deterministic steps produce bounds at increasing levels of modeling detail. This addresses the prior need for manual, error-prone derivation that was disconnected from fast iteration in model development. If the approach holds, developers could obtain reliable headroom information and optimization clues directly during coding without separate analysis steps.

What carries the argument

The LLM frontend that translates source programs into an executable Affine Loop IR validated by output comparison, which carries the argument by enabling the subsequent deterministic lifting and bound computation.

What would settle it

A source program for which the generated bounds are violated by any actual execution or for which the translated representation produces output that differs from the original program.

Watch

Extended reading notes

Core claim

SOLAR derives validated SOL bounds from source code by translating it via an LLM frontend into an executable Affine Loop IR validated by output comparison, lifting the IR into an einsum graph, and applying an analytical backend to compute unfused, fused, and cache-aware bounds, yielding zero observed violations and enabling multi-fidelity tightening that surfaces optimization insights.

Load-bearing premise

The LLM frontend reliably translates arbitrary source programs into an executable intermediate representation whose semantics are preserved for subsequent bound calculation and validation by output comparison.

Editorial extensions

If this is right

  • Headroom analysis at multiple fidelity levels becomes available directly from code without manual derivation.
  • Optimization opportunities can be identified by observing how bounds tighten across fidelity levels.
  • Cross-platform exploration of performance limits is supported through the same automated flow.
  • Inverse-roofline hardware provisioning decisions can be informed by the computed bounds.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Embedding the translation and bound steps into integrated development environments could provide immediate performance feedback while editing code.
  • The multi-fidelity tightening process might be reused for other quantitative limits such as memory usage or energy consumption.
  • If the translation component generalizes, similar automatic bound derivation could apply to workloads outside current deep learning code patterns.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

2 major / 0 minor

Summary. The manuscript introduces SOLAR, a framework for automatically deriving Speed-of-Light (SOL) performance bounds from PyTorch and JAX source code. It uses a generative LLM frontend to translate programs into an executable Affine Loop IR (validated via output comparison), followed by deterministic lifting to an einsum graph and an analytical backend that computes unfused, fused, and cache-aware SOL bounds. The work claims comprehensive operator/language coverage, zero observed SOL violations across evaluations on KernelBench, JAX/Flax models, and robotics workloads, and demonstrates four use cases: multi-fidelity headroom analysis, optimization opportunity identification, cross-platform exploration, and inverse-roofline hardware provisioning.

Significance. If the central claim holds, SOLAR would meaningfully advance the field by automating a process that is currently manual and disconnected from rapid model iteration, enabling routine integration of theoretical performance limits into ML development. The hybrid generative-deterministic architecture and explicit multi-fidelity tightening of bounds are practical strengths that could surface actionable optimization insights and support hardware-software co-design. The deterministic analytical backend and emphasis on validation are positive elements that, if substantiated, would strengthen reproducibility in performance analysis.

major comments (2)
  1. [Abstract] Abstract (validation description): The central claim of 'validated bounds with zero observed SOL violations' rests on output comparison for the LLM frontend, but this only establishes functional equivalence on sampled inputs and does not verify preservation of loop nests, data dependencies, or memory access patterns; any such mismatch would invalidate the subsequent analytical SOL bounds (unfused/fused/cache-aware) without necessarily triggering output mismatches.
  2. [Abstract] Abstract (LLM frontend): The weakest assumption—that the generative LLM produces an Affine Loop IR whose semantics exactly match the source for einsum-graph lifting and bound computation—is load-bearing, yet the manuscript provides no concrete error analysis, coverage metrics, or counterexample search beyond output comparison, leaving the reliability of the computed bounds unassessable from the given description.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the careful review and for identifying the critical distinction between functional equivalence and structural preservation in the LLM frontend validation. The points raised are substantive and directly affect the strength of our claims regarding validated SOL bounds. We respond to each major comment below and will revise the manuscript accordingly.

read point-by-point responses

  1. Referee: [Abstract] Abstract (validation description): The central claim of 'validated bounds with zero observed SOL violations' rests on output comparison for the LLM frontend, but this only establishes functional equivalence on sampled inputs and does not verify preservation of loop nests, data dependencies, or memory access patterns; any such mismatch would invalidate the subsequent analytical SOL bounds (unfused/fused/cache-aware) without necessarily triggering output mismatches.

    Authors: We agree that output comparison on sampled inputs only confirms functional equivalence and does not guarantee preservation of loop nests, data dependencies, or memory access patterns. Any structural mismatch could invalidate the analytical SOL bounds without producing output discrepancies. This is a genuine limitation of the current validation approach described in the abstract. In the revised manuscript we will (1) qualify the validation claim in the abstract, (2) add a dedicated validation subsection that includes structural IR checks (loop-nest comparison and dependency-graph matching) on representative workloads, and (3) report the results of these additional checks. We will also discuss the residual risk to bound accuracy. revision: yes

  2. Referee: [Abstract] Abstract (LLM frontend): The weakest assumption—that the generative LLM produces an Affine Loop IR whose semantics exactly match the source for einsum-graph lifting and bound computation—is load-bearing, yet the manuscript provides no concrete error analysis, coverage metrics, or counterexample search beyond output comparison, leaving the reliability of the computed bounds unassessable from the given description.

    Authors: The manuscript does rely on the assumption that LLM-generated Affine Loop IR preserves the semantics needed for correct einsum-graph lifting and bound computation. The current description provides only output comparison and does not include error analysis, coverage metrics, or systematic counterexample search, making reliability difficult to assess. We accept this critique. The revision will add quantitative translation success rates, categorized error analysis from manual inspection of failures, and results from targeted counterexample searches. These additions will allow readers to evaluate the reliability of the computed bounds. revision: yes

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: analytical bounds derived from code via deterministic pipeline

full rationale

The paper describes a pipeline in which an LLM translates source to Affine Loop IR (validated only by output comparison on samples), a deterministic lift produces an einsum graph, and an analytical backend computes unfused/fused/cache-aware SOL bounds directly from that graph. No equations, parameters, or results are shown to be fitted to the target bounds or defined in terms of the bounds themselves. No self-citation chain is invoked as load-bearing justification for uniqueness or ansatz choices. The central claim therefore reduces to standard program analysis followed by closed-form roofline-style arithmetic rather than any self-referential construction.

Assumptions & free parameters 0 free parameters · 0 assumptions · 0 invented entities

Abstract-only review yields no explicit free parameters, axioms, or invented entities; the LLM translation step implicitly assumes semantic preservation without stated formal guarantees.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SOLAR: AI-Powered Speed-of-Light Performance Analysis." pith.science (2026). https://pith.science/paper/2CNMHRLP

@misc{pith2026260626383,
  author       = {Pith},
  title        = {Pith review of: SOLAR: AI-Powered Speed-of-Light Performance Analysis},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2CNMHRLP}},
  note         = {Machine review of arXiv:2606.26383}
}
read the original abstract

How fast could a deep-learning model run on target hardware, and how far is today's implementation from that limit? These questions are central to software, hardware, and algorithm optimizations. Speed-of-Light (SOL) analysis answers them by computing a workload's theoretical minimum execution time on a given architecture. Yet deriving SOL bounds remains manual, error-prone, and disconnected from rapid model development. To close this gap, we introduce SOLAR, a framework that automatically derives validated SOL bounds from PyTorch and JAX source code. SOLAR leverages both generative and deterministic components in its flow: an LLM frontend translates any source programs into an executable Affine Loop IR, validated by output comparison; a deterministic flow lifts the IR into an einsum graph; and an analytical backend computes unfused, fused, and cache-aware SOL bounds. SOLAR provides comprehensive operator and language coverage, produces validated bounds with zero observed SOL violations, and offers multi-fidelity analysis that tightens bounds and surfaces optimization insights. We evaluate SOLAR across KernelBench, JAX/Flax models, and robotics workloads. These experiments demonstrate four use cases: headroom analysis at multiple fidelity levels, identifying optimization opportunities, cross-platform exploration, and inverse-roofline hardware provisioning.

Figures

Figures reproduced from arXiv: 2606.26383 by the authors.

Figure 1
Figure 1. What SOLAR provides. SOLAR derives validated SOL bounds from source code, enabling three capabilities existing tools lack. (a) SOL headroom analysis: points below the diagonal reveal optimization opportunity; SOLAR exposes up to orders-of-magnitude headroom on KernelBench. (b) Tighter bounds: cache-aware analysis (OROJENESIS) accounts for on-chip buffer constraints, tightening SOL by up to 10× over naïve roofline. (… view at source ↗
Figure 2
Figure 2. End-to-end SOLAR example (LinearBiasMatmul). (a) PyTorch source. (b) Agent￾translated Affine Loop IR with named-dimension tensors and affine loops. (c) Einsum Graph (fusible edge dashed) with extracted einsum equations. (d) SOL analysis: fusion eliminates the intermediate, shifting the bottleneck from memory to compute. whose iterations carry no data dependence may be annotated Dim("B", parallel=True) by the LLM to … view at source ↗
Figure 3
Figure 3. SOL headroom analysis. (a) KernelBench: measured runtime over fused SOL across L1–L4 levels. (b) JAX/Flax: headroom (baseline / fused SOL) spans from 1.1× (BatchNorm) to 85.9× (MNISTCNN), demonstrating language-agnostic frontend coverage. 0 5 10 15 20 25 SOL Speedup (runtime / SOL) L1 L2 3.7x 5.1x 4.3x 21.6x 1.9x 10.5x Cache-aware fused SOL Unfused SOL Fused SOL (a) Multi-fidelity SOL speedup for L1/L2. Cache￾aware … view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: Optimization hints. (a) Multi-fidelity SOL on L1/L2: on L1, cache-aware is tightest (intra￾operator tiling costs dominate); on L2, unfused is tightest (intermediate tensor traffic dominates). (b) All 5 association orders of a 4-tensor MLA chain; 22× TFLOP range, with o…
Figure 5
Figure 5. Figure 5: Qwen3-4B block parameter sensitivity on Jetson Thor. Fused and unfused SOL across four architectural axes. C/M = compute/memory-bound. Batch size drives linear scaling; sequence length triggers a memory→compute regime shift at ∼4K tokens. A6000 Jetson Thor H100 PCIe B2…
Figure 6
Figure 6. Figure 6: Cross-hardware Qwen3-4B block SOL. SO￾LAR enables designers to com￾pare deployment targets and identify the suited platform. pi0 GR00T N1.6 System 1 DreamZero WAM Model 0 10 20 30 40 50 60 70 80 SOL Runtime (ms) 2.0 ms 2.0 ms 2.0 ms 21.9 12.8 80.2 12.8 10.4 40.1 Unfuse…
Figure 8
Figure 8. Figure 8: KernelBench L1: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: KernelBench L2: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_9.png]
Figure 10
Figure 10. Figure 10: KernelBench L3: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p012_10.png]
Figure 11
Figure 11. Figure 11: KernelBench L4: per-problem SOL speedup (geomean [PITH_FULL_IMAGE:figures/full_fig_p013_11.png]
Figure 12
Figure 12. Figure 12: SOL-EXECBENCH SOL analysis. (a) Each point is a workload; gap to the diagonal represents optimization headroom. (b) Quant kernels show the largest headroom (35.8×), followed by FlashInfer-Bench (18.8×), L1 (11.0×), and L2 (10.2×). C Robotics Model SOL Analysis [PITH_…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

59 extracted references · 8 canonical work pages

  1. [1]

    Chen, Tianqi and Moreau, Thierry and Jiang, Ziheng and Zheng, Lianmin and Yan, Eddie and Cowan, Meghan and Shen, Haichen and Wang, Leyuan and Hu, Yuwei and Ceze, Luis and Guestrin, Carlos and Krishnamurthy, Arvind , booktitle = OSDI, year =

  2. [2]

    Evaluating Large Language Models Trained on Code

    Evaluating Large Language Models Trained on Code , author =. arXiv preprint arXiv:2107.03374 , year =

    work page Pith review arXiv

  3. [3]

    Andrews, Martin and Witteveen, Sam , journal =

  4. [4]

    and Ermon, Stefano and Rudra, Atri and R

    Dao, Tri and Fu, Daniel Y. and Ermon, Stefano and Rudra, Atri and R

  5. [5]

    arXiv preprint arXiv:2412.19437 , year =

    work page Pith review arXiv

  6. [6]

    The Meaning of Relativity , pages =

    The General Theory of Relativity , author =. The Meaning of Relativity , pages =

  7. [7]

    Quantum , volume =

    Hyper-Optimized Tensor Network Contraction , author =. Quantum , volume =

  8. [8]

    2026 , url =

    Lin, Edward and Modi, Sahil and Hari, Siva Kumar Sastry and Huang, Qijing and Ye, Zhifan and Qin, Nestor and Zhou, Fengzhe and Zhang, Yuan and Wang, Jingquan and Damani, Sana and others , journal =. 2026 , url =

    2026

Show all 59 references
  1. [9]

    IEEE Computer Architecture Letters , volume =

    Cache-Aware Roofline Model: Upgrading the Loft , author =. IEEE Computer Architecture Letters , volume =

  2. [10]

    2025 , url =

    Standardized Measurement Methodology for Kernel Benchmarking , author =. 2025 , url =

    2025

  3. [11]

    Proceedings of the ACM on Programming Languages , volume =

    The Tensor Algebra Compiler , author =. Proceedings of the ACM on Programming Languages , volume =

  4. [12]

    Li, Raymond and Ben Allal, Loubna and Zi, Yangtian and Muennighoff, Niklas and Kocetkov, Denis and Mou, Chenghao and Marone, Marc and Akiki, Christopher and Li, Jia and Chim, Jenny and others , journal =

  5. [13]

    Transformers are

    Dao, Tri and Gu, Albert , booktitle = ICML, year =. Transformers are

  6. [14]

    Dissecting

    Mei, Xinxin and Chu, Xiaowen , journal =. Dissecting

  7. [15]

    Nemotron-H: A Family of Hybrid

  8. [16]

    and Pellauer, Michael and Emer, Joel S

    Odemuyiwa, Toluwanimi O. and Pellauer, Michael and Emer, Joel S. , journal =. The

  9. [17]

    Proceedings of the 51st Annual International Symposium on Computer Architecture (ISCA) , year =

    Mind the Gap: Attainable Data Movement and Operational Intensity Bounds for Tensor Algorithms , author =. Proceedings of the 51st Annual International Symposium on Computer Architecture (ISCA) , year =

  10. [18]

    Andrulis, Tanner and Gilbert, Michael , title =

  11. [19]

    and Hu, William and R

    Ouyang, Anne and Guo, Simon and Arora, Simran and Zhang, Alex L. and Hu, William and R. arXiv preprint arXiv:2502.10517 , year =

    arXiv

  12. [20]

    and Mukkara, Anurag and Venkatesan, Rangharajan and Khailany, Brucek and Keckler, Stephen W

    Parashar, Angshuman and Raina, Priyanka and Shao, Yakun Sophia and Chen, Yu-Hsin and Ying, Victor A. and Mukkara, Anurag and Venkatesan, Rangharajan and Khailany, Brucek and Keckler, Stephen W. and Emer, Joel , booktitle = ISPASS, year =. Timeloop: A Systematic Approach to

  13. [21]

    Paleo: A Performance Model for Deep Neural Networks , author =

  14. [22]

    Reed, James and DeVito, Zachary and He, Horace and Ussery, Ansley and Ansel, Jason , booktitle = MLSys, year =

  15. [23]

    Peng, Bo and Alcaide, Eric and Anthony, Quentin and Albalak, Alon and Arcadinho, Samuel and Biderman, Stella and Cao, Huanqi and Cheng, Xin and Chung, Michael and others , booktitle =

  16. [24]

    and Gray, Johnnie , journal =

    Smith, Daniel G.A. and Gray, Johnnie , journal =. opt\_einsum -- A

  17. [25]

    Design of a High-Performance

    Springer, Paul and Bientinesi, Paolo , journal =. Design of a High-Performance

  18. [26]

    MAPL , year =

    Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations , author =. MAPL , year =

  19. [27]

    torchview: Visualize

  20. [28]

    Attention Is All You Need , author =

  21. [29]

    Benchmarking

    Wang, Yu Emma and Wei, Gu-Yeon and Brooks, David , journal =. Benchmarking

  22. [30]

    Communications of the ACM , volume =

    Roofline: An Insightful Visual Performance Model for Multicore Architectures , author =. Communications of the ACM , volume =

  23. [31]

    Xu, Bing and Chen, Terry and Zhou, Fengzhe and Chen, Tianqi and Jia, Yangqing and Grover, Vinod and Wu, Haicheng and Liu, Wei and Wittenbrink, Craig and Hwu, Wen-mei and Bringmann, Roger and Liu, Ming-Yu and Ceze, Luis and Lightstone, Michael and Shi, Humphrey , journal =

  24. [32]

    Hierarchical Roofline Analysis for

    Yang, Charlene and Kurth, Thorsten and Williams, Samuel , journal =. Hierarchical Roofline Analysis for

  25. [33]

    USENIX ATC , year =

    Habitat: A Runtime-Based Computational Performance Predictor for Deep Neural Network Training , author =. USENIX ATC , year =

  26. [34]

    Zhang, Li Lyna and Han, Shihao and Wei, Jianyu and Zheng, Ningxin and Cao, Ting and Yang, Yuqing and Liu, Yunxin , booktitle =. nn-

  27. [35]

    Zhu, Jiace and Chen, Wentao and Fan, Qi and Ren, Zhixing and Wu, Junying and Chai, Xing Zhe and Rungrueangwutthinon, Chotiwit and Ma, Yehan and Zou, An , journal =

  28. [36]

    Ding, Yuran and Chen, Xinwei and Zhang, Xiaofan and Zhou, Zongwei , journal =

  29. [37]

    Zaeed, Mohammad and Islam, Tanzima Z. and Ind. Opal: A Modular Framework for Optimizing Performance using Analytics and. arXiv preprint arXiv:2510.00932 , year =

  30. [38]

    arXiv preprint arXiv:2505.03988 , year =

    Can Large Language Models Predict Parallel Code Performance? , author =. arXiv preprint arXiv:2505.03988 , year =

  31. [39]

    Yuan, Zhihang and others , journal =

  32. [40]

    ptflops: Flops Counter for

    Sovrasov, Vladislav , howpublished =. ptflops: Flops Counter for

  33. [41]

    Dao, Tri , journal =

  34. [42]

    Ramanujam and P

    Uday Bondhugula and Albert Hartono and J. Ramanujam and P. Sadayappan , title =. 2008 , doi =

    2008

  35. [43]

    Tools and Algorithms for the Construction and Analysis of Systems (TACAS) , series =

    Amir Pnueli and Michael Siegel and Eli Singerman , title =. Tools and Algorithms for the Construction and Analysis of Systems (TACAS) , series =. 1998 , publisher =

    1998

  36. [44]

    Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP) , pages =

    Koen Claessen and John Hughes , title =. Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP) , pages =. 2000 , doi =

    2000

  37. [45]

    Competition-Level Code Generation with

    Yujia Li and David Choi and Junyoung Chung and Nate Kushman and Julian Schrittwieser and R\'. Competition-Level Code Generation with. Science , volume =. 2022 , doi =

    2022

  38. [46]

    Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines , booktitle = PLDI, pages =

    Jonathan Ragan-Kelley and Connelly Barnes and Andrew Adams and Sylvain Paris and Fr\'. Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines , booktitle = PLDI, pages =. 2013 , doi =

    2013

  39. [47]

    Noah Shinn and Federico Cassano and Ashwin Gopinath and Karthik Narasimhan and Shunyu Yao , title =

  40. [48]

    Necula , title =

    George C. Necula , title =. 2000 , doi =

    2000

  41. [49]

    Polyhedral Parallel Code Generation for

    Sven Verdoolaege and Juan Carlos Juega and Albert Cohen and Jos. Polyhedral Parallel Code Generation for. 2013 , doi =

    2013

  42. [50]

    Gonzalez and Ion Stoica , title =

    Lianmin Zheng and Chengfan Jia and Minmin Sun and Zhao Wu and Cody Hao Yu and Ameer Haj-Ali and Yida Wang and Jun Yang and Danyang Zhuo and Koushik Sen and Joseph E. Gonzalez and Ion Stoica , title =

  43. [51]

    Unsupervised Translation of Programming Languages , booktitle = NIPS, year =

    Baptiste Rozi. Unsupervised Translation of Programming Languages , booktitle = NIPS, year =

  44. [52]

    Teaching Large Language Models to Self-Debug , journal =

    Xinyun Chen and Maxwell Lin and Nathanael Sch. Teaching Large Language Models to Self-Debug , journal =

  45. [53]

    Lin, Edward and Modi, Sahil and Hari, Siva Kumar Sastry and Huang, Qijing and Ye, Zhifan and Qin, Nestor and Zhou, Fengzhe and Zhang, Yuan and Wang, Jingquan and Damani, Sana and others , journal =

  46. [54]

    arXiv preprint arXiv:2406.01698 , year =

    Abhimanyu Bambhaniya and Ritik Raj and Geonhwa Jeong and Souvik Kundu and Sudarshan Srinivasan and Suvinay Subramanian and Midhilesh Elavazhagan and Madhu Kumar and Tushar Krishna , title =. arXiv preprint arXiv:2406.01698 , year =

  47. [55]

    Jimenez and John Yang and Alexander Wettig and Shunyu Yao and Kexin Pei and Ofir Press and Karthik Narasimhan , journal =

    Carlos E. Jimenez and John Yang and Alexander Wettig and Shunyu Yao and Kexin Pei and Ofir Press and Karthik Narasimhan , journal =

  48. [56]

    arXiv preprint arXiv:2108.07732 , year =

    Program Synthesis with Large Language Models , author =. arXiv preprint arXiv:2108.07732 , year =

    arXiv

  49. [57]

    Naman Jain and King Han and Alex Gu and Wen-Ding Li and Fanjia Yan and Tianjun Zhang and Sida Wang and Armando Solar-Lezama and Koushik Sen and Ion Stoica , booktitle =

  50. [58]

    2020 , url =

    Tyler Yep , title =. 2020 , url =

    2020

  51. [59]

    arXiv preprint arXiv:2603.29010v1 , year =

    Hari, Siva Kumar Sastry and Balaji, Vignesh and Damani, Sana and Huang, Qijing and Kozyrakis, Christos , title =. arXiv preprint arXiv:2603.29010v1 , year =

Pith tools

Reviewed June 26, 2026 · model on record in the stance chip above.