Search NASA⌕ Search

SEARCH · Search NASA

Results for “compilers”

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 1,099 records · Page 61

Octahedral rotation patterns in strained EuFeO 3 and other Pbnm perovskite films: Implications for hybrid improper ferroelectricity

Here, we report the relationship between epitaxial strain and the crystallographic orientation of the in-phase rotation axis and A -site displacements in Pbnm-type perovskite films. Synchrotron diffraction measurements of EuFeO 3 films under strain states ranging from 2% compressive to 0.9% tensile on cubic or rhombohedral substrates exhibit a combination of a - a + c - and a + a - c - rotational patterns. We compare the EuFeO 3 behavior with previously reported experimental and theoretical work on strained Pbnm-type films on nonorthorhombic substrates, as well as additional measurements from LaGaO 3 , LaFeO 3 , and Eu 0.7 Sr 0.3 MnO 3 films on SrTiO 3 . Compiling the results from various material systems reveals a general strain dependence in which compressive strain strongly favors a - a + c - and a + a - c - rotation patterns and tensile strain weakly favors a - a - c + structures. In contrast, EuFeO 3 films grown on Pbnm-type GdScO 3 under 2.3% tensile strain take on a uniform a - a + c - rotation pattern imprinted from the substrate, despite strain considerations that favor the a - a - c + pattern. Our results point to the use of substrate imprinting as a more robust route than strain for tuning the crystallographic orientations of the octahedral rotations and A -site displacements needed to realize rotation-induced hybrid improper ferroelectricity in oxide heterostructures.

75 CONDENSED MATTER PHYSICS, SUPERCONDUCTIVITY AND↗

Experimental study of the {sup 11,12}B(n,{gamma}) reactions and their influence on r-process nucleosynthesis of light elements

We have studied the neutron-transfer reactions {sup 11,12}B(d,p){sup 12,13}B in inverse kinematics to obtain information about the neutron-capture reactions {sup 11,12}B(n,{gamma}). These capture reactions are suggested to play a role in seeding r-process nucleosynthesis through the production of light, neutron-rich nuclei. The neutron spectroscopic factors of the states in {sup 12,13}B were deduced and the branching ratio of the neutron-unbound state at E{sub X}=3.389 MeV in {sup 12}B was obtained to provide the ratio of partial widths, {Gamma}{sub n}/{Gamma}{sub {gamma}}. The reaction rates for {sup 11,12}B(n,{gamma}) are estimated for direct captures and resonant captures and compared with previous compilations. The astrophysical implications, especially for neutrino-driven wind models in core-collapse supernovae, are discussed in the r-process network framework using our updated reaction rates.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

Current data are consistent with flat spatial hypersurfaces in the Λ CDM cosmological model but favor more lensing than the model predicts

