Pith. sign in

REVIEW 3 major objections 7 minor 37 references

HPC-Coder-V2: Studying Code LLMs Across Low-Resource Parallel Languages

T0 review · 3 major / 7 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Fine-tuning on synthetic HPC instruction data lets a 16B open-source model generate parallel code at near-GPT-4 accuracy.

desk verdict Solid dataset and ablation study, but the 'best open-source' ranking is statistically fragile — worth reviewing, not desk-rejecting. read the letter →

arxiv 2412.15178 v1 pith:H7JV45TB submitted 2024-12-19 cs.DC cs.LGcs.SE

Aman Chaturvedi , Daniel Nichols , Siddharth Singh , Abhinav Bhatele This is my paper · ORCID
classification cs.DCcs.LGcs.SE
keywords largelanguagemodelscodegenerationhighperformancecomputingparallelsyntheticinstructiondatafine-tuningParEvalMPI
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's claim is that generating high-quality, HPC-specific instruction data is a tractable way to improve LLMs for parallel code, and that fine-tuning open models on such data can close much of the gap to frontier commercial models. To support the claim, the authors build HPC-INSTRUCT, roughly 122k problem–solution pairs distilled from four LLMs (Gemini-Pro, DBRX, Llama-3-70B, Mixtral-8x7B) using open-source parallel-code snippets as seeds, then fine-tune DeepSeek-Coder base models of 1.3B, 6.7B, and 16B parameters on this data plus two general code-instruction datasets. Their best model, HPC-Coder-V2-16B, scores 34.1 pass@1 on the ParEval parallel-code benchmark, ahead of Phind-V2-34B (32.1), Magicoder-6.7B (30.4), and StarCoder2-15B (23.1), and within a few points of GPT-4 (37.8) and GPT-3.5 (39.6). The ablation studies identify the levers behind the gain: data source (and by proxy quality) matters more than data volume for larger models, fine-tuning base weights beats fine-tuning instruct variants, instruction masking has little effect, and gains from scaling to 16B are small compared with the jump from 1.3B to 6.7B. If these conclusions hold, HPC teams can build competitive parallel-code assistants from open weights rather than relying on closed APIs.

What carries the argument

The machinery is HPC-INSTRUCT, a synthetic instruction dataset built by wrapping seed snippets from open-source HPC code in four prompt templates (programming, translation, optimization, parallelization), having four LLMs generate problem–solution pairs, and keeping the roughly 122k samples that parse. The authors then fine-tune DeepSeek-Coder base models on this dataset together with Magicoder-OSS-Instruct-75K and Evol-Instruct-Code-80k-v1, and evaluate on ParEval, a 420-problem benchmark that compiles and unit-tests generated code across twelve problem types and seven execution models, reporting pass@1, the estimated probability that a single generated sample passes the tests. The controlled variations of this dataset and the fine-tuning configuration carry the argument: data amount, data source, base-model choice, instruction masking, and model size are each varied while measuring ParEval pass@1.

What would settle it

Take a few hundred HPC-INSTRUCT samples, compile and run them against ParEval's unit-test drivers, and compare the dataset's own pass rate with the pass@1 of the fine-tuned models; if the dataset's pass rate is low, or if retraining on only verified-correct samples changes ParEval pass@1 by more than a few points, the unverified-data assumption is the load-bearing weak point.

Watch

Extended reading notes

Core claim

The central discovery is that a mid-size open-source code LLM can be made the best open-source generator of parallel code by fine-tuning on synthetic HPC instruction data. The authors report that HPC-Coder-V2-16B achieves the highest ParEval parallel pass@1 among open models (34.1), exceeding 34B Phind-V2 (32.1) and Magicoder-6.7B (30.4); the 6.7B variant reaches 33.3 while using 14.6 GB memory and higher throughput than Phind-V2-34B's 67.1 GB. They also report that fine-tuning the original DeepSeek-Coder base models consistently outperforms fine-tuning their instruct variants, that masking instruction tokens during training makes little difference, that increasing MPI data volume helps the 1.3B model up to 6k samples with diminishing returns while leaving the 6.7B model essentially unchanged, and that synthetic data generated by Llama-3-70B yields up to six pass@1 percentage points more than DBRX-generated data. The paper interprets these results as evidence that the quality of the synthetic data used for fine-tuning is the binding constraint, and that with the right data a modest open-source model can reach near-frontier parallel-code generation.

