Search NASA⌕ Search

SEARCH · Search NASA

Results for “Runtime”

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 973 records · Page 54

Task-based Parallel Computation of the Density Matrix in Quantum-based Molecular Dynamics using Graph Partitioning

Quantum-based molecular dynamics (QMD) is a highly accurate and transferable method for material science simulations. However, the time scales and system sizes accessible to QMD are typically limited to picoseconds and a few hundred atoms. These constraints arise due to expensive self-consistent ground-state electronic structure calculations that can often scale cubically with the number of atoms. Linearly scaling methods depend on computing the density matrix P from the Hamiltonian matrix H by exploiting the sparsity in both matrices. The second-order spectral projection (SP2) algorithm is an O(N) algorithm that computes P with a sequence of 40 - 50 matrix-matrix multiplications. In this paper, we present task-based implementations of a recently developed data-parallel graph-based approach to the SP2 algorithm, G-SP2. We represent the density matrix P as an undirected graph and use graph partitioning techniques to divide the computation into smaller independent tasks. The partitions thus obtained are generally not of equal size and give rise to undesirable load imbalances in standard MPI-based implementations. This load-balancing challenge can be mitigated by dynamically scheduling parallel computations at runtime using task-based programming models. We develop task-based implementations of the data-parallel G-SP2 algorithm using both Intel's Concurrent Collections (CnC) as well as the Charm++ programming model and evaluate these implementations for future use. Scaling and performance results of our implementations are investigated for representative segments of QMD simulations for solvated protein systems containing more than 10,000 atoms.

97 MATHEMATICS AND COMPUTING↗

A Holistic Algorithmic Approach to Improving Accuracy, Robustness, and Computational Efficiency for Atmospheric Dynamics

Atmospheric weather and climate models must perform simulations very quickly to be useful. Therefore, modelers have traditionally focused on reducing computations as much as possible. However, in our new era of increasingly compute-capable hardware, data movement is now the prohibiting expense. This study examines the computational benefits of a new algorithmic approach to modeling atmospheric dynamics on scales relevant to weather and climate simulation. Rather than minimizing computations, this new approach considers the larger problem more holistically, including spatial accuracy, temporal accuracy, robustness (i.e., oscillations), on-node efficiency, and internode data transfers together at once. Numerical experiments demonstrate how computations can be strategically increased to simultaneously address each of these constraints while reducing data movement to adapt to modern accelerated hardware. The new algorithm can achieve at times up to 80% peak floating point throughput in single precision on the Nvidia Tesla V100 GPU, where the traditional approach is shown to only achieve single-digit floating point efficiency. Further, the new algorithm is twice as fast as a standard Runge--Kutta time integrator, and high-order accuracy with Weighted Essentially Non-Oscillatory (WENO) limiting came at less than 30% additional runtime cost on a GPU, thus increasing the accuracy per degree of freedom.

54 ENVIRONMENTAL SCIENCES↗

Probing for the Trace Estimation of a Permuted Matrix Inverse Corresponding to a Lattice Displacement

We report thatpProbing is a general technique that is used to reduce the variance of the Hutchinson stochastic estimator for the trace of the inverse of a large, sparse matrix A. The variance of the estimator is the sum of the squares of the off-diagonal elements of A -1 . Therefore, this technique computes probing vectors that when used in the estimator annihilate the largest off-diagonal elements. For matrices that display decay of the magnitude of |A$^{-1}_{ij}$| with the graph distance between nodes i and j, this is achieved through graph coloring of increasing powers A k . Equivalently, when a matrix stems from a lattice discretization, it is computationally beneficial to find a distance-k coloring of the lattice. Previously, a hierarchical coloring was proposed so that k can be increased at runtime as needed without discarding previous work. In this work, we study probing for the more general problem of computing the trace of a permutation of A -1 , say PA -1 . The motivation comes from lattice quantum chromodynamics (QCD), where we need to construct “disconnected diagrams” to extract flavor-separated generalized parton functions. In lattice QCD, where the matrix has a four-dimensional toroidal lattice structure, these nonlocal operators correspond to a PA -1 , where P is the permutation relating to some displacement $\vec{p}$ in one or more dimensions. We focus on a single dimension displacement (p), but our methods are general. We show that probing on A k or (PA) k does not annihilate the largest magnitude elements. To resolve this issue, our displacement-based probing works on PA k using a new coloring scheme that works directly on appropriately displaced neighborhoods on the lattice. We prove lower bounds on the number of colors needed and study the effect of this scheme on variance reduction, both theoretically and experimentally on a real-world lattice QCD calculation. We achieve orders of magnitude speedup over the unprobed or the naively probed methods.

