Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

QiMeng-Xpiler: Transcompiling Tensor Programs for Deep Learning Systems with a Neural-Symbolic Approach

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read QiMeng-Xpiler claims that pairing LLM-generated code sketches with small-scale SMT-based repair can translate tensor programs across four deep learning systems at an average of 95% computation accuracy and up to 2.0x the performance of…

desk verdict A genuinely useful neural-symbolic transcompiler pipeline with real hardware results, but the 95% correctness headline is a pass rate on a small, shape-restricted test suite, not a verified whole-program guarantee. read the letter →

arxiv 2505.02146 v1 pith:Y63PIB4T submitted 2025-05-04 cs.CL cs.LGcs.PL

Shouyang Dong , Yuanbo Wen , Jun Bi , Di Huang , Jiaming Guo , Jianxing Xu , Ruibai Xu , Xinkai Song
show 5 more authors
Yifan Hao Xuehai Zhou Tianshi Chen Qi Guo Yunji Chen
This is my paper · ORCID
classification cs.CLcs.LGcs.PL
keywords tensorprogramtranscompilationneural-symbolicsynthesisLLM-assistedcompilationSMT-basedrepairdeeplearningsystemsheterogeneousacceleratorsauto-tuningsource-to-sourcetranslation
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

QiMeng-Xpiler sets out to make 'write once, run anywhere' practical for tensor programs by automatically translating an operator written for one deep learning system into the programming interface of another. The paper claims that splitting the translation into a chain of LLM-assisted transformation passes, then repairing the inevitable small mistakes with a bounded SMT-based symbolic solver, yields functionally correct code on average 95% of the time across CUDA, HIP, BANG C, and Intel VNNI. It further reports translated programs running at up to 2.0x the speed of vendor-provided manually optimized libraries, and productivity gains up to 96x for hard operators. If these results hold, a single legacy kernel could be ported to multiple accelerators without per-platform hand tuning, lowering the cost of heterogeneous data-center deployments.

What carries the argument

The machinery is the transformation-pass pipeline plus hierarchical auto-tuning. Eleven hand-defined pass types in three families (sequentialization/parallelization, memory conversion, and (de)tensorization) reshape the program one step at a time; each pass annotates source semantics, retrieves target-language references, prompts the LLM to transform, validates with unit tests, localizes failures by print-based binary search, and asks an SMT solver to fill missing expressions in a small sketch. Auto-tuning then searches pass parameters by brute force and pass sequences by Monte Carlo tree search. The pass decomposition is what keeps the SMT queries small enough to solve.

What would settle it

Take the Deformable Attention kernel in the CUDA-to-BANG C direction, isolate one conditional branch whose predicate controls a zero-fill loop, and ask whether the translated program still passes the provided unit tests when that predicate is wrong but every loop bound is correct. If such a case passes the tests yet diverges from the source on an untested shape, the local-repair guarantee is refuted. More directly, rerun the paper's 168-case suite with a test harness that checks each program against random tensors at the extremes of its declared shapes; a single divergence in a case the paper counts as correct would falsify the averaged accuracy claim.

Watch

Extended reading notes

Core claim

On its own terms, the central discovery is that neural and symbolic synthesis are complementary at the scale of a transformation pass rather than at the scale of the whole program. The LLM supplies high-level program sketches—loop structure, memory placement, tensor intrinsics—while the SMT solver repairs localized low-level details like loop bounds, buffer indices, and intrinsic parameters after unit tests expose a bug. The paper argues that this division of labour makes search-based synthesis tractable, and presents experiments across four platforms and 168 test cases with compilation accuracy at or near 100% and computation accuracy between 86.9% and 100% per direction, averaging 95%. The authors state this is the first automatic transcompiler for tensor programs across different deep learning system programming models.

Load-bearing premise

The correctness of the whole translated program is assumed to follow from unit-test-guided, SMT-based repair of small localized snippets; Section 7.6 shows this premise gives way when complex control flow hides the bug outside those snippets.

Editorial extensions

