Search NASA⌕ Search

SEARCH · Search NASA

Results for “Programming Model”

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,279 records · Page 71

Value-of-Information based Middleware for Autonomic Querying of Distributed Sensor Databases

With particular focus on distributed situational awareness in defense and security applications, we propose a value-of-information based middleware framework as a paradigm shift from crawl-index based centralized search. The proposed approach seeks to improve efficiency in search and retrieval by transforming sensors into programmable information points and enabling ubiquitous data and software flows through the infrastructure of the distributed network. We explain the different components of such a middleware framework to organize, tag and notify emerging spatial, temporal and causal patterns from the sensor measurements. We conclude the paper with a brief discussion on the top-down programming model that can realize the framework as a reconfigurable sensor query system.

Sukumar, Sreenivas R.↗

Coordinate-Space Hartree-Fock-Bogoliubov Solvers for Superfluid Fermi Systems in Large Boxes

The self-consistent Hartree-Fock-Bogoliubov problem in large boxes can be solved accurately in the coordinate space with the recently developed solvers HFB-AX (2D) and MADNESS-HFB (3D). This is essential for the description of superfluid Fermi systems with complicated topologies and significant spatial extend, such as fissioning nuclei, weakly-bound nuclei, nuclear matter in the neutron star rust, and ultracold Fermi atoms in elongated traps. The HFB-AX solver based on B-spline techniques uses a hybrid MPI and OpenMP programming model for parallel computation for distributed parallel computation, within a node multi-threaded LAPACK and BLAS libraries are used to further enable parallel calculations of large eigensystems. The MADNESS-HFB solver uses a novel multi-resolution analysis based adaptive pseudo-spectral techniques to enable fully parallel 3D calculations of very large systems. In this work we present benchmark results for HFB-AX and MADNESS-HFB on ultracold trapped fermions.

Pei, J. C.↗

MARIANE: MApReduce Implementation Adapted for HPC Environments

MapReduce is increasingly becoming a popular framework, and a potent programming model. The most popular open source implementation of MapReduce, Hadoop, is based on the Hadoop Distributed File System (HDFS). However, as HDFS is not POSIX compliant, it cannot be fully leveraged by applications running on a majority of existing HPC environments such as Teragrid and NERSC. These HPC environments typicallysupport globally shared file systems such as NFS and GPFS. On such resourceful HPC infrastructures, the use of Hadoop not only creates compatibility issues, but also affects overall performance due to the added overhead of the HDFS. This paper not only presents a MapReduce implementation directly suitable for HPC environments, but also exposes the design choices for better performance gains in those settings. By leveraging inherent distributed file systems' functions, and abstracting them away from its MapReduce framework, MARIANE (MApReduce Implementation Adapted for HPC Environments) not only allows for the use of the model in an expanding number of HPCenvironments, but also allows for better performance in such settings. This paper shows the applicability and high performance of the MapReduce paradigm through MARIANE, an implementation designed for clustered and shared-disk file systems and as such not dedicated to a specific MapReduce solution. The paper identifies the components and trade-offs necessary for this model, and quantifies the performance gains exhibited by our approach in distributed environments over Apache Hadoop in a data intensive setting, on the Magellan testbed at the National Energy Research Scientific Computing Center (NERSC).

97 MATHEMATICS AND COMPUTING↗

Optimizing Blocking and Nonblocking Reduction Operations for Multicore Systems: Hierarchical Design and Implementation