Here, we study the performance of three pairs of tilted, and a pair of untilited, ΛCDM cosmological models, with three of these four pairs allowing for non-flat spatial hypersurfaces, against cosmic microwave background (CMB) temperature and polarization power spectrum data (P18), measurements of the Planck 2018 lensing potential power spectrum (lensing), and a large compilation of non-CMB data (non-CMB). For the eight models, we measure cosmological parameters and study whether or not pairs of the data sets (as well as subsets of them) are mutually consistent in these models. Half of these models allow the lensing consistency parameter A L , which re-scales the gravitational potential power spectrum, to be an additional free parameter to be determined from data, while the other three have A L = 1 which is the theoretically expected value. The pair of untilted non-flat ΛCDM models are incompatible with P18 data. The tilted spatially-flat models assume the usual primordial spatial inhomogeneity power spectrum that is a power law in wave number. The tilted non-flat models assume either the primordial power spectrum used in the Planck group anal yses [Planck P(q)], that has recently been numerically shown to be a good approximation to what is quantum-mechanically generated from a particular choice of closed inflation model initial conditions, or a recently computed power spectrum [new P(q)] that quantum-mechanically follows from a different set of non-flat inflation model initial conditions. In the tilted non-flat models with A L = 1 we find differences between P18 data and non-CMB data cosmological parameter constraints, which are large enough to rule out the Planck P(q) model at 3σ but not the new P(q) model. No significant differences are found when cosmological parameter constraints obtained with two different data sets are compared within the standard tilted flat ΛCDM model. While both P18 data and non-CMB data separately favor a closed geometry, with spatial curvature density parameter Ω k < 0, when P18+non-CMB data are jointly analyzed the evidence in favor of non-flat hypersurfaces subsides. Differences between P18 data and non-CMB data cosmological constraints subside when A L is allowed to vary. From the most restrictive P18+lensing+non-CMB data combination we get almost model-independent constraints on the cosmological parameters and find that the A L > 1 option is preferred over the Ω k < 0 one, with the A L parameter, for all models, being larger than unity by ~ 2.5σ. According to the deviance information criterion, in the P18+lensing+non-CMB analysis, the varying A L option is on the verge of being strongly favored over the A L = 1 one, which could indicate a problem for the standard tilted flat ΛCDM model. These data are consistent with flat spatial hypersurfaces but more and better data could improve the constraints on Ω k and might alter this conclusion. Error bars on some cosmological parameters are significantly reduced when non-CMB data are used jointly with P18+lensing data. For example, in the tilted flat ΛCDM model for P18+lensing+non-CMB data the Hubble constant H 0 = 68.09 ± 0.38 km s -1 Mpc -1 , which is consistent with that from a median statistics analysis of a large compilation of H 0 measurements as well as with a number of local measurements of the cosmological expansion rate. This H 0 error bar is 31% smaller than that from P18+lensing data alone.

79 ASTRONOMY AND ASTROPHYSICS↗

Dark Energy Survey year 1 results: Constraints on extended cosmological models from galaxy clustering and weak lensing

We present constraints on extensions of the minimal cosmological models dominated by dark matter and dark energy, Lambda CDM and wCDM, by using a combined analysis of galaxy clustering and weak gravitational lensing from the first-year data of the Dark Energy Survey (DES Y1) in combination with external data. We consider four extensions of the minimal dark energy-dominated scenarios: (1) nonzero curvature Omega(k), (2) number of relativistic species N-eff different from the standard value of 3.046, (3) time-varying equation-of-state of dark energy described by the parameters w(0) and w(a) (alternatively quoted by the values at the pivot redshift, w(p), and w(a)), and (4) modified gravity described by the parameters is mu(0) and Sigma(0) that modify the metric potentials. We also consider external information from Planck cosmic microwave background measurements; baryon acoustic oscillation measurements from SDSS, 6dF, and BOSS; redshift-space distortion measurements from BOSS; and type Ia supernova information from the Pantheon compilation of datasets. Constraints on curvature and the number of relativistic species are dominated by the external data; when these are combined with DES Y1, we find Omega(k) = 0.0020(-0.0032)(+0.0037) at the 68% confidence level, and the upper limit N-eff < 3.28(3.55) at 68% (95%) confidence, assuming a hard prior N-eff > 3.0. For the time-varying equation-of-state, we find the pivot value (w(p), w(a)) = (-0.91(-0.23)(+0.19), -0.57(-1.11)(+0.93)) at pivot redshift z(p )= 0.27 from DES alone, and (w(p), w(a)) = (-1.01(-0.04)(+0.04), -0.28(-0.48)(+0.37)) at z(p) = 0.20 from DES Y1 combined with external data; in either case we find no evidence for the temporal variation of the equation of state. For modified gravity, we find the present-day value of the relevant parameters to be Sigma(0) = 0.43(-)(0.29)(+0.28) from DES Y1 alone, and (Sigma(0), mu(0)) = (0.06(-0.07)(+0.08), -0.11(-0.46)(+0.42)) from DES Y1 combined with external data. These modified-gravity constraints are consistent with predictions from general relativity.

Abbott, T. M. C.↗

Direct Randomized Benchmarking for Multiqubit Devices