If this is right

  • Legacy CUDA kernels can be ported to BANG C or HIP, and C-with-VNNI code to CUDA, without a hand rewrite.
  • Each translation pass is individually unit-tested, so errors are caught and repaired before they propagate to later passes.
  • For some operators the translated code runs faster than vendor-provided manually tuned libraries, by up to 2.0x.
  • Because the pipeline needs only a programming manual and a few examples, a comparatively rare interface like BANG C becomes a viable target despite sparse LLM training data.
  • The remaining failure mode is complex control flow, as in Deformable Attention, where neither the LLM nor the SMT solver can produce a correct translation.

Reading between the lines

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

  • The authors leave implicit that the same pass decomposition could transfer to other domain-specific languages with scarce training data: the leverage comes from bounding the repair search, not from CUDA-specific rules.
  • A consequence of the reported numbers is that translated code reaches 0.78x of vendor libraries on average, so the practical pitch is correctness plus acceptable speed, with wins concentrated where auto-tuning finds a better tiling or pass order.
  • The Deformable Attention failure suggests a concrete research target: extending SMT repair to control-flow predicates, or using the LLM to propose candidate branch conditions that the solver then verifies.
  • If the unit-test suite is the only correctness oracle, then shapes outside the tested set could expose errors the pass pipeline missed; generating exhaustive boundary tests from the source loop structure would be a natural next step.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes QiMeng-Xpiler, a transcompiler that translates tensor programs across four deep-learning platforms (Intel VNNI, NVIDIA CUDA, AMD HIP, and Cambricon BANG C) by combining LLM-based code transformation with SMT-based repair of localized code snippets, plus hierarchical auto-tuning for performance. The evaluation reports 100% compilation accuracy on most direction cells, 86.9% to 100% computation accuracy, average computation accuracy of about 95%, up to 2.0x speedup over vendor libraries, and large productivity gains for two representative directions.

Significance. If the central claims hold, this is a practically useful step toward 'write once, run anywhere' for tensor programs on heterogeneous accelerators. The paper's strengths are its realistic multi-platform setup, the inclusion of executed hardware runs, the ablation of the SMT component, honest documentation of a failure case in Section 7.6, and the comparison against LLM and rule-based baselines. The main gap is that the phrase 'correctness guarantee' is not supported by the evidence, because the SMT repair covers only localized low-level details and the accuracy metric is an unspecified unit-test pass rate.

major comments (4)
  1. [Sections 4.3, 4.4, and 8] The claim that SMT-based repair 'ensures the functional equivalence of each transformation pass' overstates what is demonstrated. Section 4.3 states that constraints are enumerated 'for each assigned concrete index variable, loop boundary, buffer size, or tensor semantic,' and Section 4.4 restricts repair to 'loop boundaries, indexing, and instruction parameters,' which is not whole-program equivalence. Section 7.6 confirms the limitation by reporting a Deformable Attention case where complex control flow defeats both the LLM and the SMT solver. I recommend replacing the word 'guarantee' with a bounded correctness claim, such as correctness with respect to the evaluated test suite for the covered pass types, and stating that scope explicitly in the abstract and conclusion.
  2. [Section 6, 'Computation accuracy'] The accuracy metric is defined as passing 'a set of unit tests,' but the paper never specifies what those unit tests are, how they are generated, what input coverage they provide, or how they are constructed for intermediate passes. Because the same tests appear to serve as both the repair oracle (Section 4.3) and the evaluation metric (Section 6), the reported 86.9% to 100% figures are pass rates on an unspecified test suite rather than demonstrated semantic correctness. The authors should release the test harness and report coverage statistics, and they should distinguish pass-rate results from a formal equivalence guarantee.
  3. [Section 6 and Table 6] The denominator for each accuracy percentage is ambiguous. The text says '168 test cases in total for evaluation' (21 operators x 8 shapes), but Table 6 reports percentages per transcompilation direction. It is unclear whether each cell is computed over all 168 cases, over only the cases applicable to that direction, or over some other subset. Please state the per-cell denominators explicitly and report raw counts (for example, 22/23) next to each percentage.
  4. [Section 7.2 and Figure 7] The performance results are averaged only over 'functional correct cases,' and the paper does not report how many correct cases each operator contributed. Since computation accuracy ranges from 86.9% to 100%, the 'up to 2.0x' performance claim is conditional on a non-random subset of cases. Please report per-operator correct-case counts and give the performance for all attempted cases, or clearly state that the performance numbers apply only to successfully translated programs.