97 MATHEMATICS AND COMPUTING↗

Additive Polynomial Time Integrators, Part I: Framework and Fully Implicit-Explicit Collocation Methods

In this paper we generalize the polynomial time integration framework to additively partitioned initial value problems. The framework we present is general and enables the construction of many new families of additive integrators with arbitrary order-of-accuracy and varying degree of implicitness. In this first work, we focus on a new class of implicit-explicit polynomial block methods that are based on fully implicit Runge–Kutta methods with Radau nodes and that possess high stage order. Here, we show that the new fully implicit-explicit (FIMEX) integrators have improved stability compared to existing IMEX Runge–Kutta methods, while also being more computationally efficient due to recent developments in preconditioning techniques for solving the associated systems of nonlinear equations. For PDEs on periodic domains where the implicit component is trivial to invert, we will show how parallelization of the right-hand side evaluations can be exploited to obtain significant speedup compared to existing serial IMEX Runge–Kutta methods. For parallel (in space) finite element discretizations, the new methods can achieve orders of magnitude better accuracy than existing IMEX Runge–Kutta methods and/or achieve a given accuracy several times times faster in terms of computational runtime.

97 MATHEMATICS AND COMPUTING↗

Beyond standard model calculations with Sherpa

We present a fully automated framework as part of the Sherpa event generator for the computation of tree-level cross sections in beyond Standard Model scenarios, making use of model information given in the Universal FeynRules Output format. Elementary vertices are implemented into C++ code automatically and provided to the matrix-element generator Comix at runtime. Widths and branching ratios for unstable particles are computed from the same building blocks. The corresponding decays are simulated with spin correlations. Parton showers, QED radiation and hadronization are added by Sherpa, providing a full simulation of arbitrary BSM processes at the hadron level.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗

Accelerating $\mathrm{LHC}$ event generation with simplified pilot runs and fast $\mathrm{PDF}$s

Poor computing efficiency of precision event generators for LHC physics has become a bottleneck for Monte-Carlo event simulation campaigns. We provide solutions to this problem by focusing on two major components of general-purpose event generators: The PDF evaluator and the matrix-element generator. For a typical production setup in the ATLAS experiment, we show that the two can consume about 80% of the total runtime. Using NLO simulations of pp→ℓ + ℓ - +jets and pp→$t\bar{t}$+jets as an example, we demonstrate that the computing footprint of LHAPDF and SHERPA can be reduced by factors of order 10, while maintaining the formal accuracy of the event sample. The improved codes are made publicly available.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗

Benchmarking for AI for Science