Load-bearing premise

The paper assumes without verification that the roughly 122k synthetic problem–solution pairs in HPC-INSTRUCT are correct and 'high quality,' using only the generating LLM as a proxy for quality, so if many solutions contain subtle parallel bugs the fine-tuned models could be learning flawed patterns and the reported ParEval gains would not transfer to real code.

Editorial extensions

If this is right

  • A 16B open-weight model can serve as a practical parallel-code assistant, delivering correctness close to GPT-4 at a fraction of the memory and per-token cost.
  • HPC data collection should focus on source-model quality rather than sheer volume; fine-tuning on data from a stronger generator can yield several points of pass@1 improvement.
  • Future HPC specialization should start from code base models rather than their instruct-tuned checkpoints, since base weights fine-tune more effectively for this domain.
  • MPI and MPI+OpenMP remain the weakest execution models even after targeted training, so they are the highest-value targets for future data generation and verification.
  • The diminishing returns between 6.7B and 16B mean that most of the parallel-code benefit of this recipe is available in a model that can run on a single GPU.

Reading between the lines

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

  • Because the paper uses the generating LLM as a proxy for data quality and never verifies the synthetic solutions, the data-source ranking could reflect stylistic imitation rather than semantic correctness; running a correctness-filtered version of HPC-INSTRUCT would separate the two.
  • The authors note in Section III-C that their hyperparameters were chosen by cursory experiments, so the exact pass@1 gaps across model sizes could shift under a more exhaustive search even if the main data-quality findings stand.
  • The small gain from 6.7B to 16B suggests that an intermediate size near 3B parameters might capture most of the benefit, which would make HPC-specialized assistants practical on consumer hardware; the paper does not test this.
  • The MPI data-volume experiment stops at 12k samples, so the conclusion that larger models are indifferent to more data may only hold within this range; scaling to tens of thousands of MPI samples is a natural stress test.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 7 minor

Summary. The paper introduces HPC-INSTRUCT, a synthetic parallel-code instruction dataset of roughly 122k problem-solution pairs generated by four LLMs (Gemini-Pro, DBRX, Llama-3-70B, Mixtral-8x7B) from seed snippets collected from The Stack v2, and fine-tunes DeepSeek-Coder models (1.3B, 6.7B, 16B) on it to produce the HPC-Coder-V2 family. The authors report ablation studies on instruction masking, base-versus-instruct models, MPI data quantity, synthetic data source, and model size, and evaluate all models on the ParEval benchmark. The central claim is that HPC-Coder-V2-16B is the best performing open-source code LLM for parallel code generation, with a ParEval parallel pass@1 of 34.1, ahead of Phind-V2-34B (32.1) and Magicoder-6.7B (30.4), and close to GPT-4 (37.8) and GPT-3.5 (39.6).