Many scientific simulations, using the Message Passing Interface (MPI) programming model, are sensitive to the performance and scalability of reduction collective operations such as MPI Allreduce and MPI Reduce. These operations are the most widely used abstractions to perform mathematical operations over all processes that are part of the simulation. In this work, we propose a hierarchical design to implement the reduction operations on multicore systems. This design aims to improve the efficiency of reductions by 1) tailoring the algorithms and customizing the implementations for various communication mechanisms in the system 2) providing the ability to configure the depth of hierarchy to match the system architecture, and 3) providing the ability to independently progress each of this hierarchy. Using this design, we implement MPI Allreduce and MPI Reduce operations (and its nonblocking variants MPI Iallreduce and MPI Ireduce) for all message sizes, and evaluate on multiple architectures including InfiniBand and Cray XT5. We leverage and enhance our existing infrastructure, Cheetah, which is a framework for implementing hierarchical collective operations to implement these reductions. The experimental results show that the Cheetah reduction operations outperform the production-grade MPI implementations such as Open MPI default, Cray MPI, and MVAPICH2, demonstrating its efficiency, flexibility and portability. On Infini- Band systems, with a microbenchmark, a 512-process Cheetah nonblocking Allreduce and Reduce achieves a speedup of 23x and 10x, respectively, compared to the default Open MPI reductions. The blocking variants of the reduction operations also show similar performance benefits. A 512-process nonblocking Cheetah Allreduce achieves a speedup of 3x, compared to the default MVAPICH2 Allreduce implementation. On a Cray XT5 system, a 6144-process Cheetah Allreduce outperforms the Cray MPI by 145%. The evaluation with an application kernel, Conjugate Gradient solver, shows that the Cheetah reductions speeds up total time to solution by 195%, demonstrating the potential benefits for scientific simulations.

Gorentla Venkata, Manjunath↗

Adaptive Sampling Proxy Application

ASPA is an implementation of an adaptive sampling algorithm [1-3], which is used to reduce the computational expense of computer simulations that couple disparate physical scales. The purpose of ASPA is to encapsulate the algorithms required for adaptive sampling independently from any specific application, so that alternative algorithms and programming models for exascale computers can be investigated more easily.

Dorr, M.↗

Highly Asynchronous VisitOr Queue Graph Toolkit

HAVOQGT is a C++ framework that can be used to create highly parallel graph traversal algorithms. The framework stores the graph and algorithmic data structures on external memory that is typically mapped to high performance locally attached NAND FLASH arrays. The framework supports a vertex-centered visitor programming model. The frameworkd has been used to implement breadth first search, connected components, and single source shortest path.

Pearce, R.↗

MiniAero

MiniAero is an MPl+X proxy app for gas dynamics problems. MiniAero can be used as a representative limited gas dynamics application to assess future computer architectures and programming models

Ken Franko, Micah Howard↗

Universal Common Communication Substrate (UCCS) Specification; Universal Common Communication Substrate (UCCS) Implementation

Universal Common Communication Substrate (UCCS) is a low-level communication substrate that exposes high-performance communication primitives, while providing network interoperability. It is intended to support multiple upper layer protocol (ULPs) or programming models including SHMEM,UPC,Titanium,Co-Array Fortran,Global Arrays,MPI,GASNet, and File I/O. it provides various communication operations including one-sided and two-sided point-to-point, collectives, and remote atomic operations. In addition to operations for ULPs, it provides an out-of-band communication channel required typically required to wire-up communication libraries.

Source record↗

RAJA - LLNL HPC Architecture Portability Encapsulation Layer Version 1.0

RAJA is a collection of C++ software abstractions designed to make HPC applications portable across a range of hardware architectures and programming models. The main conceptual abstraction in FAJA is a loop. RAJA provides abstractions for types, loop execution and scheduling, and loop iteration space portioning and ordering cooperate to insulate algorithms in application code that domain experts write from implementations details of those algorithms that may need to depend on the underlying computer hardware for high performance.

Hornung, Richard↗

Heterogenous Acceleration for Linear Algebra in Multi-coprocessor Environments

We present an efficient and scalable programming model for the development of linear algebra in heterogeneous multi-coprocessor environments. The model incorporates some of the current best design and implementation practices for the heterogeneous acceleration of dense linear algebra (DLA). Examples are given as the basis for solving linear systems' algorithms - the LU, QR, and Cholesky factorizations. To generate the extreme level of parallelism needed for the efficient use of coprocessors, algorithms of interest are redesigned and then split into well-chosen computational tasks. The tasks execution is scheduled over the computational components of a hybrid system of multi-core CPUs and coprocessors using a light-weight runtime system. The use of lightweight runtime systems keeps scheduling overhead low, while enabling the expression of parallelism through otherwise sequential code. This simplifies the development efforts and allows the exploration of the unique strengths of the various hardware components.

