Search NASA⌕ Search

SEARCH · Search NASA

Results for “code generation”

Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 55 records · Page 3
All sourcesNASA NTRSDOE OSTI
DOE OSTI2024

Large language model evaluation for high–performance computing software development

We apply AI-assisted large language model (LLM) capabilities of GPT-3 targeting high-performance computing (HPC) kernels for (i) code generation, and (ii) auto-parallelization of serial code in C ++, Fortran, Python and Julia. Our scope includes the following fundamental numerical kernels: AXPY, GEMV, GEMM, SpMV, Jacobi Stencil, and CG, and language/programming models: (1) C++ (e.g., OpenMP [including offload], OpenACC, Kokkos, SyCL, CUDA, and HIP), (2) Fortran (e.g., OpenMP [including offload] and OpenACC), (3) Python (e.g., numpy, Numba, cuPy, and pyCUDA), and (4) Julia (e.g., Threads, CUDA.jl, AMDGPU.jl, and KernelAbstractions.jl). Kernel implementations are generated using GitHub Copilot capabilities powered by the GPT-based OpenAI Codex available in Visual Studio Code given simple + + prompt variants. To quantify and compare the generated results, we propose a proficiency metric around the initial 10 suggestions given for each prompt. For auto-parallelization, we use ChatGPT interactively giving simple prompts as in a dialogue with another human including simple “prompt engineering” follow ups. Results suggest that correct outputs for C++ correlate with the adoption and maturity of programming models. For example, OpenMP and CUDA score really high, whereas HIP is still lacking. We found that prompts from either a targeted language such as Fortran or the more general-purpose Python can benefit from adding language keywords, while Julia prompts perform acceptably well for its Threads and CUDA.jl programming models. Finally, we expect to provide an initial quantifiable point of reference for code generation in each programming model using a state-of-the-art LLM. Overall, understanding the convergence of LLMs, AI, and HPC is crucial due to its rapidly evolving nature and how it is redefining human-computer interactions.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2021

Recent Updates in ETOE-2 and MC 2 -3

The MC 2 -3 code is a multigroup cross section generation code for fast reactor applications, developed by Argonne National Laboratory (ANL) under the DOE Nuclear Energy Advanced Modeling and Simulation (NEAMS) program. In this work, first, the cross section libraries for ENDF/B-VII.1 and ENDF/B-VIII.0 data were generated using the updated ETOE-2 code. Preliminary verification and validation tests of the ENDF/B-VII.1 MC 2 -3 library were performed with the selected fast reactor benchmark problems. Processing and verifying the libraries suggested that significant efforts would be required for thoroughly verifying the ENDF/B-VII.1 MC 2 -3 library and successfully processing the ENDF/B-VIII.0 MC 2 -3 library. Secondly, the cross section generation capability of MC 2 -3 was updated with the intermediate group lattice calculation and the equivalent Dancoff-factor cell (EDC) method to significantly improve the performance of a twodimensional assembly calculation using the method of characteristics (MOC). This effort was made useful in implementing and verifying the EDC method in the Griffin cross section API. Finally, we analyzed a SFR problem, for which unusually large deviations in core eigenvalues from Monte Carlo solutions were reported, by generating multigroup cross sections with MC 2 -3, performing core calculations with DIF3D-VARIANT, and analyzing cross section and eigenvalue results against Monte Carlo solutions. The analysis confirmed that the MC 2 -3/DIF3D solutions were in good agreement with Monte Carlo solutions, providing the correct process of accurately generating broad-group cross sections with MC 2 -3

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2026

Performance-Aligned LLMs for Generating Fast HPC Code

Optimizing scientific software is a difficult task because codebases are often large and complex, and performance can depend upon several factors including the algorithm, its implementation, and hardware among others. Causes of poor performance can originate from disparate sources and be difficult to diagnose. Recent years have seen a multitude of work that use large language models (LLMs) to assist in software development tasks. However, these tools are trained to model the distribution of code as text, and are not specifically designed to understand performance aspects of code. In this work, we introduce a reinforcement learning based methodology to align the outputs of code LLMs with performance. This allows us to build upon the current code modeling capabilities of LLMs and extend them to generate better performing code. Here, we demonstrate that our fine-tuned model improves the expected speedup of generated code over base models for a set of benchmark tasks from 0.9 to 1.6 for serial code and 1.9 to 4.5 for OpenMP parallel code.

Computer science↗
DOE OSTI2021