Benchmarking methods that can be adapted to multiqubit systems are essential for assessing the overall or “holistic” performance of nascent quantum processors. The current industry standard is Clifford randomized benchmarking (RB), which measures a single error rate that quantifies overall performance. But, scaling Clifford RB to many qubits is surprisingly hard. It has only been performed on one, two, and three qubits as of this writing. This reflects a fundamental inefficiency in Clifford RB: the n-qubit Clifford gates at its core have to be compiled into large circuits over the one- and two-qubit gates native to a device. As n grows, the quality of these Clifford gates quickly degrades, making Clifford RB impractical at relatively low n. In this Letter, we propose a direct RB protocol that mostly avoids compiling. Instead, it uses random circuits over the native gates in a device, which are seeded by an initial layer of Clifford-like randomization. We demonstrate this protocol experimentally on two to five qubits using the publicly available ibmqx5. We believe this to be the greatest number of qubits holistically benchmarked, and this was achieved on a freely available device without any special tuning up. Our protocol retains the simplicity and convenient properties of Clifford RB: it estimates an error rate from an exponential decay. But, it can be extended to processors with more qubits—we present simulations on 10+ qubits—and it reports a more directly informative and flexible error rate than the one reported by Clifford RB. Here, we show how to use this flexibility to measure separate error rates for distinct sets of gates, and we use this method to estimate the average error rate of a set of cnot gates.

71 CLASSICAL AND QUANTUM MECHANICS, GENERAL PHYSIC↗

iotbx.cif : a comprehensive CIF toolbox

iotbx.cif is a new software module for the development of applications that make use of the CIF format. Comprehensive tools are provided for input, output and validation of CIFs, as well as for interconversion with high-level cctbx [Grosse-Kunstleve, Sauter, Moriarty & Adams (2002). J. Appl. Cryst. 35, 126–136] crystallographic objects. The interface to the library is written in Python, whilst parsing is carried out using a compiled parser, combining the performance of a compiled language (C++) with the benefits of using an interpreted language.

37 INORGANIC, ORGANIC, PHYSICAL, AND ANALYTICAL CH↗

Accelerating semantic graph databases on commodity clusters

We are developing a full software system for accelerating semantic graph databases on commodity cluster that scales to hundreds of nodes while maintaining constant query throughput. Our framework comprises a SPARQL to C++ compiler, a library of parallel graph methods and a custom multithreaded runtime layer, which provides a Partitioned Global Address Space (PGAS) programming model with fork/join parallelism and automatic load balancing over a commodity clusters. We present preliminary results for the compiler and for the runtime.

commodity clusters↗

AXI4MLIR: User-Driven Automatic Host Code Generation for Custom AXI-Based Accelerators

Tensor algebra operations represent an important class of algorithms used across many applications, including machine learning, scientific computing, and data analytics. As a result, the efficient generation of custom accelerators for tensor operations has received increased attention. Previous efforts have produced automated tools enabling users to prototype and explore optimized accelerators. However, little effort has been focused on the host-accelerator interaction in these tools. Efficient use of hardware accelerators requires knowledge about the accelerator's capabilities (operations, data formats, and opcode support), the host CPU microarchitecture (e.g., memory hierarchy), the host-accelerator interface, and the application's features (which code regions should be mapped onto an accelerator). Manually rewriting the original applications to facilitate improved custom accelerator mapping is an error-prone and time-consuming endeavor. To cope with this, we propose AXI4MLIR, a new framework to automatically generate and optimize the communication between the host CPU and arbitrary accelerators that implement linear algebra algorithms. AXI4MLIR extends the MLIR compiler framework to automatically generate efficient host-accelerator driver code for accelerators with AXI-based interfaces. Our compiler extensions enable automatic driver code generation while carefully considering the host's memory hierarchy and target accelerator features. To demonstrate the flexibility and utility of AXI4MLIR, we test it with diverse use cases that include different types of accelerators, tiling scenarios, and dataflow schemes. We compare our experimental results to manual implementations of host-accelerator driver code and find that our approach can reduce CPU cache references by 56% and deliver up to a 1.65x speedup.