Luszczek, Piotr R↗

Optimal Voltage Regulation for Unbalanced Distribution Networks Considering Distributed Energy Resources

With increasing penetration of distributed generation in the distribution networks (DN), the secure and optimal operation of DN has become an important concern. In this paper, an iterative quadratic constrained quadratic programming model to minimize voltage deviations and maximize distributed energy resource (DER) active power output in a three phase unbalanced distribution system is developed. The optimization model is based on the linearized sensitivity coefficients between controlled variables (e.g., node voltages) and control variables (e.g., real and reactive power injections of DERs). To avoid the oscillation of solution when it is close to the optimum, a golden search method is introduced to control the step size. Numerical simulations on modified IEEE 13 nodes test feeders show the efficiency of the proposed model. Compared to the results solved by heuristic search (harmony algorithm), the proposed model converges quickly to the global optimum.

distributed energy resources↗

Advanced Energy Storage Management in Distribution Network

With increasing penetration of distributed generation (DG) in the distribution networks (DN), the secure and optimal operation of DN has become an important concern. In this paper, an iterative mixed integer quadratic constrained quadratic programming model to optimize the operation of a three phase unbalanced distribution system with high penetration of Photovoltaic (PV) panels, DG and energy storage (ES) is developed. The proposed model minimizes not only the operating cost, including fuel cost and purchasing cost, but also voltage deviations and power loss. The optimization model is based on the linearized sensitivity coefficients between state variables (e.g., node voltages) and control variables (e.g., real and reactive power injections of DG and ES). To avoid slow convergence when close to the optimum, a golden search method is introduced to control the step size and accelerate the convergence. The proposed algorithm is demonstrated on modified IEEE 13 nodes test feeders with multiple PV panels, DG and ES. Numerical simulation results validate the proposed algorithm. Various scenarios of system configuration are studied and some critical findings are concluded.

linearization↗

Quicksilver

Quicksilver is proxy application for the Monte Carlo Transport code, Mercury. The purpose of the Quicksilver mini-app is to create a freely distributable code base that represents the key elements of the Mercury workload by solving a simplified time-dependent neutron transport problem. As an open source code, Quicksilver will be hosted on the CZ git/stash repo alongside other mini-apps in the ACS so-design suite. It will be used by vendors and other partners for co-design activities such as identifying root causes of Mercury performance bottlenecks on future architectures (i.e., memory bandwidth, memory latency, flop intensity) and developing Quicksilver will be used within LLNL as a nimble platform to evaluate programming models, algorithms, etc. that might be useful in Mercury. Quicksilver may also become a replacement for MCB in future procurement benchmarks, as well as a way to engage vendors in the Trinity and Sierra Centers of Excellence as well as other co-design efforts.

Richards, David↗

Early Experiences Writing Performance Portable OpenMP 4 Codes

In this paper, we evaluate the recently available directives in OpenMP 4 to parallelize a computational kernel using both the traditional shared memory approach and the newer accelerator targeting capabilities. In addition, we explore various transformations that attempt to increase application performance portability, and examine the expressiveness and performance implications of using these approaches. For example, we want to understand if the target map directives in OpenMP 4 improve data locality when mapped to a shared memory system, as opposed to the traditional first touch policy approach in traditional OpenMP. To that end, we use recent Cray and Intel compilers to measure the performance variations of a simple application kernel when executed on the OLCF s Titan supercomputer with NVIDIA GPUs and the Beacon system with Intel Xeon Phi accelerators attached. To better understand these trade-offs, we compare our results from traditional OpenMP shared memory implementations to the newer accelerator programming model when it is used to target both the CPU and an attached heterogeneous device. We believe the results and lessons learned as presented in this paper will be useful to the larger user community by providing guidelines that can assist programmers in the development of performance portable code.