PyOMP: Multithreaded Parallel Programming in Python

We know that Python is a widely used language in scientific computing. When the goal is high performance, however, Python lags far behind low-level languages such as C and Fortran. To support applications that stress performance, Python needs to access the full capabilities of modern CPUs. That means support for parallel multithreading. In this paper, we describe PyOMP, a system that enables OpenMP in Python. Programmers write code in Python with OpenMP, Numba generates code that compiles to LLVM, and the resulting programs run with performance that approaches that from code written with C and OpenMP. In this paper we provide an update on the PyOMP project and explain how to install it and use it to write parallel multithreaded code in Python.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2024

ChatBLAS: The First AI-Generated and Portable BLAS Library

We present ChatBLAS, the first AI-generated and portable Basic Linear Algebra Subprograms (BLAS) library on different CPU/GPU configurations. The purpose of this study is (i) to evaluate the capabilities of current large language models (LLMs) to generate a portable and HPC library for BLAS operations and (ii) to define the fundamental practices and criteria to interact with LLMs for HPC targets to elevate the trustworthiness and performance levels of the AI-generated HPC codes. The generated C/C++ codes must be highly optimized using device-specific solutions to reach high levels of performance. Additionally, these codes are very algorithm-dependent, thereby adding an extra dimension of complexity to this study. We used OpenAI’s LLM ChatGPT and focused on vector-vector BLAS level-1 operations. ChatBLAS can generate functional and correct codes, achieving high-trustworthiness levels, and can compete or even provide better performance against vendor libraries.

Valero Lara, Pedro↗
DOE OSTI2023

Developing Ultrahigh-Resolution E3SM Land Model for GPU Systems

Designing and refactoring complex scientific code, such as the E3SM land model (ELM), for new computing architectures is challenging. This paper presents design strategies and technical approaches to develop a data-oriented, GPU-ready ELM model using compiler directives (OpenACC/OpenMP). We first analyze the datatypes and processes in the original ELM code. Then we present design considerations for ultrahigh-resolution ELM (uELM) development for massive GPU systems. These techniques include the global data-oriented simulation workflow, domain partition, code porting and data copy, memory reduction, parallel loop restructure and flattening, and race condition detection. We implemented the first version of uELM using OpenACC targeting the NVidia GPUs in the Summit supercomputer at Oak Ridge National Laboratory. During the implementation, we developed a software tool (named SPEL) to facilitate code generation, verification, and performance tuning using these techniques. The first uELM implementation for Nvidia GPUs on Summit delivered promising results: 1) over 98% of the ELM code was automatically generated and tuned by scripts. Most ELM modules had better computational performances than the original ELM code for CPUs. The GPU-ready uELM is more scalable than the CPU code on fully-loaded Summit nodes. Example profiling results from several modules are also presented to illustrate the performance improvements and race condition detection. The lessons learned and toolkit developed in the study are also suitable for further uELM deployment using OpenMP on the first US exascale computer, Frontier, equipped with AMD CPUs and GPUs.

Schwartz, Peter↗
DOE OSTI2025

ghostbus v0.1.0

Ghostbus is a Verilog meta-scripting tool which automates memory map creation, address assignment, and bus routing much like Register Description Language (RDL) and SystemRDL, but with a few stark differences. First, the design is entirely defined/captured within the Verilog/SystemVerilog codebase (no extra second language). Second, the Verilog code remains valid even without the auto-generated code, enhancing modularity and compatibility with other tools/workflows.