minor comments (5)
  1. [Section 5.2, Eq. (3)] The piecewise definition of the reward T_i^t is incomplete: the condition 'if p_t^i' has no predicate. It should state, for example, 'if p_t^i is executable and its execution succeeds.'
  2. [Figure 1] The axes in Figure 1 are not labeled, and the legend is difficult to read; please add axis labels and a clearer legend, and define what 'Scalability (LoCs)' and 'Human Efforts' measure.
  3. [Table 5] The column header 'Hip' is inconsistent with the 'HIP' spelling used elsewhere, and 'LoCs' is not defined at first use; please spell out 'lines of code' and use consistent capitalization.
  4. [Section 2.1.1] The sentence ending 'These specialized intrinsics for' is incomplete and should be finished (for example, '...for deep learning computations often come with intricate constraints.').
  5. [Algorithm 3] The variable S is used both for the input source program and for the extracted error snippet, which makes the algorithm hard to follow; please rename one of them.

Circularity Check

1 steps flagged · score 6.0 of 10

The 95% computation accuracy is measured by the same unit tests that drive the SMT repair loop, so the headline correctness figure is partly guaranteed by construction rather than independently verified.

  1. fitted input called prediction [Section 4.3 (Bug Localization) and Section 6 (Evaluation Metrics)]
    "For bug localization, the transformed code is validated by the provided unit tests and if it fails, Algorithm 2 will be employed to locate the buggy code snippets with unit tests precisely. ... (2) Computation accuracy is introduced in this paper as a crucial metric that assesses the functional correctness of the translated code, deeming a generated code correct if it passes a set of unit tests."

    The paper's headline claim that QiMeng-Xpiler 'correctly translates different tensor programs at the accuracy of 95% on average' is evaluated by 'computation accuracy', which is defined as passing a set of unit tests. The same unit tests are the repair oracle: Section 4.3 validates each transformed program with 'the provided unit tests' and uses those tests to localize bugs before SMT-based repair. Thus the evaluation metric is exactly the objective that the neural-symbolic loop optimizes; the reported pass rate is not an independent measure of general functional correctness.

full rationale

The only substantial circularity is the conflation of the repair oracle with the correctness metric. Computation accuracy is defined as unit-test pass rate, and the same 'provided unit tests' are used to validate and localize bugs during synthesis, so the headline 95% accuracy is partly self-fulfilling. The paper's performance claims, however, are grounded in measured hardware runs against vendor libraries, and the compilation-accuracy metric is independent of the repair oracle. There is no load-bearing self-citation chain and no imported uniqueness theorem. The failure case in Section 7.6 shows the guarantee is not fully forced, which is why the score is 6 rather than higher. If the authors had used a held-out test suite or a formal equivalence proof, the central correctness claim would be substantially more independent.

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

No new physical or theoretical entities are introduced; QiMeng-Xpiler is a software system. Free parameters are the MCTS hyperparameters, and the central assumptions are the sufficiency of the pass set, the validity of unit tests as semantic oracle, and the coverage of SMT repair.

free parameters (2)
  • MCTS maximum search depth N = 13
    Selected via design space exploration in Section 5.2 to balance search time and reward; not derived from theory.
  • MCTS number of simulations = 512
    Selected via design space exploration in Section 5.2; no principled justification is given.
assumptions (4)
  • domain assumption The 11 predefined transformation passes (Section 3, Table 4) are sufficient to transcompile any tensor program across the four DLS.
    The paper asserts this sufficiency without proof; if a translation requires a transformation not among the 11, the pipeline cannot produce it.
  • domain assumption Passing the provided unit tests implies functional equivalence of the whole program.
    Unit tests are the only semantic oracle used by repair and evaluation; no formal whole-program equivalence proof is given.
  • domain assumption SMT-based snippet repair is sound for the generated sketches and constraints.
    Algorithm 3 assumes the constraint encoding covers all error types; Section 7.6 shows complex control flow defeats both LLM and SMT, so the assumption does not always hold.
  • domain assumption BM25 retrieval from programming manuals plus LLM annotation correctly identifies target intrinsics and memory layout.
    The accuracy of reference annotation underpins LLM transformation but is not independently evaluated.