Joubert, Wayne↗

Google Test MPI Listener

Google Test MPI Listener is a plugin for the Google Test c++ unit testing library that organizes test output of software that uses both the MPI parallel programming model and Google Test. Typically, such output is ordered arbitrarily and disorganized, making difficult the process of interpreting test output. This plug organizes output in MPI rank order, enabling easy interpretation of test results.

Oxberry, Geoffrey↗

Occupant Behavior XML Schema

This software implements the DNAS framework into an XML (eXtensible Markup Language) schema, titled "occupant behavior XML" (obXML). The obXML schema is used for the practical implementation of the DNAS framework into building simulation tools. The topology of the DNAS framework implemented in the obXML schema has a main root element OccupantBehavior, linking three main elements representing Buildings, Occupants and Behaviors. Using the schema structure, the actions of turning on an air conditioner and closing blinds provide two examples of how the schema standardizes these actions using XML. The obXML schema has inherent flexibility to represent numerous, diverse and complex types of occupant behaviors in buildings, and it can also be expanded to encompass new types of behaviors. The implementation of DNAS framework into the obXML schema will facilitate the development of occupant information modeling by providing interoperability between occupant behavior models and building energy modeling programs.

Hong, Tianzhen↗

OpenMP 4.5 Validation and Verification Suite for Device Offload

OpenMP has been widely adopted for shared memory systems for over a decade. With the heterogeneity trend in architectures rapidly growing, the programming model needed to evolve such that applications could not only be ported to traditional CPUs but also to accelerators often acting as discrete or integrated devices to CPUs. To that end, OpenMP started to provide support for heterogeneous systems since 2013 when the version 4.0 of the specification was ratified. OpenMP 4.5 is being enhanced to cover major requirements of Exascale Computing Project (ECP) applications. As a result it is time-critical to ensure that the implementations of the 4.5 features are correct and conforming to the specification. This paper focuses on building a Validation and Verification testsuite that will test and present results for several offloading features implemented in compilers such as Clang, IBM XL C/C++, CCE, and GCC. We have results for our testsuite on TITAN, Summitdev and Summit at the Oak Ridge National Lab. We will highlight some of the ambiguities we encountered in the process of validating and verifying feature implementations. We also make the testsuite available for anyone to use and will walk the readers through the infrastructure and the workflow of the testsuite. A website has been built to capture our efforts narrated in this paper https://crpl.cis.udel.edu/ompvvsollve.

Monsalve Diaz, Jose↗

GraphBLAST: A High-Performance Linear Algebra-based Graph Framework on the GPU

High-performance implementations of graph algorithms are challenging to implement on new parallel hardware such as GPUs, because of three challenges: (1) difficulty of coming up with graph building blocks, (2) load imbalance on parallel hardware, and (3) graph problems having low arithmetic intensity. To address these challenges, GraphBLAS is an innovative, on-going effort by the graph analytics community to propose building blocks based in sparse linear algebra, which will allow graph algorithms to be expressed in a performant, succinct, composable and portable manner. In this paper, we examine the performance challenges of a linear algebra-based approach to building graph frameworks and describe new design principles for overcoming these bottlenecks. Among the new design principles is exploiting input sparsity, which allows users to write graph algorithms without specifying push and pull direction. Exploiting output sparsity allows users to tell the backend which values of the output in a single vectorized computation they do not want computed. Load-balancing is an important feature for balancing work amongst parallel workers. We describe the important load-balancing features for handling graphs with different characteristics. The design principles described in this paper have been implemented in "GraphBLAST", the first open-source linear algebra-based graph framework on GPU targeting high-performance computing. The results show that on a single GPU, GraphBLAST has on average at least an order of magnitude speedup over previous GraphBLAS implementations SuiteSparse and GBTL, comparable performance to the fastest GPU hardwired primitives and shared-memory graph frameworks Ligra and Gunrock, and better performance than any other GPU graph framework, while offering a simpler and more concise programming model.

97 MATHEMATICS AND COMPUTING↗