Bohm Agostini, Nicolas↗

Invited: Bambu: an Open-Source Research Framework for the High-Level Synthesis of Complex Applications

This paper presents the open-source High-Level Synthesis research framework Bambu. The framework provides an open-source starting point to experiment with new ideas across High-Level Synthesis, high-level verification and debugging, FPGA/ASIC design, design flow space exploration, and parallel hardware accelerator design. The tool accepts as input standard C/C++ specifications and compiler intermediate representations (IRs) coming from the well-known Clang/LLVM and GCC com- pilers. The broad spectrum and flexibility of input formats allow the electronic design automation (EDA) research community to explore and integrate new transformations and optimizations. The easily extendable modular framework already includes many op- timizations and HLS benchmarks. The integration with synthesis and verification backends (commercial and open-source) allows researchers to quickly test any new finding and easily obtain performance and resource usage metrics for a given application. Different FPGA devices are supported from several different vendors: AMD/XILINX, Intel/Altera, Lattice Semiconductor, and NanoXplore. Finally, integration with the OpenRoad open-source end-to-end silicon compiler perfectly fits with the recent push towards open-source EDA.

Ferrandi, Fabrizio↗

PRESAGE: Protecting Structured Address Generation against Soft Errors

Modern computer scaling trends in pursuit of larger component counts and power efficiency have, unfortunately, lead to less reliable hardware and consequently soft errors escaping into application data ("silent data corruptions"). Techniques to enhance system resilience hinge on the availability of efficient error detectors that have high detection rates, low false positive rates, and lower computational overhead. Unfortunately, efficient detectors to detect faults during address generation (to index large arrays) have not been widely researched. We present a novel lightweight compiler-driven technique called PRESAGE for detecting bit-flips affecting structured address computations. A key insight underlying PRESAGE is that any address computation scheme that flows an already incurred error is better than a scheme that corrupts one particular array access but otherwise (falsely) appears to compute perfectly. Enabling the flow of errors allows one to situate detectors at loop exit points, and helps turn silent corruptions into easily detectable error situations. Our experiments using PolyBench benchmark suite indicate that PRESAGE-based error detectors have a high error-detection rate while incurring low overheads.

Sharma, Vishal C.↗

Automated Generation of Integrated Digital and Spiking Neuromorphic Machine Learning Accelerators

The growing numbers of application areas for artificial intelligence (AI) methods have led to an explosion of domain-specific accelerators that could support every new machine learning (ML) algorithm advancement, clearly highlighting the need for a capability to quickly and automatically transition from algorithm definition to hardware implementation and explore design space along a variety of SWaP (size, weight and Power). The software defined architectures (SODA) synthesizer implements a compiler-based modular infrastructure for the end-to-end generation of machine learning accelerators from high-level frameworks to hardware description language. At the same time, neuromorphic computing, by mimicking how the brain operates, promises to perform artificial intelligence tasks at efficiencies orders of magnitude higher than the current conventional tensor-processing based accelerators, as demonstrated by a variety of specialized designs leveraging Spiking Neural Networks (SNNs). Nevertheless, the mapping of an artificial neural network (ANN) to solutions supporting SNNs is still a non-trivial and very device-specific task, and completely lack the possibility to design hybrid systems that integrate conventional and spiking neural models. In this paper we discuss the support for such an integrated generation leveraging the SODA Synthesizer framework and its modular structure. In particular, we present a new MLIR dialect (part of the SODA frontend) that allows expressing spiking neural network features (e.g., available resources, spiking sequences, analog signal reading, etc.) and illustrate how it enables mapping to Spiking Neurons and deployment to the related specialized hardware (which, in the digital domain, could be generated through the other existing layers of the SODA Synthesizer). We then discuss the opportunities for even deeper integration afforded by the hardware compilation infrastructure, providing a path towards the generation of complex heterogeneous artificial intelligence systems.

Curzel, Serena↗

HERCULES: Strong Patterns towards More Intelligent Predictive Modeling, In: 2014 43rd International Conference on Parallel Processing

