Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “compiler”

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 703 records · Page 39
All sourcesNASA NTRSDOE OSTI
DOE OSTI2017

Establishing Malware Attribution and Binary Provenance Using Multicompilation Techniques

Malware is a serious problem for computer systems and costs businesses and customers billions of dollars a year in addition to compromising their private information. Detecting malware is particularly difficult because malware source code can be compiled in many different ways and generate many different digital signatures, which causes problems for most anti-malware programs that rely on static signature detection. Our project uses a convolutional neural network to identify malware programs but these require large amounts of data to be effective. Towards that end, we gather thousands of source code files from publicly available programming contest sites and compile them with several different compilers and flags. Building upon current research, we then transform these binary files into image representations and use them to train a long-term recurrent convolutional neural network that will eventually be used to identify how a malware binary was compiled. This information will include the compiler, version of the compiler and the options used in compilation, information which can be critical in determining where a malware program came from and even who authored it.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2020

CCAMP: OpenMP and OpenACC Interoperable Framework

Heterogeneous systems have become a staple of the HPC environment. Several directive-based solutions, such as OpenMP and OpenACC, have been developed to alleviate the challenges of programming heterogeneous systems, and these standards strive to provide a single portable programming solution across heterogeneous environments. However, in many ways this goal has yet to be realized due to device-specific implementations and different levels of language support across compilers. In this framework we aim to analyze and address the different levels of optimization and compatibility between OpenACC and OpenMP programs and device compilers. We introduce the CCAMP framework, built on the OpenARC compiler, which implements language translation between OpenACC and OpenMP, with the goal of exploiting the maturity of different device-specific compilers to maximize performance for a given architecture. We show that CCAMP allows us to generate code for a specific device-compiler combination given a device-agnostic OpenMP or OpenACC program, allowing compilation and execution of programs with specific directives on otherwise incompatible devices. CCAMP also provides a starting point for a more advanced interoperable framework that can effectively provide directive translation and device, compiler, and application specific optimizations.

Lambert, Jacob↗
DOE OSTI2018

The OpenACC data model: Preliminary study on its major challenges and implementations

This paper describes how the OpenACC data model is implemented in current OpenACC compilers, ranging from research compilers (OpenUH and OpenARC) to a commercial compiler (the PGI OpenACC compiler). First, we summarize various memory architectures in today’s accelerator systems. We then describe details and issues in implementing the OpenACC data model in three different OpenACC compilers. This includes managing page tables, asynchronous data transfers, asynchronous memory allocate and free, host data construct, aliasing on a data directive, reusing device memory, partially present data, and adjacent data. We also discusses ongoing work to manage large, complex dynamic data structures. We measured the present table lookups, device memory allocation, pinned memory allocation, and managed memory in the three OpenACC compilers using eight OpenACC applications (seven from the SPEC ACCEL benchmark suite and a shock-hydrodynamics mini-application called LULESH).

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2017

Effective Vectorization with OpenMP 4.5

This paper describes how the Single Instruction Multiple Data (SIMD) model and its extensions in OpenMP work, and how these are implemented in different compilers. Modern processors are highly parallel computational machines which often include multiple processors capable of executing several instructions in parallel. Understanding SIMD and executing instructions in parallel allows the processor to achieve higher performance without increasing the power required to run it. SIMD instructions can significantly reduce the runtime of code by executing a single operation on large groups of data. The SIMD model is so integral to the processor s potential performance that, if SIMD is not utilized, less than half of the processor is ever actually used. Unfortunately, using SIMD instructions is a challenge in higher level languages because most programming languages do not have a way to describe them. Most compilers are capable of vectorizing code by using the SIMD instructions, but there are many code features important for SIMD vectorization that the compiler cannot determine at compile time. OpenMP attempts to solve this by extending the C++/C and Fortran programming languages with compiler directives that express SIMD parallelism. OpenMP is used to pass hints to the compiler about the code to be executed in SIMD. This is a key resource for making optimized code, but it does not change whether or not the code can use SIMD operations. However, in many cases critical functions are limited by a poor understanding of how SIMD instructions are actually implemented, as SIMD can be implemented through vector instructions or simultaneous multi-threading (SMT). We have found that it is often the case that code cannot be vectorized, or is vectorized poorly, because the programmer does not have sufficient knowledge of how SIMD instructions work.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2024

