SEARCH · Search NASA
Results for “computing applications”
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.
Wafer-scale TaOx device variability and implications for neuromorphic computing applications.
Abstract not provided.
A Perspective on Quantum Computing Applications in Quantum Chemistry Using 25-100 Logical Qubits
The intersection of quantum computing and quantum chemistry represents a promising frontier for achieving quantum utility in domains of both scientific and societal relevance. Owing to the exponential growth of classical resource requirements for simulating quantum systems, quantum chemistry has long been recognized as a natural candidate for quantum computation. This perspective focuses on identifying scientifically meaningful use cases where early fault-tolerant quantum computers, which are considered to be equipped with approximately 25-100 logical qubits, could deliver tangible impact. While recent advances in classical computing have pushed the boundaries of tractable simulations to unprecedented scales, this logical-qubit regime represents the first window where quantum devices can pursue qualitatively distinct strategies, such as polynomial-scaling phase estimation, direct simulation of quantum dynamics, and active-space embedding, that remain challenging for classical solvers, such as multireference charge-transfer and conical-intersection states central to photochemistry and materials design. We highlight near-term opportunities in algorithm and software design, discuss representative chemical problems suited for quantum acceleration, and propose strategic roadmaps and collaborative pathways for advancing practical quantum utility in quantum chemistry.
Toward a persistent event-streaming system for high-performance computing applications
High-performance computing (HPC) applications have traditionally relied on parallel file systems and file transfer services to manage data movement and storage. Alternative approaches have been proposed that use direct communications between application components, trading persistence and fault tolerance for speed. Event-driven architectures, as popularized in enterprise contexts, present a compelling middle ground, avoiding the performance cost and API constraints of parallel file systems while retaining persistence and offering impedance matching between application components. However, adapting streaming frameworks to HPC workloads requires addressing challenges unique to HPC systems. This paper investigates the potential for a streaming framework designed for HPC infrastructures and use cases. We introduce Mofka, a persistent event-streaming framework designed specifically for HPC environments. Mofka combines the capabilities of a traditional streaming service with optimizations tailored to the HPC context, such as support for massively multicore nodes, efficient scaling for large producer-consumer workflows, RDMA-enabled high-performance network communications, specialized network fabrics with multiple links per node, and efficient handling of large scientific data payloads. Built using the Mochi suite of HPC data service components, Mofka provides a lightweight, modular, and high-performance solution for persistent streaming in HPC systems. We present the architecture of Mofka and evaluate its performance against Kafka and Redpanda using benchmarks on diverse platforms, including Argonne's Polaris and Oak Ridge's Frontier supercomputers, showing up to 8× improvement in throughput in some scenarios. We then demonstrate its utility in several real-world applications: a tomographic reconstruction pipeline, a workflow for the discovery of metal-organic frameworks for carbon capture, and the instrumentation of Dask workflows for provenance tracking and performance analysis.
Modeling and Predicting Performance of High Performance Computing Applications on Hardware Accelerators
Computers with hardware accelerators, also referred to as hybrid-core systems, speedup applications by offloading certain compute operations that can run faster on accelerators. Thus, it is not surprising that many of top500 supercomputers use accelerators. However, in addition to procurement cost, significant programming and porting effort is required to realize the potential benefit of such accelerators. Hence, before building such a system it is prudent to answer the question 'what is the projected performance benefit from accelerators for the workloads of interest?'. We address this question by way of a performance-modeling framework that predicts realizable application performance on accelerators rapidly and accurately without going to the considerable effort of porting and tuning. The modeling framework first automatically identifies commonly found compute patterns in scientific applications which we term idioms, which may benefit by accelerator technology. Next the framework models the predicted speedup of those idioms if they were to be ported to and run on hardware accelerators. As a proof of concept we characterize two kinds of accelerators 1) the FPGA accelerators on a Convey HC-1 system and 2) an NVIDIA FERMI GPU accelerator. We model performance of the idioms gather/scatter and stream and our predictions show that where these occur in two full-scale HPC applications, Milc and HYCOM, gather/scatter speeds up by as much as 15X, and stream by as much as 14X, whereas the overall compute time of Milc improves by 3.4% and HYCOM by 20%.
The Applicability of Unit Systems to High-Performance Computing Applications
Dimensional analysis is a key technique used to verify the soundness of scientific models. Most experts agree that engineering and scientific software would be made more reliable by integrating dimensional analysis in their type system. We explored how High Performance Computing (HPC) applications could integrate compile-time dimensional analysis. We started by investigating various implementation of unit systems for C++. Eventually, selecting the latest (and most advanced) one to apply to our test codes. We worked with code of increasing complexity, from a projectile trajectory calculation to the proxy-application Lulesh. This included our code, Springs-3D, which focuses on demonstrating language features while performing simple physic computations. Finally, our main contribution is a source-code analysis which extracts constraints on the dimension of all variables, functions, and constants in an application. This resulting system of equations is solved using the dimensions of a few of these objects. This analysis has the potential to greatly reduce the time spent performing dimensional analysis when refactoring application to use a representation of units.
Auto-HPCnet: An Automatic Framework to Build Neural Network-based Surrogate for High-Performance Computing Applications
High-performance computing communities are increasingly adopt- ing Neural Networks (NN) as surrogate models in their applications to generate scientific insights. Replacing an execution phase in the application with NN models can bring significant performance im- provement. However, there is a lack of tools that can help domain scientists automatically apply NN-based surrogate models to HPC applications. We introduce a framework, named Auto-HPCnet, to democratize the usage of NN-based surrogates. Auto-HPCnet is the first end-to-end framework that makes past proposals for the NN-based surrogate model practical and disciplined. Auto-HPCnet introduces a workflow to address unique challenges when apply- ing the approximation, such as feature acquisition and meeting the application-specific constraint on the quality of final computation outcome. We show that Auto-HPCnet can leverage NN for a set of HPC applications and achieve 5.50× speedup on average (up to 16.8× speedup and with data preparation cost included) while meeting the application-specific constraint on the final computation quality.
Fundamental Superconductivity of Nb films for Quantum Computing Application
Niobium is a widely accepted material for quantum computing device as well as superconducting radio frequency (SRF) technology. Superconducting niobium is a marginal type II superconductor which has a very narrow gap (~20-30 mT) of the mixed state at 2K, even showing the intermediate state (IMS) at the early stage of magnetic vortex penetration. Tremendous progress has been made in understanding the impact of the Nb surface and bulk superconductivities on SRF resonator performance. However, the effect of thin superconducting Nb films for quantum computing applications requires further examination. In this study, we explore the fundamental superconducting properties of various thin Nb films and compare them with respect to the energy relaxation time, T1, measured from superconducting qubit fabricated with these films. The Nb films are fabricated both with or without a surface protective layer that prevents the formation of lossy Nb2O5. Electromagnetic properties are characterized by means of bulk magnetization, electromagnetic transport, and dynamics of surface superconductivity. In addition, analytical electron microscopy is implemented to further connect the superconducting properties to microstructure.
Fundamental Superconductivity of Nb films for Quantum Computing Application
Niobium is a widely accepted material for quantum computing device as well as superconducting radio frequency (SRF) technology. Superconducting niobium is a marginal type II superconductor which has a very narrow gap (~20-30 mT) of the mixed state at 2K, even showing the intermediate state (IMS) at the early stage of magnetic vortex penetration. Tremendous progress has been made in understanding the impact of the Nb surface and bulk superconductivities on SRF resonator performance. However, the effect of thin superconducting Nb films for quantum computing applications requires further examination. In this study, we explore the fundamental superconducting properties of various thin Nb films and compare them with respect to the energy relaxation time, T1, measured from superconducting qubit fabricated with these films. The Nb films are fabricated both with or without a surface protective layer that prevents the formation of lossy Nb2O5. Electromagnetic properties are characterized by means of bulk magnetization, electromagnetic transport, and dynamics of surface superconductivity. In addition, analytical electron microscopy is implemented to further connect the superconducting properties to microstructure.
Minimizing Error Potential Using Computer Applications - 18498
Many Savannah River Site (SRS) liquid waste facility operations depend upon repetitive engineering calculations and operator actions. Although these calculations and actions are formalized in technical reports and paper procedures, they can still be vulnerable to data entry errors, calculation errors, equipment alignment errors, and occasional changes caused by different people performing these activities. Savannah River Remediation (SRR) is using computer automation to reduce these error precursors by standardizing repetitive calculations and by performing plant alignment checks for repetitive operation processes. Data entry can be automated, calculation methodologies can be standardized, and computers can check to see that predefined plant conditions exist before equipment operation. In addition to improving quality, the time required for these activities to generate technical reports, to perform independent reviews, and to perform equipment alignment checks can be significantly reduced. In the case of operator-performed calculations, error precursors involve distractions that can occur over a multi-page paper procedure, confusing displays and controls from equipment, mathematical errors, complacency, and unfamiliarity with the procedure among many others. Repetitive engineering calculations suffer from similar error precursors and are often compounded by high workloads, lack of proficiency, lack of standard methodology, mental shortcuts, and biases. Web-based computer applications can eliminate many of these precursors through standardization. Calculation methods are fixed, inputs are fixed, and computer checks can highlight potentially wrong inputs and outputs. Automated calculations are performed almost instantaneously once input is provided. Operators and engineers can spend more time focusing on the results than on the process to achieve the results. Similarly, when operators use repetitive procedures involving equipment manipulation, the same error precursors apply. Automated operation sequences and equipment checks can be programmed into the distributed control system to provide standard operating processes that reduce and eliminate error precursors. This paper describes how SRR incorporates Human Performance Improvement (HPI) principles when automating calculations and operation processes. Computer applications will be reviewed in detail, highlighting the software development life-cycle that includes requirements gathering, prototyping, design, development, testing, and implementation. (authors)
Cloud object store for checkpoints of high performance computing applications using decoupling middleware
Cloud object storage is enabled for checkpoints of high performance computing applications using a middleware process. A plurality of files, such as checkpoint files, generated by a plurality of processes in a parallel computing system are stored by obtaining said plurality of files from said parallel computing system; converting said plurality of files to objects using a log structured file system middleware process; and providing said objects for storage in a cloud object storage system. The plurality of processes may run, for example, on a plurality of compute nodes. The log structured file system middleware process may be embodied, for example, as a Parallel Log-Structured File System (PLFS). The log structured file system middleware process optionally executes on a burst buffer node.
Balanced Coloring for Parallel Computing Applications
Graph coloring is used to identify subsets of independent tasks in parallel scientific computing applications. Traditional coloring heuristics aim to reduce the number of colors used as that number also corresponds to the number of parallel steps in the application. However, if the color classes produced have a skew in their sizes, utilization of hardware resources becomes inefficient, especially for the smaller color classes. Equitable coloring is a theoretical formulation of coloring that guarantees a perfect balance among color classes, and its practical relaxation is referred to as balanced coloring. In this paper, we revisit the problem of balanced coloring in the context of parallel computing. The goal is to achieve a balanced coloring of an input graph without increasing the number of colors that an algorithm oblivious to balance would have used. We propose and study multiple heuristics that aim to achieve such a balanced coloring, present parallelization approaches for multi-core and manycore architectures, and cross-evaluate their effectiveness with respect to the quality of balance achieved and performance. Furthermore, we study the impact of the proposed balanced coloring heuristics on a concrete application - viz. parallel community detection, which is an example of an irregular application. The thorough treatment of balanced coloring presented in this paper from algorithms to application is expected to serve as a valuable resource to parallel application developers who seek to improve parallel performance of their applications using coloring.
Improved Approach for Utilization of FPGA Technology into DAQ, DSP, and Computing Applications
Innovation Partners proposed and successfully demonstrated in this SBIR Phase I grant a software/hardware co-design approach to reduce both the difficulty and time to implement Field Programmable Gate Array (FPGA) solutions to data acquisition and specialized computational applications. FPGAs can require excessive time for programming and require specialized knowledge that will be greatly reduced by the company's solution. Not only are FPGAs ideal for DAQ and embedded solutions, they can also be the best solution to specialized signal processing to replace Digital Signal Processors (DSPs). By allowing FPGA programming to be done in C with the equivalent of a simple compilation, algorithm changes and improvements can be implemented decreasing the life-cycle costs and allow subsitution of new FPGA designs staying above the technological details.
Deterministic point inclusion methods for computational applications with complex geometry
A fundamental problem in computation is finding practical and efficient algorithms for determining if a query point is contained within a model of a three-dimensional solid. The solid is modeled using a general boundary representation that can contain polygonal elements and/or parametric patches.We have developed two such algorithms: the first is based on a global closest feature query, and the second is based on a local intersection query. Both algorithms work for two- and three-dimensional objects. This paper presents both algorithms, as well as the spatial data structures and queries required for efficient implementation of the algorithms. Applications for these algorithms include computational geometry, mesh generation, particle simulation, multiphysics coupling, and computer graphics. These methods are deterministic in that they do not involve random perturbations of diagnostic rays cast from the query point in order to avoid ‘unclean’ or ‘singular’ intersections of the rays with the geometry. Avoiding the necessity of such random perturbations will become increasingly important as geometries become more convoluted and complex.
PREPARING FOR EXASCALE: ORNL Leadership Computing Application Requirements and Strategy
In 2009 the Oak Ridge Leadership Computing Facility (OLCF), a U.S. Department of Energy (DOE) facility at the Oak Ridge National Laboratory (ORNL) National Center for Computational Sciences (NCCS), elicited petascale computational science requirements from leading computational scientists in the international science community. This effort targeted science teams whose projects received large computer allocation awards on OLCF systems. A clear finding of this process was that in order to reach their science goals over the next several years, multiple projects will require computational resources in excess of an order of magnitude more powerful than those currently available. Additionally, for the longer term, next-generation science will require computing platforms of exascale capability in order to reach DOE science objectives over the next decade. It is generally recognized that achieving exascale in the proposed time frame will require disruptive changes in computer hardware and software. Processor hardware will become necessarily heterogeneous and will include accelerator technologies. Software must undergo the concomitant changes needed to extract the available performance from this heterogeneous hardware. This disruption portends to be substantial, not unlike the change to the message passing paradigm in the computational science community over 20 years ago. Since technological disruptions take time to assimilate, we must aggressively embark on this course of change now, to insure that science applications and their underlying programming models are mature and ready when exascale computing arrives. This includes initiation of application readiness efforts to adapt existing codes to heterogeneous architectures, support of relevant software tools, and procurement of next-generation hardware testbeds for porting and testing codes. The 2009 OLCF requirements process identified numerous actions necessary to meet this challenge: (1) Hardware capabilities must be advanced on multiple fronts, including peak flops, node memory capacity, interconnect latency, interconnect bandwidth, and memory bandwidth. (2) Effective parallel programming interfaces must be developed to exploit the power of emerging hardware. (3) Science application teams must now begin to adapt and reformulate application codes to the new hardware and software, typified by hierarchical and disparate layers of compute, memory and concurrency. (4) Algorithm research must be realigned to exploit this hierarchy. (5) When possible, mathematical libraries must be used to encapsulate the required operations in an efficient and useful way. (6) Software tools must be developed to make the new hardware more usable. (7) Science application software must be improved to cope with the increasing complexity of computing systems. (8) Data management efforts must be readied for the larger quantities of data generated by larger, more accurate science models. Requirements elicitation, analysis, validation, and management comprise a difficult and inexact process, particularly in periods of technological change. Nonetheless, the OLCF requirements modeling process is becoming increasingly quantitative and actionable, as the process becomes more developed and mature, and the process this year has identified clear and concrete steps to be taken. This report discloses (1) the fundamental science case driving the need for the next generation of computer hardware, (2) application usage trends that illustrate the science need, (3) application performance characteristics that drive the need for increased hardware capabilities, (4) resource and process requirements that make the development and deployment of science applications on next-generation hardware successful, and (5) summary recommendations for the required next steps within the computer and computational science communities.
High-mobility 2D hole systems for quantum computing applications
One of the leading candidates for a solid-state quantum bit is the spin of a single electron confined in a semiconductor. Coherent control of individual electron spins has already been demonstrated in quantum dots in high-mobility 2D electron systems in GaAs/AlGaAs heterostructures. The major source of decoherence in such experiments is coupling between electron spins and nuclear spins in the host GaAs semiconductor. It has been proposed that hole spins in GaAs would be better suited for such experiments due to a lesser coupling between hole and nuclear spins. Building on recent successes in the growth of high-mobility 2D hole systems (2DHS) via carbon doping of (100) oriented GaAs/AlGaAs heterostructures, we have developed 2DHS at Sandia to enable experiments investigating the physics of hole spins in GaAs, looking towards eventual applications in the area of quantum computing.
High Performance Computing Application I/O Traces
The dataset comprises trace files from high performance computing (HPC) simulations. The trace files contain records of every I/O operation executed by a simulation application run, including I/O operations from HDF5, MPI-IO, and POSIX and all of the parameters supplied to those operations, e.g. file name, offset, and flags. The traces are generated by executing a simulation application that is linked with the Recorder tracing tool (https://github.com/uiuc-hpc/Recorder). The Recorder trace tool intercepts the I/O calls made by the application, records the I/O trace record, and then calls the intended I/O call so that the operation executes.
Autotuning in High-Performance Computing Applications
Autotuning refers to the automatic generation of a search space of possible implementations of a computation that are evaluated through models and/or empirical measurement to identify the most desirable implementation. Autotuning has the potential to dramatically improve the performance portability of petascale and exascale applications. To date, autotuning has been used primarily in high-performance applications through tunable libraries or previously tuned application code that is integrated directly into the application. This paper draws on the authors' extensive experience applying autotuning to high-performance applications, describing both successes and future challenges. If autotuning is to be widely used in the HPC community, researchers must address the software engineering challenges, manage configuration overheads, and continue to demonstrate significant performance gains and portability across architectures. In particular, tools that configure the application must be integrated into the application build process so that tuning can be reapplied as the application and target architectures evolve.