Recent work has shown that program analysis techniques to select meaningful code features of programs are important in the task of deciding the best compiler optimizations. Although, there are many successful state-of-the-art program analysis techniques, they often do not provide a simple method to extract the most expressive information about loops, especially when a target program is computationally intensive with complex loops and data dependencies. In this paper, we introduce a static technique to characterize a program using a pattern-driven system named HERCULES. This characterization technique not only helps a user to understand programs by searching pattern-of-interests, but also can be used for a predictive model that effectively selects the proper compiler optimizations. We formulated 35 loop patterns, then evaluated our characterization technique by comparing the predictive models constructed using HERCULES to three other state-of-the-art characterization methods. We show that our models outperform three state-of-the-art program characterization techniques on two multicore systems in selecting the best optimization combination from a given loop transformation space. We achieved up to 67% of the best possible speedup achievable with the optimization search space we evaluated.

Computer Science↗

Computing with a Chemical Reservoir

Contemporary computation is expensive, with large language models and artificial intelligence becoming more common in daily life. However, high-performance computing is reaching the limits in speed and energy expenditure, and domain science requires ever-increasing computational capacity, with simulations and data analysis pipelines ever-growing in complexity. As we progress towards post-exascale computation, with the associated high energy costs, new methods of energy-conscious computation are required. Novel analog and hybrid digital-analog systems can overcome these challenges, and chemical reactions offer a promising avenue. Computers based on chemistry can provide compact desktop devices with immense computational power. These devices are readily scalable by considering greater reaction systems or vessels, meeting the high-performance requirements for scientific workflows. In this article, we present ChemComp, a compilation pipeline for the conversion of ordinary differential equations into implementable chemical reactions. We then demonstrate the solving capabilities of ChemComp by emulating a potential chemical reservoir device. We leverage the multi-layer intermediate representation (MLIR) compiler framework to implement an expressive chemical reaction abstraction and propose a path for chemical reaction networks (CRNs) to represent mathematical problems effectively. Combined, we demonstrate a potential workflow that can harness chemistry’s computing power to create energy-efficient, high-performance computation systems for contemporary computing needs.

artificial intelligence↗

Characterization of In-Use Medium Duty Electric Vehicle Driving and Charging Behavior: Preprint

The U.S. Department of Energy's American Recovery and Reinvestment Act (ARRA) deployment and demonstration projects are helping to commercialize technologies for all-electric vehicles (EVs). Under the ARRA program, data from Smith Electric and Navistar medium duty EVs have been collected, compiled, and analyzed in an effort to quantify the impacts of these new technologies. Over a period of three years, the National Renewable Energy Laboratory (NREL) has compiled data from over 250 Smith Newton EVs for a total of over 100,000 days of in-use operation. Similarly, data have been collected from over 100 Navistar eStar vehicles, with over 15,000 operating days having been analyzed. NREL has analyzed a combined total of over 4 million kilometers of driving and 1 million hours of charging data for commercial operating medium duty EVs. In this paper, the authors present an overview of medium duty EV operating and charging behavior based on in-use data collected from both Smith and Navistar vehicles operating in the United States. Specifically, this paper provides an introduction to the specifications and configurations of the vehicles examined; discusses the approach and methodology of data collection and analysis, and presents detailed results regarding daily driving and charging behavior. In addition, trends observed over the course of multiple years of data collection are examined, and conclusions are drawn about early deployment behavior and ongoing adjustments due to new and improving technology. Results and metrics such as average daily driving distance, route aggressiveness, charging frequency, and liter per kilometer diesel equivalent fuel consumption are documented and discussed.

25 ENERGY STORAGE↗

Scout: high-performance heterogeneous computing made simple