A Full-Stack Exploration of Language-Based Parallelism in Fortran 2023

This poster explores native parallel features in Fortran 2023 through the lens of supporting applications with libraries, compilers, and parallel runtimes. The language revision informally named Fortran 2008 introduced parallelism in the form of Single Program Multiple Data (SPMD) execution with two broad feature sets: (1) loop-level parallelism via do concurrent and (2) a Partitioned Global Address Space (PGAS) comprised of distributed “coarray” data structures. Fortran’s native parallelism has demonstrated high performance [1] and reduced the burden of inserting what sometimes amounts to more directives than code. Several compilers support both feature sets, typically by translating do concurrent into serial do loops annotated by parallel directives and by translating SPMD/PGAS features into direct calls to a communication library. Our research focuses primarily on two questions: (1) can the compiler’s parallel runtime library be developed in the language being compiled (Fortran) and (2) can we define an interface to the runtime that liberates compilers from being hardwired to one runtime and vice versa. We are answering these questions by developing the Parallel Runtime Interface for Fortran (PRIF) [2] and the Co-Array Fortran Framework of Efficient Interfaces to Network Environments (Caffeine) [3]. Caffeine is initially targeting adoption by LLVM Flang, a new open-source Fortran compiler developed by a broad community in industry, academia, and government labs. We are also exploring the use of these features in Inference-Engine, a deep learning library designed to facilitate neural network training and inference for high-performance computing applications written in modern Fortran.

Rasmussen, Katherine↗
NASA NTRS1992

Automatic data partitioning on distributed memory multicomputers

Distributed-memory parallel computers are increasingly being used to provide high levels of performance for scientific applications. Unfortunately, such machines are not very easy to program. A number of research efforts seek to alleviate this problem by developing compilers that take over the task of generating communication. The communication overheads and the extent of parallelism exploited in the resulting target program are determined largely by the manner in which data is partitioned across different processors of the machine. Most of the compilers provide no assistance to the programmer in the crucial task of determining a good data partitioning scheme. A novel approach is presented, the constraints-based approach, to the problem of automatic data partitioning for numeric programs. In this approach, the compiler identifies some desirable requirements on the distribution of various arrays being referenced in each statement, based on performance considerations. These desirable requirements are referred to as constraints. For each constraint, the compiler determines a quality measure that captures its importance with respect to the performance of the program. The quality measure is obtained through static performance estimation, without actually generating the target data-parallel program with explicit communication. Each data distribution decision is taken by combining all the relevant constraints. The compiler attempts to resolve any conflicts between constraints such that the overall execution time of the parallel program is minimized. This approach has been implemented as part of a compiler called Paradigm, that accepts Fortran 77 programs, and specifies the partitioning scheme to be used for each array in the program. We have obtained results on some programs taken from the Linpack and Eispack libraries, and the Perfect Benchmarks. These results are quite promising, and demonstrate the feasibility of automatic data partitioning for a significant class of scientific application programs with regular computations.

Gupta, Manish↗
DOE OSTI2013

Performing aggressive code optimization with an ability to rollback changes made by the aggressive optimizations

Mechanisms for aggressively optimizing computer code are provided. With these mechanisms, a compiler determines an optimization to apply to a portion of source code and determines if the optimization as applied to the portion of source code will result in unsafe optimized code that introduces a new source of exceptions being generated by the optimized code. In response to a determination that the optimization is an unsafe optimization, the compiler generates an aggressively compiled code version, in which the unsafe optimization is applied, and a conservatively compiled code version in which the unsafe optimization is not applied. The compiler stores both versions and provides them for execution. Mechanisms are provided for switching between these versions during execution in the event of a failure of the aggressively compiled code version. Moreover, predictive mechanisms are provided for predicting whether such a failure is likely.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2026

Evaluation of LLVM Flang for Production HPC Applications and Modern Fortran Features