AI has been instrumental for recent developments in a number of domains of the sciences. With several hundred machine learning (ML) algorithms and models, and numerous AI-specific hardware platforms, a common quest for all scientists working on AI for Science is around the selection of machine learning algorithm(s) to solve their domain-specific scientific problems. A number of different initiatives around AI Benchmarking have been set up and have been useful in understanding the benefits of different ML algorithms for different tasks.However, with the majority of these AI Benchmarking initiatives focusing on the conventional notions of benchmarking, where the focus is purely runtime performance (such as training time or inference time), their suitability for benchmarking different ML algorithms for solving scientific problems has been viewed as a performance problem even though both are hardly the same. To make reasonable, explainable, and justifiable advancements in science using AI, it is critical to focus on the merits of these algorithms in handling different domain science problems. In other words, more emphasis must be given on Benchmarking for AI for Science than AI Benchmarking. The vision of the former is not only to assess the performance of ML algorithms, but also to assess, and understand the benefits and merits of different ML algorithms in handling scientific problems. Benchmarking for AI for Science, instead of pure performance focused AI Benchmarking, has several benefits: (i) it has the potential to offer advances in the sciences, much more rapidly than through pure performance-based AI methods, (ii) it will encourage the community to focus on developing better domain-specific AI techniques, particularly given the provision for being able to benchmark different techniques, and (iii) it will encourage hardware manufacturers to focus on developing science-specific hardware subsystems.

Thiyagalingam, Jeyan↗

Parrallel Implementation of Fast Randomized Algorithms for Low Rank Matrix Decomposition

We analyze the parallel performance of randomized interpolative decomposition by de- composing low rank complex-valued Gaussian random matrices larger than 100 GB. We chose a Cray XMT supercomputer as it provides an almost ideal PRAM model permitting quick investigation of parallel algorithms without obfuscation from hardware idiosyncrasies. We obtain that on non-square matrices performance scales almost linearly with runtime about 100 times faster on 128 processors. We also verify that numerically discovered error bounds still hold on matrices two orders of magnitude larger than those previously tested.

Lucas, Andrew J.↗

Parametric Multi-Level Tiling of Imperfectly Nested Loops

Tiling is a critical loop transformation for generating high-performance code on modern architectures. Efficient generation of multilevel tiled code is essential to exploit several levels of parallelism and/or to maximize data reuse in deep memory hierarchies. Tiled loops with parameterized tile sizes (not compile time constants) facilitate runtime feedback and dynamic optimizations used in iterative compilation and automatic tuning. The existing parametric multilevel tiling approach has focused on transformation for perfectly nested loops, where all assignment statements are contained inside the innermost loop of a loop nest. Previous solutions to tiling for imperfect loop nests are limited to the case where tile sizes are fixed. In this paper, we present an approach to parameterized multilevel tiling for imperfectly nested loops. Our tiling algorithm generates loops that iterate over full rectangular tiles that are amenable for potential compiler optimizations such as register tiling. Experimental results using a number of computational benchmarks demonstrate the effectiveness of our tiling approach.

97 MATHEMATICS AND COMPUTING↗

Fault Oblivious eXascale Whitepaper

In this paper we present a software system which supports dynamic, irregular, adaptive applications. Data objects are created and structured in a hierarchical manner, with replication as needed to provide a high degree of redundancy. The data objects can contain data, code, tasks (work descriptors with references to data, code, and other tasks) and higher level structures such as work queues. The higher level structures benefit from the properties of the data objects: redundant storage to support resiliency in the face of hardware failure; hierarchical structure to optimize use of the HPC system; and a presence of object names, available in the per-user file system name space, which allows any application, not just specially written HPC applications, to make use of the data even while it is on the HPC system. Our use of hierarchy will make the runtime scalable to very large systems. Our use of redundancy will allow programs to be written in a fault-oblivious manner, eliminating the need for system-level checkpointing. Putting data object names into the file system name space allows for interactive use of the system by users. With this approach, we will be able to finally leave the batch era behind, a half-century after the invention of time sharing. We will be able to stop bounding program through- put by the checkpoint interval. Application data will be accessible at any time, not hidden behind opaque 128-bit pointers or MPI ranks, but given a name that is visible everywhere. Programmers can stop laying out data, and thinking about where the data is, and the code is, and the nodes are, and stick with the problem of what the application is supposed to be doing. This work, if it succeeds, will enable scientific computing to scale to the next generation of machines.

99 GENERAL AND MISCELLANEOUS↗

An Evaluation of the Network Simulators in Large-Scale Distributed Simulations