Researchers must often write their own simulation and analysis software. During this process they simultaneously confront both computational and scientific problems. Current strategies for aiding the generation of performance-oriented programs do not abstract the software development from the science. Furthermore, the problem is becoming increasingly complex and pressing with the continued development of many-core and heterogeneous (CPU-GPU) architectures. To acbieve high performance, scientists must expertly navigate both software and hardware. Co-design between computer scientists and research scientists can alleviate but not solve this problem. The science community requires better tools for developing, optimizing, and future-proofing codes, allowing scientists to focus on their research while still achieving high computational performance. Scout is a parallel programming language and extensible compiler framework targeting heterogeneous architectures. It provides the abstraction required to buffer scientists from the constantly-shifting details of hardware while still realizing higb-performance by encapsulating software and hardware optimization within a compiler framework.

97 MATHEMATICS AND COMPUTING↗

Automatic Offloading C++ Expression Templates to CUDA Enabled GPUs

In the last few years, many scientific applications have been developed for powerful graphics processing units (GPUs) and have achieved remarkable speedups. This success can be partially attributed to high performance host callable GPU library routines that are offloaded to GPUs at runtime. These library routines are based on C/C++-like programming toolkits such as CUDA from NVIDIA and have the same calling signatures as their CPU counterparts. Recently, with the sufficient support of C++ templates from CUDA, the emergence of template libraries have enabled further advancement in code reusability and rapid software development for GPUs. However, Expression Templates (ET), which have been very popular for implementing data parallel scientific software for host CPUs because of their intuitive and mathematics-like syntax, have been underutilized by GPU development libraries. The lack of ET usage is caused by the difficulty of offloading expression templates from hosts to GPUs due to the inability to pass instantiated expressions to GPU kernels as well as the absence of the exact form of the expressions for the templates at the time of coding. This paper presents a general approach that enables automatic offloading of C++ expression templates to CUDA enabled GPUs by using the C++ metaprogramming technique and Just-In-Time (JIT) compilation methodology to generate and compile CUDA kernels for corresponding expression templates followed by executing the kernels with appropriate arguments. This approach allows developers to port applications to run on GPUs with virtually no code modifications. More specifically, this paper uses a large ET based data parallel physics library called QDP++ as an example to illustrate many aspects of the approach to offload expression templates automatically and to demonstrate very good speedups for typical QDP++ applications running on GPUs against running on CPUs using this method of offloading. In addition, this approach of automatic offlo- ding expression templates could be applied to other many-core accelerators that provide C++ programming toolkits with the support of C++ template.

97 MATHEMATICS AND COMPUTING↗

Towards Resiliency Evaluation of Vector Programs

The systems resilience research community has developed methods to manually insert additional source-program level assertions to trap errors, and also devised tools to conduct fault injection studies for scalar program codes. In this work, we contribute the first vector oriented LLVM-level fault injector VULFI to help study the effects of faults in vector architectures that are of growing importance, especially for vectorizing loops. Using VULFI, we conduct a resiliency study of nine real-world vector benchmarks using Intel’s AVX and SSE extensions as the target vector instruction sets, and offer the first reported understanding of how faults affect vector instruction sets. We take this work further toward automating the insertion of resilience assertions during compilation. This is based on our observation that during intermediate (e.g., LLVM-level) code generation to handle full and partial vectorization, modern compilers exploit (and explicate in their code-documentation) critical invariants. These invariants are turned into error-checking code. We confirm the efficacy of these automatically inserted low-overhead error detectors for vectorized for-loops.

fault injection↗

Integer Sum Reduction with OpenMP on an AMD MI100 GPU

Sum reduction is a primitive operation in parallel computing. Device offload support allows a user to use OpenMP directives to take advantage of a highly capable GPU. In this paper, we present the integer sum reduction annotated with the OpenMP directives and evaluate the performance impacts of tunable parameters with the AOMP and GCC compilers on an AMD MI100 GPU. In addition, we explain the implementations of the OpenMP reduction by the compilers. Sweeping over the pruned parameter space, we find that the speedup is approximately 20 with AOMP, and the reduction performance using AOMP is approximately 11% higher than that using GCC. However, the OpenMP offload performance is approximately 30% lower compared to the performance of the reductions written with rocThrust or hipCUB.

Jin, Zheming↗