In 2025, LLVM released its first Flang Fortran compiler version considered ready for widespread evaluation. We know of no published assessment of Flang compiling a workload- derived portfolio of high-performance computing (HPC) applications. We address this gap using workload data from the National Energy Research Scientific Computing Center (NERSC), which supports more than 10,000 scientists on approximately 1,000 projects. The NERSC workload analyses identify many Fortran components in heavily used applications. We selected 10 such packages with available source code. We compiled them with Flang 22.1.3 on NERSC’s Perlmutter system. Six compiled without code modifications, though some required build-system changes. Three compiled after minor source edits, mostly to address Fortran standard violations. One built only without OpenMP enabled. We evaluated seven additional packages selected for their use of, or enablement of, standard Fortran parallel features: multi-image execution and do concurrent. Six such codes compiled with most or all unit tests passing.

Rasmussen, Katherine↗
DOE OSTI1991

Nuclear Safety [Vol. 32, No. 1, January-March 1991]

Nuclear Safety is a review journal that covers significant developments in the field of nuclear safety. Its scope includes the analysis and control of hazards associated with nuclear energy, operations involving fissionable materials, and the products of nuclear fission and their effects on the environment. Primary emphasis is on safety in reactor design, construction, and operation; however, the safety aspects of the entire fuel cycle, including fuel fabrication, spent-fuel processing, nuclear waste disposal, handling of radioisotopes, and environmental effects of these operations, are also treated. Table of Contents for this issue follows. GENERAL SAFETY CONSIDERATIONS: 1 The Safety Review and Approval Process for Space Nuclear Power Sources, G. L. Bennett; 19 Report on the American Nuclear Society International Topical Meeting: "The Safety, Status, and Future of Non-Commercial Reactors and Irradiation Facilities", E. G. Silver; 35 Book Review: Fission Product Transport Processes in Reactor Accidents, Proceedings to the International Centre tor Heat and Mass Processes T. S. Kress; 38 Fast Reactor Technology in the 1990s: A Summary of the 1990 International Fast Reactor Safety Meeting, A. E. Levin; ACCIDENT ANALYSIS: 56 Effects of Chemical Phenomena on LWR Severe Accident Fission Product Behavior, A. P. Malinauskas and T. S. Kress; CONTROL AND INSTRUMENTATION: 65 Technical Note: Safety Parameter Display Systems—10 Years Later, R. J. Eckenrode; 68 Potential Application of Neural Networks to the Operation of Nuclear Power Plants, R. E. Uhrig; DESIGN FEATURES: 80 Twenty-First DOE/NRC Nuclear Air-Cleaning Conference, R. R. Bellamy, D. W. Moeller, and M. W. First; 91 Impact of an Apparent Radiation Embrittlement Rate on the Life Expectancy of PWR Vessel Supports, R. D. Cheverton, G. C. Robinson, W. E. Pennell, and R. K. Nanstad; ENVIRONMENTAL EFFECTS: 103 Technical Note: The Impact of Offsite Factors on the Safety Performance of Small Nuclear Power Plants, Yu. D. Baranaev and A. N. Viktorov; WASTE AND SPENT FUEL MANAGEMENT: 109 Activities Related to Waste Management, Compiled by E. G. Silver; OPERATING EXPERIENCES: 118 Reactor Shutdown Experience, Compiled by J. W. Cletcher; 121 Selected Safety-Related Events, Compiled by G. A. Murphy; 123 Operating U.S. Power Reactors, Compiled by E. G. Silver; RECENT DEVELOPMENTS: 140 General Administrative Activities, Compiled by E. G. Silver; 150 Reports, Standards, and Safety Guides, D. S. Queener; 155 Status of Power-Reactor Licensing Activities, Compiled by E. G. Silver; 157 Proposed Rule Changes as of Sept. 30, 1990; ANNOUNCEMENTS: 79 MIT Offers Summer Program on Nuclear Power Reactor Safety; 108 Harvard School of Public Health Offers Several Short Courses; 139 Short Course and Workshop on Nuclear Criticality Safety at University of New Mexico; 160 SCK/CEN Announces Training Course on Emergency Planning and Response; 161 The Authors; 164 Indexes to Nuclear Safety, Volume 31

11 NUCLEAR FUEL CYCLE AND FUEL MATERIALS↗
DOE OSTI2019

Performance Exploration Through Optimistic Static Program Annotations