Huang, Gang [Lawrence Berkeley National Laboratory↗
DOE OSTI2021

(U) Radiation Hydrodynamics in the Ristra Project’s Symphony code: Initial release

One of the recent focuses in the next-generation code (NGC/Ristra)project at LANL is to develop a cell-centered Lagrangian radiation-hydrodynamics code under FleCSI framework. The FleCSI frame-work provides a unified data and execution model in order to insulate production code development from the uncertainty of evolving runtimeand architectures. We have developed the code, Symphony, which in-corporates the hydrodynamics code, FleCSALE, and the radiation transport code, Puno.This memo is intended to describe the coupling of radiation and hydrodynamics within the Ristra Project’s code Symphony.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2026

Capacities of Entanglement Distribution From a Central Source

Distribution of entanglement is an essential task in quantum information processing and the realization of quantum networks. In our work, we theoretically investigate the scenario where a central source prepares an N -partite entangled state and transmits each entangled subsystem to one of N receivers through noisy quantum channels. The receivers are then able to perform local operations assisted by unlimited classical communication to distill target entangled states from the noisy channel output. In this operational context, we define the EPR distribution capacity and the GHZ distribution capacity of a quantum channel as the largest rates at which Einstein-Podolsky-Rosen (EPR) states and Greenberger-Horne-Zeilinger (GHZ) states can be faithfully distributed through the channel, respectively. We establish lower and upper bounds on the EPR distribution capacity by connecting it with the task of assisted entanglement distillation. We also construct an explicit protocol consisting of a combination of a quantum communication code and a classical-post-processing-assisted entanglement generation code, which yields a simple achievable lower bound for generic channels. As applications of these results, we give an exact expression for the EPR distribution capacity over two erasure channels and bounds on the EPR distribution capacity over two generalized amplitude damping channels. We also bound the GHZ distribution capacity, which results in an exact characterization of the GHZ distribution capacity when the most noisy channel is a dephasing channel.

42 ENGINEERING↗
DOE OSTI2026

Kinetic Model of HoxEFU reduction by NADH [SWR-26-087]

This repository is used to release code generated for manuscripts on the Photosynthetic Energy Transduction core program. This code simulates the reduction of HoxEFU by NADH. The electro transfer rate constants for the simulation are specified in the .csv files. The two .csv files correspond tot he two models described in Dawson et al. Cell. Rep. Phys. Sci. 2026. The code utilizes a chemical master equation, a set of differential equations, defining the time evolution of the oxidation and reduction kinetics of NAD+, NADH, a FMN flavin, and a set of iron sulfur clusters. The kinetics of HoxEFU reduction by NADH are evaluated by numerical integration of the chemical master equation using a variable-time-step Runge-Kutta algorithm.

Dahl, Peter [National Laboratory of the Rockies (N↗
DOE OSTI2022

Developments in Performance and Portability for MadGraph5_aMC@NLO

Event generators simulate particle interactions using Monte Carlo techniques, providing the primary connection between experiment and theory in experimental high energy physics. These software packages, which are the first step in the simulation worflow of collider experiments, represent approximately 5 to 20% of the annual WLCG usage for the ATLAS and CMS experiments. With computing architectures becoming more heterogeneous, it is important to ensure that these key software frameworks can be run on future systems, large and small. In this contribution, recent progress on porting and speeding up the Madgraph5_aMC@NLO event generator on hybrid architectures, i.e. CPU with GPU accelerators, is discussed. The main focus of this work has been in the calculation of scattering amplitudes and "matrix elements", which is the computational bottleneck of an event generation application. For physics processes limited to QCD leading order, the code generation toolkit has been expanded to produce matrix element calculations using C++ vector instructions on CPUs and using CUDA for NVidia GPUs, as well as using Alpaka, Kokkos and SYCL for multiple CPU and GPU architectures. Performance is reported in terms of matrix element calculations per time on NVidia, Intel, and AMD devices. The status and outlook for the integration of this work into a production release usable by the LHC experiments, with the same functionalities and very similar user interfaces as the current Fortran version, is also described.

Valassi, Andrea↗
DOE OSTI2025

Kinetic modeling of hot tail runaway electron generation during plasma disruptions using the JOREK code

The generation of runaway electrons (REs) during disruptions poses a significant challenge for the operation of tokamaks. The production of these high-energy electrons can cause substantial damage, particularly when the plasma current is high, making it a critical concern for ITER. For the high-temperature plasmas anticipated in ITER, the primary generation of REs may be dominated by the hot tail mechanism, which consists of the acceleration of hot electrons from the pre-disruption population which have not yet thermalized with the bulk following the rapid cooling of the plasma. To account for the significant 3D effects on RE production, a hot tail modeling framework has been developed within the non-linear 3D extended MHD code JOREK. This paper presents the structure of this framework, which is based on test electrons evolving in MHD fields. The verification of the method shows good agreement with the reference DREAM code for 0D test cases, as well as for axisymmetric simulations of 15 MA ITER H-mode disruption scenarios. Furthermore, a proof-of-principle application to a DIII-D case demonstrates the framework’s capability to capture for the first time the hot tail generation in 3D MHD simulations in realistic geometry. Preliminary results suggest that the production of REs is significantly reduced by stochastic losses.

70 PLASMA PHYSICS AND FUSION TECHNOLOGY↗
DOE OSTI2023

Status of PyGriffin Development for Integration into the NEAMS Workbench

The integration of Griffin into Workbench, by way of the PyGriffin code package, was initiated by the Nuclear Energy Advanced Modeling and Simulation (NEAMS) program in FY-2022. PyGriffin was developed as a Python wrapper to Griffin to streamline the complex workflow involving mesh, cross section, and Griffin input generation, code execution, and results postprocessing, by improving user experience with high fidelity neutronics analysis through the Workbench GUI interface. PyGriffin can be used as a standalone application or through the PyARC code suite. FY-2023 saw the continued development of PyGriffin to expand its capabilities including advanced post-processing of simulation results and initial development of the Monte Carlo (MC) cross section generation workflow with the Shift MC code. PyGriffin was also approved for open-source software status in FY-2023, initiating plans to move the code repository into an open location. In addition to PyGriffin development, there were many improvements and developments made in PyARC leading to several software releases (latest version is v2.3.0), but the focus of this report is PyGriffin.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗
DOE OSTI2022

Verification and Validation Tests of the Gamma Library of the ARC Software Package (Rev.1)

As part of the verification and validation (V&V) efforts of the Argonne Reactor Code (ARC) software system to support the Versatile Test Reactor (VTR) project of the U.S. Department of Energy (DOE), work has been performed to verify and validate the gamma (or photon) library of the multigroup cross section generation code MC 2 -3 of the ARC system, which is the essential part of the coupled neutron and gamma heating calculations to determine the heat generation rate or power distribution in the core. This V&V study was carried out in three steps: 1) review of the procedures and utility programs for generating the MC 2 -3 gamma library, 2) verification tests of cross sections and KERMA factors by comparing the total heat generation rate of coupled neutron and gamma calculation with that obtained with reaction Q values under the assumption of local gamma energy deposition and by comparing the prompt heat generation rate with that calculated with the MCNP6.2 code, and 3) validation tests of cross sections and KERMA factors by analyzing the ZPPR-15D gamma dose data measured with thermoluminescent dosimeters (TLD).