Significance. The paper makes a substantial practical contribution: a large, publicly released synthetic HPC instruction dataset, three released open models, and a systematic ablation study that addresses several under-explored fine-tuning choices for low-resource parallel languages. The use of a machine-checked correctness harness (ParEval's unit tests), the release of reproducibility scripts, and the breadth of the ablation (28 fine-tuned models) are concrete strengths. The observed improvements over strong open-source baselines are plausible and of clear interest to the HPC-LLM community. However, the headline ranking claim and several quantitative conclusions rest on point estimates from a single self-authored benchmark with no confidence intervals, and the synthetic data is used without any verification of solution correctness. These issues currently limit the strength of the evidence for the paper's strongest claims, even though the underlying methodology and artifacts are valuable.

major comments (3)
  1. [§VII-B, Table I, Appendix C] The headline claim that HPC-Coder-V2-16B is the best performing open-source model for parallel code generation is not statistically established. Table I reports parallel pass@1 values of 34.1 (HPC-Coder-V2-16B), 33.3 (HPC-Coder-V2-6.7B), and 32.1 (Phind-V2-34B). Appendix C states that pass@1 is estimated from 20 samples per prompt over 420 problems, i.e., the aggregate mean of per-problem cp/20. Under that protocol the standard error of the aggregate mean is approximately sqrt( (1/420)*mean(p_i(1-p_i)/20) + var(p_i)/420 ), which, given the large between-problem variance visible in the Figure 12 heatmaps, is on the order of 1.5–2 percentage points. Consequently, the 2-point gap over Phind-V2 and the 0.8-point gap over the 6.7B model are plausibly sampling noise. No confidence intervals, significance tests, or per-problem pass@1 distributions are reported. The same concern applies to the ablation conclusions in Section VI, including the instruction-masking differences in Figure 4 (e.g., 31.8 vs. 31.1 for the 6.7B base model) and the data-source differences in Figure 6. The authors should provide uncertainty quantification (confidence intervals or significance tests) and either demonstrate that the reported separations are statistically meaningful or soften the ranking claims accordingly.
  2. [§V-A, §VII-B, §III-A] All central claims—the comparison with other models, the ranking, and every ablation—are evaluated exclusively on ParEval [2], a benchmark co-authored by two of the present authors. No independent parallel-code benchmark is used to validate the ranking, and no decontamination check is reported between HPC-INSTRUCT (whose seed snippets are drawn from The Stack v2, the same corpus used to pretrain several comparison models) and ParEval. The claim that HPC-Coder-V2 is the best open-source model for parallel code generation therefore rests on a single, self-authored, potentially benchmark-specific evaluation. The authors should validate the ranking on at least one external benchmark or provide a contamination analysis (e.g., checking for n-gram overlap between HPC-INSTRUCT and ParEval prompts), or explicitly acknowledge this as a limitation of the headline claim.
  3. [§VI-B, RQ3, §III-A] The conclusion that the quality of synthetic data significantly impacts fine-tuned model performance (RQ3) uses the generating LLM identity as a proxy for data quality, but no automated or human verification of the correctness of the HPC-INSTRUCT problem-solution pairs is reported. The paper itself notes in Section VI-B that this approach 'will not allow us to infer what makes the data better or worse.' If a substantial fraction of the generated solutions contain subtle correctness bugs—which is plausible given that the generating LLMs are asked to write non-trivial parallel code—the fine-tuned models may be learning flawed patterns, and the reported ParEval gains plus the data-quality conclusions would not transfer to real parallel-code generation. The authors should either add a verification or random-audit step for the synthetic data, or reframe the RQ3 result as an effect of the data source model rather than of 'data quality' as a validated property.
minor comments (7)
  1. [§IV-B] Typo: 'Tangetially' should be 'Tangentially'.
  2. [Figure 5 caption] The caption says 'MPI fine-tuning date'; 'date' should be 'data'.
  3. [§V-A] The sentence 'These problems range across 12 different problem types: sort, scan, dense linear algebra, sparse linear algebra, search, reduce, histogram, stencil, graph, geometry, fourier transform and transform help us show the diversity' is grammatically incomplete; 'and transform help us show' should be rephrased, for example as '... and transform. These problem types help us show the diversity ...'.
  4. [Equation (1)] The binomial-coefficient notation in the pass@k formula is garbled in the text (the superscript/subscript layout does not render correctly). Please fix the typesetting so that the formula reads as 1 - C(N-c_p, k)/C(N, k).
  5. [Abstract and §I] The claim 'best performing open-source code LLM for parallel code generation to date' should be qualified as applying to the ParEval benchmark, since no external benchmark is used.
  6. [Figure 11] In the throughput-versus-pass@1 scatter plot, the HPC-Coder-V2-16B dot is not labeled with its memory requirement (GB) or throughput; please add the missing label for completeness.
  7. [§VIII-A] The related-work discussion mentions HPC-specific models such as MPIrigen [23] and OMPGPT [31] but does not quantitatively compare against them; a brief statement of why they are not directly comparable (e.g., task scope or evaluation protocol) would help situate the contribution.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the shared-author ParEval benchmark is a public, externally checkable evaluation suite, and the headline ranking is an empirical measurement rather than a construction from its inputs.

full rationale

ParEval [2] is the only benchmark used for the headline claims, and it shares two authors with this paper; this is a self-citation and an independence concern. It is not, however, circular in the defined sense. ParEval is a published, code-reproducible benchmark (HPDC '24), the models' pass@1 values are empirical measurements obtained by running the benchmark, and nothing in the paper defines 'best open-source parallel-code LLM' as 'highest score on ParEval' in a way that makes the comparison true by construction. The synthetic HPC-INSTRUCT dataset is generated before and independently of the ParEval evaluations; the data-quality study (RQ3) explicitly uses the generating LLM only as a proxy and disclaims any inference about intrinsic quality, so it does not smuggle the conclusion into the definition. Concerns about missing confidence intervals, possible decontamination, and selection of the final configuration on the same benchmark are real statistical-validity risks, but they are not circularity. No equation or parameter is fitted to ParEval and then reported as a prediction, and no load-bearing claim is justified solely by an unverified self-citation. Hence score 0.

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

The central empirical claim rests on several hand-chosen training hyperparameters and three unverified assumptions: the correctness of synthetic solutions, the validity of the source-LLM quality proxy, and the sufficiency of the self-authored ParEval benchmark. These are not fitted parameters but choices and assumptions that the paper does not independently validate.

free parameters (5)
  • Learning rate and optimizer hyperparameters = Not reported
    Fine-tuning uses AdamW (Section III-C) but the learning rate, weight decay, and scheduler are never stated; these hand-chosen values affect convergence and are required for replication.
  • Batch size = 128 (1.3B/6.7B), 1024 (16B)
    Chosen based on model size and GPU memory (Section III-C), not tuned; affects training dynamics.
  • Number of epochs = 2 (1.3B/6.7B), 1 (16B)
    Selected from related literature (Section III-C); no ablation on epochs.
  • Sequence length / context window = 8192 tokens
    Reduced from the base model's 16k because no data sample exceeds 8k tokens (Section III-C); a design choice.
  • Seed snippet counts per language = 25k Python/C/Fortran/C++, 15k CUDA, 5k Chapel/OpenCL
    Ad hoc distribution chosen to diversify the synthetic data (Section III-A); not justified by a data analysis.
assumptions (5)
  • domain assumption LLM-generated synthetic problem-solution pairs are correct and high quality without verification.
    The data pipeline (Section III-A) uses LLMs to generate solutions from seed snippets and discards only unparsable outputs; correctness is never checked.
  • ad hoc to paper The generating LLM identity is a valid proxy for synthetic data quality.
    Section VI-B states the source model is used as a proxy because quality cannot be quantified; this assumption underlies RQ3's conclusions.
  • domain assumption ParEval pass@1 is a valid and sufficient measure of parallel code generation ability.
    All claims and ablations use ParEval (Section V-A), a benchmark co-authored by this group; no external parallel-code benchmark is used.
  • domain assumption Pass@1 estimates from N=20 samples per problem are stable enough to support differences of a few points.
    Equation 1 and Appendix C use 20 generations per problem; no confidence intervals or significance tests are reported.
  • domain assumption Seed snippets from The Stack V2 provide representative coverage of HPC parallel code.
    The dataset is built from 125k snippets gathered from open-source codebases (Section III-A); representativeness is not assessed.

how reviews work

0 comments
Cite this review

Pith. "Pith review of HPC-Coder-V2: Studying Code LLMs Across Low-Resource Parallel Languages." pith.science (2026). https://pith.science/paper/H7JV45TB

@misc{pith2026241215178,
  author       = {Pith},
  title        = {Pith review of: HPC-Coder-V2: Studying Code LLMs Across Low-Resource Parallel Languages},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/H7JV45TB}},
  note         = {Machine review of arXiv:2412.15178}
}
read the original abstract