Compilers are limited by the static information directly or indirectly encoded in the program. Low-level languages, such as C/C++, are considered problematic as their weak type system and relaxed memory semantic allows for various, sometimes non-obvious, behaviors. Since compilers have to preserve the program semantics for all program executions, the existence of exceptional behavior can prevent optimizations that the developer would consider valid and might expect. Analyses to guarantee the absence of disruptive and unlikely situations are consequently an indispensable part of an optimizing compiler. However, such analyses have to be approximative and limited in scope as global and exact solutions are infeasible for any non-trivial program. In this paper, we present an automated tool to measure the effectmissing static information has on the optimizations applied to a given program. The approach generates an optimistically optimized program version which, compared to the original, defines a performance gap that can be closed by better compiler analyses and selective static program annotations. Our evaluation on six already tuned proxy applications for high-performance codes shows speedups of up to 20.6%. This clearly indicates that static uncertainty limits performance. At the same time, we observed that compilers are often unable to utilize additional static information. Thus, manual annotation of all correct static information is therefore not only error prone but also mostly redundant.

Auto Tuning↗
DOE OSTI2014

Experimental cross sections for L-shell x-ray production and ionization by protons

Tables of compiled cross sections list data for production of individual line and total L x-rays as well as for ionization of L subshells and the total L shell. The present cumulative compilation covers some six decades of measurements on targets from {sub 10}Ne to {sub 95}Am bombarded by protons ranging from 10 keV to 1 GeV. It includes data published in the period 1954–1992 from tables published in this journal, cross sections that were not reported in those tables, and new data from works published after 1992. Existing empirical, semiempirical, and theoretical analyses based on, and relative to, the pre-1993 database are reviewed. The experimental details are summarized for pre-1993 articles that were not referenced in previous compilations and, continuing the practice of these compilations, for each new publication. Covering the period 1954–December 2012, the present tabulation collects (not counting 2519 new data for L{sub β1,3,4}, L{sub β2,15},L{sub γ1}, L{sub γ2,3}, and L{sub γ4,4{sup ′}} x ray production) circa 15 500 experimental cross sections and enlarges the database from the previously published tables by 94%. -- Highlights: •An updated database is presented, increasing by 94% the earlier pre-1993 database. •The update has 40% more data from the pre-1993 period, absent in prior compilations. •The growth and possible saturation in the number of data is illustrated. •Ionization cross sections are reconverted to x-ray production cross sections. •Elements and ion energies are identified where measurements are still necessary.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗
DOE OSTI2017

The HITRAN2016 molecular spectroscopic database

This paper describes the contents of the 2016 edition of the HITRAN molecular spectroscopic compilation. The new edition replaces the previous HITRAN edition of 2012 and its updates during the intervening years. The HITRAN molecular absorption compilation is comprised of five major components: the traditional line-by-line spectroscopic parameters required for high-resolution radiative-transfer codes, infrared absorption cross-sections for molecules not yet amenable to representation in a line-by-line form, collision-induced absorption data, aerosol indices of refraction, and general tables such as partition sums that apply globally to the data. The new HITRAN is greatly extended in terms of accuracy, spectral coverage, additional absorption phenomena, added line-shape formalisms, and validity. Moreover, molecules, isotopologues, and perturbing gases have been added that address the issues of atmospheres beyond the Earth. Of considerable note, experimental IR cross-sections for almost 200 additional significant molecules have been added to the database.

Gordon, I. E.↗
DOE OSTI2016

OpenACC to FPGA: A Framework for Directive-based High-Performance Reconfigurable Computing

This paper presents a directive-based, high-level programming framework for high-performance reconfigurable computing. It takes a standard, portable OpenACC C program as input and generates a hardware configuration file for execution on FPGAs. We implemented this prototype system using our open-source OpenARC compiler; it performs source-to-source translation and optimization of the input OpenACC program into an OpenCL code, which is further compiled into a FPGA program by the backend Altera Offline OpenCL compiler. Internally, the design of OpenARC uses a high- level intermediate representation that separates concerns of program representation from underlying architectures, which facilitates portability of OpenARC. In fact, this design allowed us to create the OpenACC-to-FPGA translation framework with minimal extensions to our existing system. In addition, we show that our proposed FPGA-specific compiler optimizations and novel OpenACC pragma extensions assist the compiler in generating more efficient FPGA hardware configuration files. Our empirical evaluation on an Altera Stratix V FPGA with eight OpenACC benchmarks demonstrate the benefits of our strategy. To demonstrate the portability of OpenARC, we show results for the same benchmarks executing on other heterogeneous platforms, including NVIDIA GPUs, AMD GPUs, and Intel Xeon Phis. This initial evidence helps support the goal of using a directive-based, high-level programming strategy for performance portability across heterogeneous HPC architectures.