how reviews work

0 comments
Cite this review

Pith. "Pith review of QiMeng-Xpiler: Transcompiling Tensor Programs for Deep Learning Systems with a Neural-Symbolic Approach." pith.science (2026). https://pith.science/paper/Y63PIB4T

@misc{pith2026250502146,
  author       = {Pith},
  title        = {Pith review of: QiMeng-Xpiler: Transcompiling Tensor Programs for Deep Learning Systems with a Neural-Symbolic Approach},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y63PIB4T}},
  note         = {Machine review of arXiv:2505.02146}
}
read the original abstract

Heterogeneous deep learning systems (DLS) such as GPUs and ASICs have been widely deployed in industrial data centers, which requires to develop multiple low-level tensor programs for different platforms. An attractive solution to relieve the programming burden is to transcompile the legacy code of one platform to others. However, current transcompilation techniques struggle with either tremendous manual efforts or functional incorrectness, rendering "Write Once, Run Anywhere" of tensor programs an open question. We propose a novel transcompiler, i.e., QiMeng-Xpiler, for automatically translating tensor programs across DLS via both large language models (LLMs) and symbolic program synthesis, i.e., neural-symbolic synthesis. The key insight is leveraging the powerful code generation ability of LLM to make costly search-based symbolic synthesis computationally tractable. Concretely, we propose multiple LLM-assisted compilation passes via pre-defined meta-prompts for program transformation. During each program transformation, efficient symbolic program synthesis is employed to repair incorrect code snippets with a limited scale. To attain high performance, we propose a hierarchical auto-tuning approach to systematically explore both the parameters and sequences of transformation passes. Experiments on 4 DLS with distinct programming interfaces, i.e., Intel DL Boost with VNNI, NVIDIA GPU with CUDA, AMD MI with HIP, and Cambricon MLU with BANG, demonstrate that QiMeng-Xpiler correctly translates different tensor programs at the accuracy of 95% on average, and the performance of translated programs achieves up to 2.0x over vendor-provided manually-optimized libraries. As a result, the programming productivity of DLS is improved by up to 96.0x via transcompiling legacy tensor programs.

Figures

Figures reproduced from arXiv: 2505.02146 by the authors.