Large Language Model (LLM) based coding tools have been tremendously successful as software development assistants, yet they are often designed for general purpose programming tasks and perform poorly for more specialized domains such as high performance computing. Creating specialized models and tools for these domains is crucial towards gaining the benefits of LLMs in areas such as HPC. While previous work has explored HPC-specific models, LLMs still struggle to generate parallel code and it is not at all clear what hurdles are still holding back these LLMs and what must be done to overcome them. In this work, we conduct an in-depth study along the many axes of fine-tuning a specialized HPC LLM in order to better understand the challenges. Based on our findings we fine-tune and evaluate a specialized HPC LLM that is shown to be the best performing open-source code LLM for parallel code generation to date.

Figures

Figures reproduced from arXiv: 2412.15178 by the authors.

Figure 1
Figure 1. Overview of the methodology proposed in this paper. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Synthetic data generation process. We collect seed snippets from open source codebases and combine them with multiple [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Example synthetic data generation output. Here, a [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: ParEval parallel code generation scores for various [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 6
Figure 6. Figure 6: ParEval parallel code generation performance across [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: ParEval serial and parallel code generation performance [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: ParEval code generation performance by problem type. These results follow similar trends to those shown in [2] except [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: ParEval code generation performance by execution [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: Comparison of ParEval parallel and serial code generation performance across all models. The HPC-Coder-V2 models [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]
Figure 11
Figure 11. Figure 11: Comparison of parallel code generation pass rate [PITH_FULL_IMAGE:figures/full_fig_p010_11.png]
Figure 12
Figure 12. Figure 12: Complete generation results for a sample of the models on the ParEval benchmark. Each box shows the pass@1 score [PITH_FULL_IMAGE:figures/full_fig_p013_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

37 extracted references · 15 canonical work pages

  1. [2]

    Can large language models write parallel code?

    D. Nichols, J. H. Davis, Z. Xie, A. Rajaram, and A. Bhatele, “Can large language models write parallel code?” in Proceedings of the 33rd International Symposium on High-Performance Parallel and Distributed Computing, ser. HPDC ’24. New York, NY , USA: Association for Computing Machinery, 2024

    work page 2024

  2. [1]

    Survey reveals ai’s impact on the developer experience,

    I. Shani, “Survey reveals ai’s impact on the developer experience,” https://github.blog/news-insights/research/ survey-reveals-ais-impact-on-the-developer-experience/, June 2023, accessed: 2024-10-12

    work page 2023

  3. [3]

    Starcoder 2 and the stack v2: The next generation,

    A. Lozhkov, R. Li, L. B. Allal, F. Cassano, J. Lamy-Poirier, N. Tazi, A. Tang, D. Pykhtar, J. Liu, Y . Wei, T. Liu, M. Tian, D. Kocetkov, A. Zucker, Y . Belkada, Z. Wang, Q. Liu, D. Abulkhanov, I. Paul, Z. Li, W.-D. Li, M. Risdal, J. Li, J. Zhu, T. Y . Zhuo, E. Zheltonozhskii, N. O. O. Dade, W. Yu, L. Krauß, N. Jain, Y . Su, X. He, M. Dey, E. Abati, Y . C...

    2024

  4. [4]

    Attention is all you need,

    A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” in Advances in neural information processing systems , 2017, pp. 5998–6008

    2017

  5. [5]

    Code llama: Open foundation models for code,

    B. Rozi `ere, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. E. Tan, Y . Adi, J. Liu, T. Remez, J. Rapin, A. Kozhevnikov, I. Evtimov, J. Bitton, M. Bhatt, C. C. Ferrer, A. Grattafiori, W. Xiong, A. D ´efossez, J. Copet, F. Azhar, H. Touvron, L. Martin, N. Usunier, T. Scialom, and G. Synnaeve, “Code llama: Open foundation models for code,” 2023

    work page 2023

  6. [6]

    Gpt-4o system card,

    OpenAI, A. Hurst, and et al, “Gpt-4o system card,” 2024. [Online]. Available: https://arxiv.org/abs/2410.21276

    arXiv 2024

  7. [7]

    A survey on knowledge distillation of large language models,

    X. Xu, M. Li, C. Tao, T. Shen, R. Cheng, J. Li, C. Xu, D. Tao, and T. Zhou, “A survey on knowledge distillation of large language models,” 2024. [Online]. Available: https://arxiv.org/abs/2402.13116

    arXiv 2024

  8. [8]

    Magicoder: Source code is all you need,

    Y . Wei, Z. Wang, J. Liu, Y . Ding, and L. Zhang, “Magicoder: Source code is all you need,” arXiv preprint arXiv:2312.02120 , 2023

    arXiv 2023

Show all 37 references
  1. [9]

    Big code models leaderboard - a hugging face space by bigcode,

    “Big code models leaderboard - a hugging face space by bigcode,” 2023. [Online]. Available: https://huggingface.co/spaces/ bigcode/bigcode-models-leaderboard

    2023

  2. [10]

    Deepseek-coder: When the large language model meets programming – the rise of code intelligence,

    D. Guo, Q. Zhu, D. Yang, Z. Xie, K. Dong, W. Zhang, G. Chen, X. Bi, Y . Wu, Y . K. Li, F. Luo, Y . Xiong, and W. Liang, “Deepseek-coder: When the large language model meets programming – the rise of code intelligence,” 2024

    2024

  3. [11]

    Deepseek-coder-v2: Breaking the barrier of closed-source models in code intelligence,

    DeepSeek-AI, Q. Zhu, D. Guo, Z. Shao, D. Yang, P. Wang, R. Xu, Y . Wu, Y . Li, H. Gao, S. Ma, W. Zeng, X. Bi, Z. Gu, H. Xu, D. Dai, K. Dong, L. Zhang, Y . Piao, Z. Gou, Z. Xie, Z. Hao, B. Wang, J. Song, D. Chen, X. Xie, K. Guan, Y . You, A. Liu, Q. Du, W. Gao, X. Lu, Q. Chen, ...

    2024 arXiv

  4. [12]

    Llama 2: Open foundation and fine-tuned chat models,

    H. Touvron et al. , “Llama 2: Open foundation and fine-tuned chat models,” Tech. Rep., 2023

    2023

  5. [13]

    Efficient large scale language modeling with mixtures of experts,

    M. Artetxe, S. Bhosale, N. Goyal, T. Mihaylov, M. Ott, S. Shleifer, X. V . Lin, J. Du, S. Iyer, R. Pasunuru, G. Anantharaman, X. Li, S. Chen, H. Akin, M. Baines, L. Martin, X. Zhou, P. S. Koura, B. O’Horo, J. Wang, L. Zettlemoyer, M. Diab, Z. Kozareva, and V . Stoyanov, “Effic...

    2021 arXiv

  6. [14]

    Wizardcoder: Empowering code large language models with evol-instruct,

    Z. Luo, C. Xu, P. Zhao, Q. Sun, X. Geng, W. Hu, C. Tao, J. Ma, Q. Lin, and D. Jiang, “Wizardcoder: Empowering code large language models with evol-instruct,” arXiv preprint arXiv:2306.08568 , 2023

    2023 arXiv

  7. [15]

    Exploiting sparsity in pruned neural networks to optimize large model training,

    S. Singh and A. Bhatele, “Exploiting sparsity in pruned neural networks to optimize large model training,” in 2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS) . Los Alamitos, CA, USA: IEEE Computer Society, may 2023, pp. 245–

    2023

  8. [16]

    Pytorch: An imperative style, high- performance deep learning library,

    A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. K ¨opf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala, “Pytorch: An imperative style, high-...

    2019

  9. [17]

    Fixing weight decay regularization in adam,

    I. Loshchilov and F. Hutter, “Fixing weight decay regularization in adam,” CoRR, vol. abs/1711.05101, 2017. [Online]. Available: http://arxiv.org/abs/1711.05101

    2017 arXiv

  10. [18]

    Evaluating large language models trained on code,

    M. Chen and et al, “Evaluating large language models trained on code,” 2021

    2021

  11. [19]

    (2023) Phind-codellama-34b-v2

    Phind. (2023) Phind-codellama-34b-v2. [Online]. Available: https: //huggingface.co/Phind/Phind-CodeLlama-34B-v2

    2023

  12. [20]

    Gemini: A family of highly capable multimodal models,

    G. Team, “Gemini: A family of highly capable multimodal models,” 2023

    2023

  13. [21]

    Language models are few-shot learners,

    T. B. Brown et al. , “Language models are few-shot learners,” CoRR, vol. abs/2005.14165, 2020. [Online]. Available: https://arxiv.org/abs/ 2005.14165

    2005 arXiv

  14. [22]

    Gpt-4 technical report,

    OpenAI, “Gpt-4 technical report,” 2023

    2023

  15. [23]

    Mpirigen: Mpi code generation through domain-specific language models,

    N. Schneider, N. Hasabnis, V . A. V o, T. Kadosh, N. Krien, M. Capota, G. Tamir, T. L. Willke, N. Ahmed, Y . Pinter, T. Mattson, and G. Oren, “Mpirigen: Mpi code generation through domain-specific language models,” in Proceedings of the 2024 Workshop on AI For Systems , ser. A...

    2024

  16. [24]

    Llm4vv: Developing llm-driven testsuite for compiler validation,

    C. Munley, A. Jarmusch, and S. Chandrasekaran, “Llm4vv: Developing llm-driven testsuite for compiler validation,” 2023

    2023

  17. [25]

    Data race detection using large language models,

    L. Chen, X. Ding, M. Emani, T. Vanderbruggen, P. hung Lin, and C. Liao, “Data race detection using large language models,” 2023

    2023

  18. [26]

    Scope is all you need: Transforming llms for hpc code,

    T. Kadosh, N. Hasabnis, V . A. V o, N. Schneider, N. Krien, A. Wasay, N. Ahmed, T. Willke, G. Tamir, Y . Pinter, T. Mattson, and G. Oren, “Scope is all you need: Transforming llms for hpc code,” 2023

    2023

  19. [27]

    Modeling parallel programs using large language models,

    D. Nichols, A. Marathe, H. Menon, T. Gamblin, and A. Bhatele, “Modeling parallel programs using large language models,” ser. ISC ’24, may 2024

    2024

  20. [28]

    Performance-aligned llms for generating fast code,

    D. Nichols, P. Polasam, H. Menon, A. Marathe, T. Gamblin, and A. Bhatele, “Performance-aligned llms for generating fast code,” 2024. [Online]. Available: https://arxiv.org/abs/2404.18864

    2024 arXiv

  21. [29]

    chathpc: Empowering hpc users with large language models,

    J. Yin, J. Hines, E. Herron, T. Ghosal, H. Liu, S. Prentice, V . Lama, and F. Wang, “chathpc: Empowering hpc users with large language models,” The Journal of Supercomputing , vol. 81, no. 1, p. 194, 2025

    2025

  22. [30]

    Lassi: An llm- based automated self-correcting pipeline for translating parallel scientific codes,

    M. T. Dearing, Y . Tao, X. Wu, Z. Lan, and V . Taylor, “Lassi: An llm- based automated self-correcting pipeline for translating parallel scientific codes,” in 2024 IEEE International Conference on Cluster Computing Workshops (CLUSTER Workshops), 2024, pp. 136–143

    2024

  23. [31]

    Ompgpt: A generative pre-trained transformer model for openmp,

    L. Chen, A. Bhattacharjee, N. Ahmed, N. Hasabnis, G. Oren, V . V o, and A. Jannesari, “Ompgpt: A generative pre-trained transformer model for openmp,” arXiv preprint arXiv:2401.16445 , 2024

    2024 arXiv

  24. [32]

    A Systematic Evaluation of Large Language Models of Code,

    F. F. Xu, U. Alon, G. Neubig, and V . J. Hellendoorn, “A Systematic Evaluation of Large Language Models of Code,” Feb. 2022, https://arxiv.org/abs/2202.13169. [Online]. Available: https://doi.org/10. 5281/zenodo.6363556

    2022 arXiv

  25. [33]

    Deepseek-coder: When the large language model meets programming – the rise of code intelligence,

    D. Guo, Q. Zhu, D. Yang, Z. Xie, K. Dong, W. Zhang, G. Chen, X. Bi, Y . Wu, Y . K. Li, F. Luo, Y . Xiong, and W. Liang, “Deepseek-coder: When the large language model meets programming – the rise of code intelligence,” 2024. [Online]. Available: https://arxiv.org/abs/2401.14196

    2024 arXiv

  26. [34]

    Biocoder: A benchmark for bioinformatics code generation with contextual prag- matic knowledge,

    X. Tang, B. Qian, R. Gao, J. Chen, X. Chen, and M. Gerstein, “Biocoder: A benchmark for bioinformatics code generation with contextual prag- matic knowledge,” 2023

    2023

  27. [35]

    Verilogeval: Evaluating large language models for verilog code generation,

    M. Liu, N. Pinckney, B. Khailany, and H. Ren, “Verilogeval: Evaluating large language models for verilog code generation,” 2023

    2023

  28. [36]

    Knowledge transfer from high-resource to low-resource programming languages for code llms,

    F. Cassano, J. Gouwar, F. Lucchetti, C. Schlesinger, A. Freeman, C. J. Anderson, M. Q. Feldman, M. Greenberg, A. Jangda, and A. Guha, “Knowledge transfer from high-resource to low-resource programming languages for code llms,” Proc. ACM Program. Lang., vol. 8, no. OOPSLA2, Oct...

    2024 doi

  29. [255]

    Available: https://doi.ieeecomputersociety.org/10.1109/ IPDPS54959.2023.00033

    [Online]. Available: https://doi.ieeecomputersociety.org/10.1109/ IPDPS54959.2023.00033

    2023

Pith tools

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