This is a survey paper about the state-of-the-art in large-scale network simulation. Networks for the smart grids are characterized by millions of sensor nodes exchanging information about the status of the grid. This information exchange must be realized reliably and efficiently due to the mission critical nature of the power grid. Hence, the applications and the network protocols developed for the smart grid need go through rigorous testing and analysis before deployment. Developers usually do not have access to such a large-scale network that can be used as a controlled test-bed; therefore, network simulation becomes an essential tool for testing. Network simulation is a well studied problem in the literature and there are various widely used network simulators. These simulators can be adopted for testing applications and protocols of the smart grid. Due to the scale of these networks, parallel/distributed simulations need to be conducted. Even though most network simulators support distributed simulations, generating a large-scale network model to simulate can still be a cumbersome task. In this survey, we describe a selection of commonly used network simulators and evaluate them with respect to the following features that can aid users in distributed simulations of large-scale networks: transparency of setting up distributed simulation, automated topology generation, information hiding, lightweight routing protocols, network error simulation, evaluation of the network model during simulation and trace analysis tools. As a complementary result, we identify two issues with network simulators that can be addressed with runtime steering methods.

99 GENERAL AND MISCELLANEOUS↗

Exploiting Points-to Maps for De-/Serialization Code Generation

Serialization code generators for C++ have restrictions on the implementation of dynamic arrays and void/function pointers. If the target program is not implemented with these restrictions, de- velopers have to manually change the source code to facilitate se- rialization code generation. Unfortunately, such changes hamper the benefits of code generation, and they are not localized. This pa- per presents the de-/serialization code generator Ser++ that does not restrict the implementation of these pointer types and, hence, eliminates the need to adapt the source code for serialization code generation. Ser++ can be considered an aspect weaver that i) traces the pointers, ii) identifies the statements in which properties regard- ing the serialization of pointer attributes can be extracted and, finally, iii) weaves the code to store these properties at runtime. It generates the de-/serialization functions in such a way that they serialize the pointer attributes according to the stored values of the properties. We have successfully used Ser++ to generate de- /serialization methods for a computer architecture and a power- flow simulator, without any modifications to the existing source code.

Serialization↗

Steal Tree: Low-Overhead Tracing of Work Stealing Schedulers

Work stealing is a popular approach to scheduling task-parallel programs. The flexibility inherent in work stealing when dealing with load imbalance results in seemingly irregular computation structures, complicating the study of its runtime behavior. In this paper, we present an approach to efficiently trace async-finish parallel programs scheduled using work stealing. We identify key properties that allow us to trace the execution of tasks with low time and space overheads. We also study the usefulness of the proposed schemes in supporting algorithms for data-race detection and retentive steal- ing presented in the literature. We demonstrate that the perturbation due to tracing is within the variation in the execution time with 99% confidence and the traces are concise, amounting to a few tens of kilobytes per thread in most cases. We also demonstrate that the traces enable significant reductions in the cost of detecting data races and result in low, stable space overheads in supporting retentive stealing for async-finish programs.

async-finish parallelism↗

Using cross-layer adaptations for dynamic data management in large scale coupled scientific workflows, In: SC '13 Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis

As system scales and application complexity grow, managing and processing simulation data has become a significant challenge. While recent approaches based on data staging and in-situ/in-transit data processing are promising, dynamic data volumes and distributions, such as those occurring in AMR-based simulations, make the efficient use of these techniques challenging. In this paper we propose cross-layer adaptations that address these challenges and respond at runtime to dynamic data management requirements. Specifically we explore (1) adaptations of the spatial resolution at which the data is processed, (2) dynamic placement and scheduling of data processing kernels, and (3) dynamic allocation of in-transit resources. We also exploit coordinated approaches that dynamically combine these adaptations at the different layers. We evaluate the performance of our adaptive cross-layer management approach on the Intrepid IBM-BlueGene/P and Titan Cray-XK7 systems using Chombo-based AMR applications, and demonstrate its effectiveness in improving overall time-to-solution and increasing resource efficiency.