Figure 1
Figure 1. Comparing QiMeng-Xpiler to existing transcompilation techniques in terms of (a) scalability-accuracy axis and (b) human efforts e.g., NVIDIA GPU with Tensor Core [12], Google TPU [29], GraphCore IPU [9], and Cambricon MLU [3], have been de￾ployed in data centers of cloud and internet service companies such as Microsoft [10], Google [6], and Amazon [4]. To fully exploit various DLS, it is required to develop multiple… view at source ↗
Figure 2
Figure 2. (c) tends to replace the original SIMT-based scalar operations with SIMD-based tensorized instructions, but the parameter that indicates the tensor length should be 2309 rather than 1024. int i = blockIdx.x * 1024 + threadIdx.x; if (i < 2309) { T_add[i] = A[i] + B[i];} int i = clusterId * 1024 + CoreId; if (i < 2309) { T_add[i] = A[i] + B[i];} if (row < 128 && col < 128) { C[row * 128 + col] = 0.0f; for (int i = 0; … view at source ↗
Figure 3
Figure 3. The overview of QiMeng-Xpiler, a novel transcompiler for automatic transcompilation of tensor programs across different programming models. The transcompiler consists of two parts: (a) neural-symbolic program synthesis, which utilizes LLM to transform code and repair incorrect transformation through symbolic synthesis with limited scales, and (b) hierarchical performance auto-tuning, which systemically explores both… view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: An illustrative example of the proposed neural-symbolic program synthesis on a tensorization case. [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 6
Figure 6. Figure 6: The auto-tuning prompt for loop split. 5.1 Intra-Pass Auto-Tuning During the transformation process, passes such as loop split and loop reorder are tasked with making a series of critical decisions, including the split size and loop order, which significantly affect th…
Figure 7
Figure 7. Figure 7: Performance evaluations on four common transcompilation directions and various operators. The performance of programs generated by QiMeng￾Xpiler is compared to its manually optimized counterparts, PyTorch, with backend libraries such as cuDNN/cuBLAS, CNNL, rocBLAS, and…
Figure 8
Figure 8. Figure 8 [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 9
Figure 9. Figure 9: The complex control flow in Deformable Attention. 8 Related Work Rule-based approaches. These methods focus on transcom￾piling source programs to target languages using expert￾defined rules [5, 7, 13, 47]. For instance, C2Rust [13] and CxGo [5] translate C code to Rust…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. QiMeng: Fully Automated Hardware and Software Design for Processor Chip

    cs.AR 2025-06 conditional novelty 4.0 of 10

    QiMeng is a proposed three-layer architecture for automating processor hardware and software design, with several published components but no integrated implementation yet.

Reference graph

Works this paper leans on

51 extracted references · 37 canonical work pages · cited by 1 Pith paper

  1. [1]

    https:// developer.nvidia.com/cublas

    Basic Linear Algebra on NVIDIA GPUs. https:// developer.nvidia.com/cublas

    work page

  2. [2]

    https://www

    Cambricon BANG C Developer Guide. https://www. cambricon.com/docs/sdk_1.13.0/cntoolkit_3.5. 2/cambricon_bang_c_4.5.1/index.html

    work page

  3. [3]

    https://www.cambricon.com/

    Cambricon MLU. https://www.cambricon.com/

    work page

  4. [4]

    https://aws.amazon.com/

    Cloud Computing Services - Amazon Web Services (AWS). https://aws.amazon.com/

    work page

  5. [5]

    https://github.com/gotranspile/cxgo

    cxgo. https://github.com/gotranspile/cxgo

    work page

  6. [6]

    https:// cloud.google.com/

    Google Cloud: Cloud Computing Services. https:// cloud.google.com/

    work page

  7. [7]

    https://github.com/ROCm/HIPIFY

    HIPIFY. https://github.com/ROCm/HIPIFY

    work page

  8. [8]

    https://openai.com/o1/

    Introducing OpenAI o1. https://openai.com/o1/

    work page

Show all 51 references
  1. [9]

    https://www.graphcore.ai/ products/ipu

    IPU Processors. https://www.graphcore.ai/ products/ipu

  2. [10]

    https: //azure.microsoft.com/

    Microsoft Azure: Cloud Computing Services. https: //azure.microsoft.com/

  3. [11]

    https://developer.nvidia.com/ cudnn

    NVIDIA cuDNN. https://developer.nvidia.com/ cudnn

  4. [12]

    https://www.nvidia.cn/ data-center/tensor-cores/

    NVIDIA Tensor Core. https://www.nvidia.cn/ data-center/tensor-cores/

  5. [13]

    https://github.com/immunant/ c2rust

    C2Rust, [n.d]. https://github.com/immunant/ c2rust

  6. [14]

    https://github.com/intel/mkl-dnn

    oneAPI Deep Neural Network Library (oneDNN), [n.d]. https://github.com/intel/mkl-dnn

  7. [16]

    Neural machine translation by jointly learning to align and translate

    Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Ben- gio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014

    2014 arXiv

  8. [17]

    Mosaic: An interoperable compiler for tensor algebra

    Manya Bansal, Olivia Hsu, Kunle Olukotun, and Fredrik Kjolstad. Mosaic: An interoperable compiler for tensor algebra. Proceedings of the ACM on Programming Languages, 7(PLDI):394–419, 2023. 13

    2023

  9. [18]

    Seshia, and Alvin Cheung

    Sahil Bhatia, Sumer Kohli, Sanjit A. Seshia, and Alvin Cheung. Building Code Transpilers for Domain- Specific Languages Using Program Synthesis. In Karim Ali and Guido Salvaneschi, editors, 37th European Con- ference on Object-Oriented Programming (ECOOP 2023), volume 263 ofLe...

    2023

  10. [19]

    Browne, Edward Powley, Daniel White- house, Simon M

    Cameron B. Browne, Edward Powley, Daniel White- house, Simon M. Lucas, Peter I. Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Com- putational Intelligence an...

    2012

  11. [20]

    Sparks of artificial general intelligence: Early experiments with gpt-4

    Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint arXiv:2303.12712, 2023

    2023 arXiv

  12. [21]

    Evaluating large language models trained on code

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021

    2021 arXiv

  13. [22]

    Teaching large language models to self- debug

    Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. Teaching large language models to self- debug. arXiv preprint arXiv:2304.05128, 2023

    2023 arXiv

  14. [23]

    Bert: Pre-training of deep bidirec- tional transformers for language understanding

    Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirec- tional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018

    2018 arXiv

  15. [24]

    Cox: Exposing cuda warp-level functions to cpus

    Ruobing Han, Jaewon Lee, Jaewoong Sim, and Hyesoon Kim. Cox: Exposing cuda warp-level functions to cpus. ACM Trans. Archit. Code Optim., 19(4), sep 2022

    2022

  16. [25]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vi- sion and Pattern Recognition (CVPR), pages 770–778, 2016

    2016

  17. [26]

    Mobilenets: Efficient convolutional neural networks for mobile vision appli- cations

    Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision appli- cations. arXiv preprint arXiv:1704.04861, 2017

    2017 arXiv

  18. [27]

    Exocompi- lation for productive programming of hardware accel- erators

    Yuka Ikarashi, Gilbert Louis Bernstein, Alex Reinking, Hasan Genc, and Jonathan Ragan-Kelley. Exocompi- lation for productive programming of hardware accel- erators. In Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementati...

    2022

  19. [28]

    Martini: The little match and replace tool for automatic application rewriting with code exam- ples

    Alister Johnson, Camille Coti, Allen D Malony, and Jo- hannes Doerfert. Martini: The little match and replace tool for automatic application rewriting with code exam- ples. In European Conference on Parallel Processing, pages 19–34. Springer, 2022

    2022

  20. [29]

    In- datacenter performance analysis of a tensor process- ing unit

    Norman P Jouppi, Cliff Young, Nishant Patil, David Pat- terson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, et al. In- datacenter performance analysis of a tensor process- ing unit. In Proceedings of the 44th ACM/IEEE An- nual Internatio...

    2017

  21. [30]

    Taco: A tool to gen- erate tensor algebra kernels

    Fredrik Kjolstad, Stephen Chou, David Lugato, Shoaib Kamil, and Saman Amarasinghe. Taco: A tool to gen- erate tensor algebra kernels. In 2017 32nd IEEE/ACM International Conference on Automated Software Engi- neering (ASE), pages 943–948. IEEE, 2017

    2017

  22. [31]

    Starcoder: may the source be with you!, 2023

    Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, Qian Liu, Evgenii Zheltonozhskii, Terry Yue Zhuo, Thomas Wang, Olivier Dehaene, Mishig Davaadorj, Joel Lamy- Poirier, João Monteiro,...

    2023

  23. [32]

    Competition-level code generation with alphacode

    Yujia Li, David Choi, Junyoung Chung, Nate Kush- man, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. Competition-level code generation with alphacode. Sci- ence, 378(6624):1092–1097, 2022. 14

    2022

  24. [33]

    C2taco: Lifting tensor code to taco

    José Wesley de Souza Magalhães, Jackson Woodruff, Elizabeth Polgreen, and Michael FP O’Boyle. C2taco: Lifting tensor code to taco. In Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences, pages 42–56, 2023

    2023

  25. [34]

    Z3: an effi- cient smt solver

    Leonardo De Moura and Nikolaj Bjørner. Z3: an effi- cient smt solver. In In Proceedings of the Theory and practice of software, 14th international conference on Tools and algorithms for the construction and analysis of systems, ASPLOS ’21, pages 337–340, 2008

    2008

  26. [35]

    Codegen: An open large language model for code with multi-turn program synthesis

    Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, and Caim- ing Xiong. Codegen: An open large language model for code with multi-turn program synthesis. arXiv preprint arXiv:2203.13474, 2022

    2022 arXiv

  27. [36]

    GPT-4 technical report

    OpenAI. GPT-4 technical report. CoRR, abs/2303.08774, 2023

    2023 arXiv

  28. [37]

    Efficient compilation of cuda kernels for high- performance computing on fpgas

    Alexandros Papakonstantinou, Karthik Gururaj, John A Stratton, Deming Chen, Jason Cong, and Wen-Mei W Hwu. Efficient compilation of cuda kernels for high- performance computing on fpgas. ACM Transactions on Embedded Computing Systems (TECS), 13(2):1–26, 2013

    2013

  29. [38]

    Chasins, and Rastislav Bodík

    Phitchaya Mangpo Phothilimthana, Tikhon Jelvis, Ro- hin Shah, Nishant Totla, Sarah E. Chasins, and Rastislav Bodík. Chlorophyll: synthesis-aided compiler for low- power spatial architectures. In Michael F. P. O’Boyle and Keshav Pingali, editors, In Proceedings of Inter- nation...

    2014

  30. [39]

    Seshia, and Alvin Cheung

    Jie Qiu, Colin Cai, Sahil Bhatia, Niranjan Hasabnis, San- jit A. Seshia, and Alvin Cheung. Tenspiler: A verified- lifting-based compiler for tensor operations. In Jonathan Aldrich and Guido Salvaneschi, editors, 38th European Conference on Object-Oriented Programming, ECOOP 20...

    2024

  31. [40]

    Unsupervised translation of programming languages

    Baptiste Roziere, Marie-Anne Lachaux, Lowik Chanus- sot, and Guillaume Lample. Unsupervised translation of programming languages. In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 206...

    2020

  32. [41]

    Generative neu- ral machine translation

    Harshil Shah and David Barber. Generative neu- ral machine translation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors,Advances in Neural Information Pro- cessing Systems, volume 31. Curran Associates, Inc., 2018

    2018

  33. [42]

    Simonyan and A

    K. Simonyan and A. Zisserman. Very Deep Convolu- tional Networks for Large-Scale Image Recognition. In International Conference on Learning Representations, May 2015

    2015

  34. [43]

    Gemini: a family of highly capable multimodal models

    Gemini Team, Rohan Anil, Sebastian Borgeaud, Yonghui Wu, Jean-Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M Dai, Anja Hauth, et al. Gemini: a family of highly capable multimodal models. arXiv preprint arXiv:2312.11805, 2023

    2023 arXiv

  35. [44]

    Llama 2: Open foundation and fine-tuned chat models

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288, 2023

    2023 arXiv

  36. [45]

    Im- provements to bm25 and language models examined

    Andrew Trotman, Antti Puurula, and Blake Burgess. Im- provements to bm25 and language models examined. In Proceedings of the 19th Australasian Document Com- puting Symposium, ADCS ’14, page 58–65, New York, NY , USA, 2014. Association for Computing Machinery

    2014

  37. [46]

    Vectorization for dig- ital signal processors via equality saturation extended abstract

    Alexa VanHattum, Rachit Nigam, Vincent T Lee, James Bornholt, and Adrian Sampson. Vectorization for dig- ital signal processors via equality saturation extended abstract

  38. [47]

    Polyhedral parallel code generation for cuda

    Sven Verdoolaege, Juan Carlos Juega, Albert Cohen, José Ignacio Gómez, Christian Tenllado, and Francky Catthoor. Polyhedral parallel code generation for cuda. ACM Trans. Archit. Code Optim., 9(4), jan 2013

    2013

  39. [48]

    Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation

    Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. arXiv preprint arXiv:2109.00859, 2021

    2021 arXiv

  40. [49]

    Jackson Woodruff, Jordi Armengol-Estapé, Sam Ainsworth, and Michael F. P. O’Boyle. Bind the gap: Compiling real software to hardware fft accelerators. In In Proceedings of International Conference on Programming Language and Design Implementation (PLDI), page 687–702, 2022

    2022

  41. [50]

    Google’s neural machine translation system: Bridging the gap between human and machine translation

    Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144,...

    2016 arXiv

  42. [51]

    Vision transformer with deformable at- tention

    Zhuofan Xia, Xuran Pan, Shiji Song, Li Erran Li, and Gao Huang. Vision transformer with deformable at- tention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 4794–4803, 2022

    2022

  43. [52]

    Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval- x

    Qinkai Zheng, Xiao Xia, Xu Zou, Yuxiao Dong, Shan Wang, Yufei Xue, Zihan Wang, Lei Shen, Andi Wang, Yang Li, et al. Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval- x. arXiv preprint arXiv:2303.17568, 2023. 16

    2023 arXiv

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.