22 GENERAL STUDIES OF NUCLEAR REACTORS↗
DOE OSTI2024

Verification of the ENDF/B-VII.1 Based MC 2 -3 Library Rev.1

The MC 2 -3 code, developed by Argonne National Laboratory under the DOE-NE NEAMS program, is a multigroup cross section generation code for fast reactor applications. Last year, the ENDF/B-VII.0 (E70) MC 2 -3 library, which has been extensively used, verified, and validated over a long period, was intensively reverified and updated to support the commercial grade dedication (CGD) requirement of the TerraPower Natrium project. This year, the ENDF/B-VII.1 (E71) MC 2 -3 library, the preliminary version of which was generated several years ago, was regenerated and rigorously verified to support the Natrium project as well as the completion of verification of the E71 library. The E71 library was verified using the process developed during the verification of the E70 library, including comparisons of cross sections with the NJOY-generated cross sections, comparisons of the resolved resonance cross sections with those using the PEDNF library, and comparison of total cross sections with the sum of partial cross sections. Additional verifications were conducted to ensure that the benchmark problem solutions with the E71 library are reasonable compared to the corresponding Monte Carlo solutions. Furthermore, the E71 gamma library was generated, which includes data for prompt gamma, delayed gamma, and delayed beta as well as neutron and gamma heating. The gamma library was verified at the level of individual isotopes. The EBR-II core solutions from MC 2 -3/ DIF3D and MCNP were compared, demonstrating that those solutions in terms of k-effective and assembly powers were in good agreement.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗
DOE OSTI2024

Fiscal Year 2024 Software Quality Assurance Activities for the ARC Software