Computer Science↗

Clover: Compiler directed lightweight soft error resilience

This paper presents Clover, a compiler directed soft error detection and recovery scheme for lightweight soft error resilience. The compiler carefully generates soft error tolerant code based on idem-potent processing without explicit checkpoint. During program execution, Clover relies on a small number of acoustic wave detectors deployed in the processor to identify soft errors by sensing the wave made by a particle strike. To cope with DUE (detected unrecoverable errors) caused by the sensing latency of error detection, Clover leverages a novel selective instruction duplication technique called tail-DMR (dual modular redundancy). Once a soft error is detected by either the sensor or the tail-DMR, Clover takes care of the error as in the case of exception handling. To recover from the error, Clover simply redirects program control to the beginning of the code region where the error is detected. Lastly, the experiment results demonstrate that the average runtime overhead is only 26%, which is a 75% reduction compared to that of the state-of-the-art soft error resilience technique.

97 MATHEMATICS AND COMPUTING↗

Evaluation of PGAS communication paradigms with geometric multigrid

Partitioned Global Address Space (PGAS) languages and one-sided communication enable application developers to select the communication paradigm that balances the performance needs of applications with the productivity desires of programmers. In this paper, we evaluate three different one-sided communication paradigms in the context of geometric multigrid using the miniGMG benchmark. Although miniGMG's static, regular,and predictable communication does not exploit the ultimate potential of PGAS models, multigrid solvers appear in many contemporary applications and represent one of the most important communication patterns. We use UPC++, a PGAS extension of C++, as the vehicle for our evaluation, though our work is applicable to any of the existing PGAS languages and models. We compare performance with the highly tuned MPI baseline, and the results indicate that the most promising approach towards achieving performance and ease of programming is to use high-level abstractions, such as the multidimensional arrays provided by UPC++, that hide data aggregation and messaging in the runtime library.

Shan, H↗

Trace-Driven Memory Access Pattern Recognition in Computational Kernels. In: WOSC '14 Proceedings of the Second Workshop on Optimizing Stencil Computations

Classifying memory access patterns is paramount to the selection of the right set of optimizations and determination of the parallelization strategy. Static analyses suffer from ambiguities present in source code, which modern compilation techniques, such as profile-guided optimization, alleviate by observing runtime behavior and feeding back into the compilation flow. This paper discusses a dynamic analysis technique for recognizing memory access patterns, with application to the stencils domain, and presents our design and C++ implementation using the memory-tracing tool Gleipnir. Finally, we evaluate and discuss the performance and matching capability of our classifiers in the context of the Polybench scientific benchmark suite, which includes both stencil and matrix computations.

Park, Eunjung↗

Diagnosing the Causes and Severity of One-sided Message Contention

Two trends suggest network contention for one-sided messages is poised to become a performance problem that concerns application developers: an increased interest in one-sided programming models and a rising ratio of hardware threads to network injection bandwidth. Unfortunately, it is difficult to reason about network contention and one-sided messages because one-sided tasks can either decrease or increase contention. We present effective and portable techniques for diagnosing the causes and severity of one-sided message contention. To detect that a message is affected by contention, we maintain statistics representing instantaneous (non-local) network resource demand. Using lightweight measurement and modeling, we identify the portion of a message's latency that is due to contention and whether contention occurs at the initiator or target. We attribute these metrics to program statements in their full static and dynamic context. We characterize contention for an important computational chemistry benchmark on InfiniBand, Cray Aries, and IBM Blue Gene/Q interconnects. We pinpoint the sources of contention, estimate their severity, and show that when message delivery time deviates from an ideal model, there are other messages contending for the same network links. With a small change to the benchmark, we reduce contention up to 50% and improve total runtime as much as 20%.

Network Contention, Performance Analysis, Dynamic ↗