Lee, Seyong↗
DOE OSTI2017

Snowflake: A Lightweight Portable Stencil DSL

Stencil computations are not well optimized by general-purpose production compilers and the increased use of multicore, manycore, and accelerator-based systems makes the optimization problem even more challenging. In this paper we present Snowflake, a Domain Specific Language (DSL) for stencils that uses a 'micro-compiler' approach, i.e., small, focused, domain-specific code generators. The approach is similar to that used in image processing stencils, but Snowflake handles the much more complex stencils that arise in scientific computing, including complex boundary conditions, higher-order operators (larger stencils), higher dimensions, variable coefficients, non-unit-stride iteration spaces, and multiple input or output meshes. Snowflake is embedded in the Python language, allowing it to interoperate with popular scientific tools like SciPy and iPython; it also takes advantage of built-in Python libraries for powerful dependence analysis as part of a just-in-time compiler. We demonstrate the power of the Snowflake language and the micro-compiler approach with a complex scientific benchmark, HPGMG, that exercises the generality of stencil support in Snowflake. By generating OpenMP comparable to, and OpenCL within a factor of 2x of hand-optimized HPGMG, Snowflake demonstrates that a micro-compiler can support diverse processor architectures and is performance-competitive whilst preserving a high-level Python implementation.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2017

Completeness and coverage of open-access freshwater fish distribution data in the United States

Aim: Primary biodiversity data constitute observations of particular species at given points in space and time. Open-access databases provide unprecedented access to these data, but their utility depends on how complete species inventories are at a given surveying resolution and how uniformly distributed surveys are in space and time. Our aim was to characterize the completeness of freshwater fish data across spatial scales and among habitat types (lotic stream reaches and lentic waterbodies), and assess coverage bias in space and time. Location: Freshwater habitats of the contiguous United States. Methods: We compiled fish occurrence records from the Global Biodiversity Information Facility (GBIF), the Multi-state Aquatic Resources Information Server (MARIS), and three federally-administered surveys (EMAP, NAQWA, NRS). Next, we evaluated survey completeness across seven spatial resolutions representing nested stream catchments, and separately for lotic and lentic habitats. Lastly, we tested for bias in survey coverage along environmental and temporal gradients for each habitat type. Results: A total of 39,855,157 records representing 1925 species were available from 1800 to 2014. The percent of catchments surveyed increased as spatial resolution decreased while the density of occurrence records within surveyed catchments decreased. Species richness also increased with catchment size consistent with putative species–area relationships. Occurrence records were distributed among 72,114 lotic reaches and 3,325 lentic waterbodies throughout the contiguous US. Seven percent (N=5,055) of surveyed lotic reaches and 23% (N=771) of surveyed lentic waterbodies were well-surveyed based on the most conservative thresholds for two completeness indices. Most well-surveyed lotic reaches (95%) and undammed lentic waterbodies (97%) were completed since 1980, and most were surveyed during only one 20-year time interval (83% and 56% for lotic and lentic waterbodies, respectively). Coverage analyses indicated that contemporary and future climates corresponding to regions along the west coast and gulf coast are the most under-represented for both lotic and lentic habitats. Small lentic waterbodies (surface area < 0.1 km2) are also under-represented. Main Conclusions: Contemporary surveys of lotic reaches and, to a lesser extent, lentic waterbodies are plentiful and generally representative of climatic and landscape characteristics. Data compilation efforts should focus on adding historical data to public repositories. Clustering of well-surveyed waterbodies in MARIS-participating states highlights the value of state-agency data and demonstrates the need for dissemination of these data by more state agencies.

60 APPLIED LIFE SCIENCES↗
DOE OSTI2016