The continued goal of the ARC SQA project in the Advanced Reactor Technologies program of DOE is to resolve the QA gaps for the ARC software that limit, or prevent, commercialization of the software for industry users. This project started in earnest in fiscal year 2023 which saw the entire code system moved from a SVN repository to a GitLab repository and an associated software quality assurance plan (SQAP) developed and ratified. Most of the QA gaps in the ARC software were identified in collaboration with industry partners and work begin in fiscal year 2023 and continued in 2024. The primary documentation that is missing includes user manuals, user guides, software verification reports, and code coverage assessments. The SUMMAR manual was completed this fiscal year and work was started on creating manuals for SE2ANL, SE2RCT, and DASSH. Software verification work was carried out for DIF3D and REBUS in a previous program and the current fiscal year saw the completion of software verification reports for GAMSOR, GAMSRC, VARPOW, EvaluateFlux, and SUMMAR. The goal for the next fiscal year is to complete the PERSENT software verification work and begin planning the software verification work for DASSH, SE2ANL, and SE2RCT. The code coverage reports for DIF3D and MC2-3 were completed in the previous fiscal year and the goal is to generate code coverage reports for REBUS, GAMSOR, PERSENT, and DASSH in the coming fiscal year. A considerable amount of effort was spent in the current fiscal year working on the continuous integration capability for automated regression testing in GitLab. The first version of the testing was created in the previous fiscal year and applied to DIF3D and its utility programs. That testing was extended this year to cover GAMSOR, REBUS, and PERSENT. To accomplish this, the first version of the new testing methodology had to be updated to make a single output checking methodology viable for all of the ARC software. This will result in a single document to detail the automated regression testing methodology and minor documents to detail the tolerance settings that have been applied to the output for each ARC code. The previous methodology put into place with SVN would have required a separate document for each ARC code to detail the output checking methodology and the tolerance settings for the output from each code. Because some of our industry partners are providing funds to add new capabilities to the ARC software to meet their needs, all of which must be reviewed and approved by the SQA program funded by this project, a summary of that development work is detailed in this report. Overall progress on resolving the QA gaps has been good this year with the most impactful improvement for our industry partners in capability being the creation of a threaded version of DIF3D-VARIANT that allows the DIF3D, REBUS, and GAMSOR run times to be reduced by a factor of 4-6. The most impactful QA gap that was resolved was the software verification of GAMSRC and VARPOW.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2021

A High Performance Sparse Tensor Algebra Compiler in MLIR

Sparse tensor algebra is widely used in many applications, including scientific computing, machine learning, and data analytics. The performance of sparse tensor algebra kernels strongly depends on the intrinsic characteristics of the input tensors, hence many storage formats are designed for tensors to achieve optimal performance for particular applications/architectures, which makes it challenging to implement and optimize every tensor operation of interest on a given architecture. We propose a tensor algebra domain-specific language (DSL) and compiler framework to automatically generate kernels for mixed sparse-dense tensor algebra operations. The proposed DSL provides high-level programming abstractions that resemble the familiar Einstein notation to represent tensor algebra operations. The compiler introduces a new Sparse Tensor Algebra dialect built on top of LLVM's extensible MLIR compiler infrastructure for efficient code generation while covering a wide range of tensor storage formats. Our compiler also leverages input-dependent code optimization to enhance data locality for better performance. Our results show that the performance of automatically generated kernels outperforms the state-of-the-art sparse tensor algebra compiler, with up to 20.92x, 6.39x, and 13.9x performance improvement over state-of-the-art tensor algebra compilers, for parallel SpMV, SpMM, and TTM, respectively.

Tian, Ruiqin↗
DOE OSTI2023

Quantum error correction from complexity in Brownian SYK

We study the robustness of quantum error correction in a one-parameter ensemble of codes generated by the Brownian SYK model, where the parameter quantifies the encoding complexity. The robustness of error correction by a quantum code is upper bounded by the “mutual purity” of a certain entangled state between the code subspace and environment in the isometric extension of the error channel, where the mutual purity of a density matrix ρAB is the difference $\mathcal{F}$ p ($A : B$) ≡ $\mathrm{T}$r $p^{2}_{AB}$ - $\mathrm{T}$r $p^{2}_{A}$ $\mathrm{T}$r $p^{2}_{B}$. We show that when the encoding complexity is small, the mutual purity is O(1) for the erasure of a small number of qubits (i.e., the encoding is fragile). However, this quantity decays exponentially, becoming O(1/N) for O(log N) encoding complexity. Further, at polynomial encoding complexity, the mutual purity saturates to a plateau of O(e -N ). We also find a hierarchy of complexity scales associated to a tower of subleading contributions to the mutual purity that quantitatively, but not qualitatively, adjust our error correction bound as encoding complexity increases. In the AdS/CFT context, our results suggest that any portion of the entanglement wedge of a general boundary subregion A with sufficiently high encoding complexity is robustly protected against low-rank errors acting on A with no prior access to the encoding map. From the bulk point of view, we expect such bulk degrees of freedom to be causally inaccessible from the region A despite being encoded in it.

1/N expansion↗