TU-AB-BRC-12: Optimized Parallel MonteCarlo Dose Calculations for Secondary MU Checks

Purpose: Secondary MU checks are an important tool used during a physics review of a treatment plan. Commercial software packages offer varying degrees of theoretical dose calculation accuracy, depending on the modality involved. Dose calculations of VMAT plans are especially prone to error due to the large approximations involved. Monte Carlo (MC) methods are not commonly used due to their long run times. We investigated two methods to increase the computational efficiency of MC dose simulations with the BEAMnrc code. Distributed computing resources, along with optimized code compilation, will allow for accurate and efficient VMAT dose calculations. Methods: The BEAMnrc package was installed on a high performance computing cluster accessible to our clinic. MATLAB and PYTHON scripts were developed to convert a clinical VMAT DICOM plan into BEAMnrc input files. The BEAMnrc installation was optimized by running the VMAT simulations through profiling tools which indicated the behavior of the constituent routines in the code, e.g. the bremsstrahlung splitting routine, and the specified random number generator. This information aided in determining the most efficient compiling parallel configuration for the specific CPU’s available on our cluster, resulting in the fastest VMAT simulation times. Our method was evaluated with calculations involving 10{sup 8} – 10{sup 9} particle histories which are sufficient to verify patient dose using VMAT. Results: Parallelization allowed the calculation of patient dose on the order of 10 – 15 hours with 100 parallel jobs. Due to the compiler optimization process, further speed increases of 23% were achieved when compared with the open-source compiler BEAMnrc packages. Conclusion: Analysis of the BEAMnrc code allowed us to optimize the compiler configuration for VMAT dose calculations. In future work, the optimized MC code, in conjunction with the parallel processing capabilities of BEAMnrc, will be applied to provide accurate and efficient secondary MU checks.

60 APPLIED LIFE SCIENCES↗
DOE OSTI2023

QuComm: Optimizing Collective Communication for Distributed Quantum Computing

Distributed quantum computing (DQC) is a scalable way to build a large-scale quantum computing system while the error-prone nonlocal communication between DQC nodes may heavily degrade the fidelity of the distributed quantum program and thus demands specific compiler optimizations. Previous compilers on DQC communication optimization either assumes unlimited communication resource or a few communication qubits due to the hardware limitation. The former compilers may not be efficient when interfacing with communication-resource-constrained DQC hardware while the latter compilers lose the opportunities of optimizing collective communication and routing concurrent communication as they unnecessarily couple limited communication qubits with the implementation of expensive inter-node operations. In this paper, we invent the communication buffer, a communication facility consisting of idle qubits in each compute node, to decouple the execution of inter-node quantum operations from communication qubits: communication qubits are devoted to generating inter-node entanglement while internode operations are conducted in the communication buffer. The communication buffer provides an intermediate layer for inter-node communication and paves the way for collective communication optimization. We then propose QuComm, a buffer-based compiler framework that first performs smart buffer allocation according to communication characteristics of the distributed quantum program and then optimizes and collectively routes inter-node quantum operations. Experimental results on a hierarchical DQC system show that the proposed QuComm can reduce the most expensive inter-node communication request and the latency of various distributed quantum programs by 50.4% and 47.6% on average, respectively.

Wu, Anbang↗
DOE OSTI2018

Concepts and Meta-Programming Library

CAMP provides a portable optimized implementation of template meta-programming primitives. All capabilities found within are available in other open source projects, including metal and mpl among others, but no other library we know of supports all compilers required by LLNL codes. CAMP serves as an efficient facility for writing portable compile-time operations in C++ codes. It was developed as part of the RAJA project to facilitate more complex compile-time introspection and better error message delivery to users, but has since proven useful in Umpire, CHAI and other pre-release LLNL software projects and is thus being re-factored to stand alone. The CAMP library uses portable C++ template mechanisms almost exclusively, with the exception of intrinsics provided for performance by some compilers such as clang and gee. There are no private or protected interfaces and no proprietary information included in the source. Any and all future versions will limit themselves to implementing commonly available and well known primitives for compile-time manipulation of types. A new public github repository will be created to host the code independent of its current location in the raja repository, likely at github.com/llnl/camp.

Kunen, AdamJ.↗