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 109 records · Page 6
All sourcesNASA NTRSDOE OSTI
DOE OSTI2019

Computational simulation of a 100 kW dual circulating fluidized bed reactor processing coal by chemical looping with oxygen uncoupling

Chemical looping with oxygen uncoupling (CLOU) is a promising carbon capture technology that utilizes two interconnected fluidized-bed reactors to separate oxygen from air using a metal oxide, and then to use that oxygen to combust fuel in a nitrogen-free environment. CLOU is particularly well suited for solid fuels such as coal since released O 2 will readily combust with solid char. This study presents simulations of the University of Utah's dual fluidized bed chemical looping process development unit (PDU) operating as a CLOU system at 100 kW th , using CPFD Software's Barracuda-VR™ CFD modeling program. A full 3D model of the PDU was used including both reactors, as well as loop seals and cyclone separators. Hydrodynamic settings and the drag model are based on previous cold-flow validation experiments. Mechanisms describing CLOU reaction kinetics for cuprous oxide oxidation in the air reactor and cupric oxide reduction in the fuel reactor were adapted from previously completed experimental work. Coal char kinetics were based on the carbon-hydrogen-nitrogen-oxygen-sulfur, CHNOS, method. Submodels for devolatilization, gasification, and homogenous gas-phase reactions used relationships from the literature. Results predict volatile burnout almost immediately, though coal combustion continues into the upper portions of the fuel reactor and cyclone. Lastly, nitrogen gas leakage into the fuel reactor is shown to be mostly carryover from the air reactor

42 ENGINEERING↗
DOE OSTI2024

Scheduling and Performance of Asynchronous Tasks in Fortran 2018 with FEATS

Most parallel scientific programs contain compiler directives (pragmas) such as those from OpenMP (Hermanns in Parallel programming in Fortran 95 using openMP, 2002. School of Aeronautical Engineering, Universidad Politécnica de Madrid, España, 2011), explicit calls to runtime library procedures such as those implementing the Message Passing Interface (MPI) (in A message-passing interface standard version 4.0, 2021. https://www.mpi-forum.org/docs/mpi-4.0/mpi40-report.pdf), or compiler-specific language extensions such as those provided by CUDA (Ruetsch and Fatica in CUDA Fortran for scientists and engineers: best practices for efficient CUDA Fortran programming, Elsevier, 2013). By contrast, the recent Fortran standards empower developers to express parallel algorithms without directly referencing lower-level parallel programming models (Numrich in Parallel programming with co-arrays, CRC Press, 2018, and Curcic in Modern Fortran: building efficient parallel applications, Manning Publications, 2020). Fortran’s parallel features place the language within the Partitioned Global Address Space (PGAS) class of programming models. When writing programs that exploit data parallelism, application developers often find it straightforward to develop custom parallel algorithms. Problems involving complex, heterogeneous, staged calculations, however, pose much greater challenges. Such applications require careful coordination of tasks in a manner that respects dependencies prescribed by a directed acyclic graph. When rolling one’s own solution proves difficult, extending a customizable framework becomes attractive. Further, the paper presents the design, implementation, and use of the Framework for Extensible Asynchronous Task Scheduling (FEATS), which we believe to be the first task scheduling tool written in modern Fortran. We describe the benefits and compromises associated with choosing Fortran as the implementation language, and we propose ways in which future Fortran standards can best support the use case in this paper.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2018

Adaptive Runtime Features For Distributed Graph Algorithms

Performance of distributed graph algorithms can benefit greatly by forming rapport between algorithmic abstraction and the underlying runtime system that is responsible for scheduling work and exchanging messages. However, due to their dynamic and irregular nature of computation, distributed graph algorithms written in different programming models impose varying degree of workload pressure on the runtime. To cope with such vastly different workload characteristics, a runtime has to make several trade-offs. One such trade-off arises, for example, when the runtime scheduler has to choose among alternatives such as whether to execute algorithmic work, or progress the network by probing network buffers, or throttle sending messages (termed flow control). This tradeoff decides between optimizing the throughput of a runtime scheduler by increasing the rate of execution of algorithmic work, and reducing the latency of the network messages. Another trade-off exists when a decision has to be made about when to send aggregated messages in buffers (message coalescing). This decision chooses between trading off latency for network bandwidth and vice versa. At any instant, such trade-offs emphasize either on improving the quantity of work being executed (by maximizing the scheduler throughput) or on improving the quality of work (by prioritizing better work). However, encoding static policies for different runtime features (such as flow control, coalescing) can prevent graph algorithms from achieving their full potential, thus can undermine the actual performance of a distributed graph algorithm . In this paper, we investigate runtime support for distributed graph algorithms in the context of two paradigms: variants of wellknown Bulk-Synchronous Parallel model and asynchronous programming model. We explore generic runtime features such as message coalescing (aggregation) and flow control and show that execution policies of these features need to be adjusted over time to make a positive impact on the execution time of a distributed graph algorithm. Since synchronous and asynchronous graph algorithms have different workload characteristics, not all of such runtime features may be good candidates for adaptation. Each of these algorithmic paradigms may require different set of features to be adapted over time. We demonstrate which set of feature(s) can be useful in each case to achieve the right balance of work in the runtime layer. Existing implementation of different graph algorithms can benefit from adapting dynamic policies in the underlying runtime.

Firoz, Jesun S.↗
DOE OSTI2020

Improving the performance of medical imaging applications using SYCL

As opposed to the Open Computing Language (OpenCL) programming model, in which host and device codes are generally written in different programming languages, SYCL can combine host and device codes for an application in a type-safe way to improve development productivity and performance portability. Hence, this report shows the experimental results of applying the SYCL programming model to medical imaging applications for a study on performance portability and programming productivity between OpenCL and SYCL. Rodinia is a widely used open-source benchmark suite for heterogeneous computing. We choose two medical imaging applications (Heart Wall and Particle Filter) in the benchmark suite, migrate the OpenCL implementations of the applications to the SYCL implementations, and evaluate their performance and productivity on Intel® microprocessors that contain a central processing unit (CPU) and an integrated graphics processing unit (GPU). The maturing SYCL compilers, which are based on a conformant implementation of the SYCL 1.2.1 Khronos specification, have been actively optimized for Intel® computing platforms. The experimental results are promising in terms of the raw performance and productivity. Although the SYCL implementation of the Heart Wall application does not execute successfully on a CPU, the SYCL implementations of the application can achieve comparable or better performance than the OpenCL implementation on Intel® integrated GPUs. For the Particle Filter application, the performance difference between the SYCL and OpenCL implementations is comparable on the GPUs for most cases, but the SYCL implementations are on average 4X faster than the OpenCL implementations on Intel® Xeon® CPUs. For programming productivity, we arguably use lines of code as a way to measure programming productivity in software. The SYCL programs reduce the lines of code of the OpenCL programs by 52% and 38% for the Heart Wall and Particle Filter, respectively. The results indicate that SYCL is a promising programming model for heterogeneous computing with the maturing compilers. We organize the remainder of the report as follows. Section II introduces the SYCL programming model, compares the major differences between an OpenCL program and a SYCL program, and describes the characteristics of the two applications. Section III describes the SYCL programming model in more details, and shows the SYCL implementation of a kernel function in the Particle Filter application as an example. In Section IV, we evaluate the performance of the applications on the CPUs and GPUs. Section V concludes the report.

59 BASIC BIOLOGICAL SCIENCES↗
DOE OSTI2022

Towards Enhancing Coding Productivity for GPU Programming Using Static Graphs

The main contribution of this work is to increase the coding productivity of GPU programming by using the concept of Static Graphs. GPU capabilities have been increasing significantly in terms of performance and memory capacity. However, there are still some problems in terms of scalability and limitations to the amount of work that a GPU can perform at a time. To minimize the overhead associated with the launch of GPU kernels, as well as to maximize the use of GPU capacity, we have combined the new CUDA Graph API with the CUDA programming model (including CUDA math libraries) and the OpenACC programming model. We use as test cases two different, well-known and widely used problems in HPC and AI: the Conjugate Gradient method and the Particle Swarm Optimization. In the first test case (Conjugate Gradient) we focus on the integration of Static Graphs with CUDA. In this case, we are able to significantly outperform the NVIDIA reference code, reaching an acceleration of up to 11x thanks to a better implementation, which can benefit from the new CUDA Graph capabilities. In the second test case (Particle Swarm Optimization), we complement the OpenACC functionality with the use of CUDA Graph, achieving again accelerations of up to one order of magnitude, with average speedups ranging from 2x to 4x, and performance very close to a reference and optimized CUDA code. Our main target is to achieve a higher coding productivity model for GPU programming by using Static Graphs, which provides, in a very transparent way, a better exploitation of the GPU capacity. The combination of using Static Graphs with two of the current most important GPU programming models (CUDA and OpenACC) is able to reduce considerably the execution time w.r.t. the use of CUDA and OpenACC only, achieving accelerations of up to more than one order of magnitude. Finally, we propose an interface to incorporate the concept of Static Graphs into the OpenACC Specifications.

58 GEOSCIENCES↗
DOE OSTI2019

A Case Study with the HACCmk Kernel in SYCL

The SYCL standard specifies a cross-platform abstraction layer that enables programming of heterogeneous computing systems using standard C++ [1]. In the Open Computing Language (OpenCL) programming model, host and device codes are written in different languages [2 ]. To improve development productivity and performance portability, the SYCL programming model combines host and device codes for an application in a type-safe way. In this report, we are interested in applying the SYCL programming model to a computationally intensive routine derived from the Hardware Accelerated Cosmology Code (HACC) framework for a study on performance portability on a heterogeneous computing device. We use Intel® OneAPI toolkit [3] to build the OpenCL and SYCL programs, and evaluate the performance of both implementations on Intel® integrated GPUs. We find that the SYCL implementation can achieve the same performance as the OpenCL implementation after we specify a target backend for the compiler to build the SYCL program in offline compilation. Without the specification of a target backend, the runtime will have to compile intermediate device codes for a target platform. Such runtime overhead may become significant compared to the execution of a kernel on a target device. As the kernel routine is compute-bound, we evaluate the impact of the number of compute units upon the kernel’s raw performance using two GPUs. When the hardware resource is not underutilized, we can obtain almost linear performance speedup from 48 compute units to 72 compute units in offline compilation, which indicates that the number of compute units on a GPU are important to improving the raw performance of a compute-bound kernel. The experimental results show that SYCL is a promising programming model for heterogeneous computing. The remainder of the report is organized as follows: In Section II, we describe the SYCL programming model, the steps to map an OpenCL program to a SYCL program, and the architecture of an integrated GPU. Section III introduces the kernel routine, and presents the OpenCL and SYCL implementations of the kernel. In Section IV, we evaluate the performance of the implementations on the GPUs. Section V concludes the report.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2020

Towards Generic Parallel Programming in Computer Science Education with Kokkos

Parallel patterns, views, and spaces are promising abstractions to capture the programmer's intent as well as the contextual information that can be used by an underlying runtime to efficiently map software to parallel hardware. These abstractions can be valuable in cases where an algorithm must accommodate requirements of code and performance portability across hardware architectures and vendor programming models. Kokkos is a parallel programming model for host- and accelerator architectures that relies on these abstractions and targets these requirements. It consists of a pure C++ interface, a specification, and a programming library. The programming library exposes patterns and types and maps them to an underlying abstract machine model. The abstract machine model offers a generic view of parallel hardware. While Kokkos is gaining popularity in large-scale HPC applications at some DOE laboratories, we believe that the implemented concepts are of interest to a broader audience including academia as they may contribute to a generic, vendor, and architecture-independent education of parallel programming. In this work, we give an insight into the design considerations of this programming model and list important abstractions. Further, we document best practices obtained from giving virtual classes on Kokkos and give pointers to resources that the reader may consider valuable for a lecture on generic parallel programming for students with preexisting knowledge on this matter.

Ciesko, Jan↗
DOE OSTI2020

A Case Study on the HACCmk Routine in SYCL on Integrated Graphics

As opposed to the Open Computing Language (OpenCL) programming model in which host and device codes are generally written in different languages, the SYCL programming model can combine host and device codes for an application in a type-safe way to improve development productivity. In this paper, we chose the HACCmk routine, a representative compute-bound kernel, as a case study on the performance of the SYCL programming model targeting a heterogeneous computing device. More specifically, we introduced the SYCL programming model, presented the OpenCL and SYCL implementations of the routine, and compared the performance of the two implementations using the offline and online compilation on Intel (R) Iris (TM) Pro integrated GPUs. We found that the overhead of online compilation may become significant compared to the execution time of a kernel. Compared to the performance of OpenCL implementations, the SYCL implementation can maintain the performance using the offline compilation. The number of execution units in a GPU are critical to improving the raw performance of a compute-bound kernel.

Compilation modes↗
DOE OSTI2018

Final Report on Community Solar Design Models for Consumer, Industry, & Utility Success

Since the inception of the first community solar program in 2006, a number of different utility, solar industry and consumer driven community solar program models have emerged across the country with varying regulatory and solar market frameworks behind them. There is little consistency in how programs are administered, participant benefits are assigned, and customers are charged for participation. Further, while it is regularly speculated that community solar programs meet the needs of customers, no such consumer research has been completed against different community solar program models. This collaborative research effort addressed three primary issues: Program design models are numerous and evolving, with varying degrees of applicability across different state policy, utility regulatory, and solar market types. The agents, transaction methods, and accruing costs and benefits are highly variable and largely built on anecdotally successful model evolution. ‘Community solar’ (shared/group solar, solar gardens, etc.) has become a catch-all concept that means different things to different stakeholders, limiting constructive program development and growth. Everything from green pricing programs to remote net metering to metering aggregation has been framed as community solar. Consumer research on individual concepts and program models has been done, but no comprehensive and comparative market research on the broader design models and attributes has been performed. SEPA’s collaborative research effort on Community Solar Design Models for Consumer, Industry, & Utility Success is premised on the principle that greater standardization of community solar models and better understanding of consumer interests are key underpinnings of increased community solar deployment. Utilizing a cross-sectional multi-stakeholder working group, as well as focus groups and surveys, webinars, targeted outreach, and other tools, this project aims to expand the community solar knowledge base, facilitate information exchange, identify opportunities for standardization and improvement, determine what consumers’ interests are and how best to message to them, promote the research results within the solar and utility industries, and advance key opportunities for strategic deployment plans for community solar. A summary of these key takeaways/lessons learned during the grant period include: Siting of system should be evaluated up-front in the process Engage stakeholders collaboratively and early to help ensure the best chance for a successful program IT/billing departments must have a seat at the design table Establish upfront target objectives with respect to residential and commercial program access levels helps ensure program success Balance trade-offs to manage utility and developer risk with customer participation carefully to optimize pricing and sizing the program offering Over the course of the 42 month grant period, SEPA and its project team conducted a series of activities all designed to accelerate the number and size of community solar programs across the country. These activities included: Community Solar Program Design Models (2 reports) – SEPA, in collaboration with its projects team, the Coalition for Community Solar Access, and over 60 administrators of actual community solar programs, developed two reports providing hard data on the developments of community solar. These reports touched on program performance, quantity and type of programs, and program design steps, among other aspects. The reports collectively received over 2000 unique downloads. Market Research Report – SEPA, in collaboration with The Shelton Group, conducted a series of national surveys and focus groups to identify what customers were looking for in a community solar offering. The resulting report, “What the Community Solar Customer Wants”, received over 1,000 unique downloads. Technical Assistance Projects – SEPA supported 8 organizations who were pursuing community solar programs. Based on this support, over 5.7 MWs of new solar capacity have been developed. Technical Assistance Case Studies – SEPA developed two case studies detailing the technical assistance work in Fremont, NE Department of Utilities and the public power arm of Minster Ohio. These two reports have received 1,002 unique downloads. Webinar – SEPA hosted two webinars on community solar which collectively received 743 participants. The webinars focused on disseminating the findings of the research conducted under this project, as well as the research conducted in separate solar market pathways projects. Community Solar Design Workshops – 120 registrants learned about the trends in community solar and participated a business case exercise to design their own programs.

14 SOLAR ENERGY↗
DOE OSTI2021

Design-time performance modeling of compositional parallel programs

Performance models are powerful instruments for understanding the performance of parallel systems and uncovering their bottlenecks. Already during system design, performance models can help ponder alternative development options. However, creating a performance model – whether theoretically or empirically – for an entire application that does not exist yet is challenging. In this paper, we propose to generate performance models of full programs from performance models of their components using formal composition operators derived from parallel design patterns. As long as the design of the overall system follows such a pattern, its performance model can be predicted with reasonable accuracy without an actual implementation. In conclusion, we demonstrate our approach with design patterns of varying complexity, including pipeline, task pool, and eventually MapReduce, which is representative of a broad class of data-analytics applications.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2016

Towards Achieving Performance Portability Using Directives for Accelerators

In this paper we explore the performance portability of directives provided by OpenMP 4 and OpenACC to program various types of node architectures with attached accelerators, both self-hosted multicore and offload multicore/GPU. Our goal is to examine how successful OpenACC and the newer offload features of OpenMP 4.5 are for moving codes between architectures, how much tuning might be required and what lessons we can learn from this experience. To do this, we use examples of algorithms with varying computational intensities for our evaluation, as both compute and data access efficiency are important considerations for overall application performance. We implement these kernels using various methods provided by newer OpenACC and OpenMP implementations, and we evaluate their performance on various platforms including both X86_64 with attached NVIDIA GPUs, self-hosted Intel Xeon Phi KNL, as well as an X86_64 host system with Intel Xeon Phi coprocessors. In this paper, we explain what factors affected the performance portability such as how to pick the right programming model, its programming style, its availability on different platforms, and how well compilers can optimize and target to multiple platforms.

97 MATHEMATICS AND COMPUTING↗
DOE OSTI2019

Grid Optimization Lawrence Livermore Nonlinear Programming

Modelling and solution library for security-constrained AC optimal power flow problems that uses nonlinear programming methods (interior-point methods) and solvers (Ipopt, HiOp). The code is written in C++ and provides parallel computing capabilities in the form of task parallelism (solving contingency problems in parallel). Code can run on a variety of commodity high-performance computing.

Petra, CosminG↗
DOE OSTI2022

Y-12 Nuclear Criticality Safety Program Health Model: Development, Use and Benefits

The Y-12 National Security Complex (Y-12) operates seven diverse enriched uranium processing facilities and maintains a comprehensive nuclear criticality safety (NCS) program. Given the magnitude of the hazard, the NCS program receives significant oversight. Describing the scope and health of the Y-12 NCS program to sometimes non-expert stakeholders with limited time had historically focused on recent events and “hot topics” which did not always convey sufficient context (i.e., how to differentiate between an individual performance issue and a systemic concern). Y-12 created the NCS Program Health (NCSPH) Model to provide a complete and holistic framework to quantify and communicate NCS program health. The model is constructed in a tiered fashion with the top tier broken into three (3) Tier 2 elements, fourteen (14) Tier 3 elements, and 104 Tier 4 and 5 elements. This granularity ensures every feature of the NCS Program is accounted for and stakeholders can see how these features support the collective whole. The model is used as the framework for NCS communications including program plans, reports, health surveys, and meeting agendas. The model has substantially improved stakeholder appreciation for the entirety of the NCS program and how events and assessment results factor into an overarching conclusion on NCS program health. While some details are Y-12 specific, the NCSPH model can easily be tailored for any other site with an NCS program.

12 MANAGEMENT OF RADIOACTIVE AND NON-RADIOACTIVE W↗
DOE OSTI2022

Economic and Environmental Analysis to Evaluate the Potential Value of Co-Optima Diesel Bioblendstocks to Petroleum Refiners

The U.S. petroleum refining sector is undergoing a period of historic transformation, catalyzed by the decarbonization of the U.S. economy. Diesel-boiling-range bioblendstocks have gained traction, owing to their superior fuel properties and environmental performance as compared to traditional petroleum fuels. This work couples refinery linear programming models with life cycle assessment to quantify the potential economic and environmental benefits, and trade-offs, of blending diesel-boiling-range bioblendstocks at petroleum refineries. Linear programming models were developed in Aspen Process Industry Modeling Systems (PIMS) for three representative petroleum refinery configurations of differing complexity. Seven diesel-boiling-range bioblendstocks: 4-butoxyheptane, 5-ethyl-4-propylnonane, soy biodiesel, sludge hydrothermal liquefaction diesel, polyoxymethylene ethers, renewable diesel, and hexyl hexanoate, were investigated to identify key fuel properties that influence refineries' economics and to track the effect of adding bioblendstocks on refinery-wide cradle-to-gate greenhouse gases (GHG) emissions. These analyses considered blending levels from 10 to 30 vol% and fuel demand projections over the period 2040 to 2050. This analysis determines that bioblendstock sulfur content and cetane number are the primary fuel attributes with the potential to provide value to refiners. Life cycle assessment results indicate that the use of diesel-boiling-range bioblendstocks can reduce cradle-to-gate refinery GHG emissions by up to ~ 40 % relative to conventional refinery operations when considering carbon uptake in the supply chain of the bioblendstock. Refinery-wide marginal GHG abatement costs range from 120 to 3,600 USD2016/metric tons carbon dioxide equivalent avoided across the scenarios evaluated. Reducing the price of bioblendstocks is identified as a key to their adoption.

ADVANCED PROPULSION SYSTEMS,BIOMASS FUELS,ENERGY P↗
DOE OSTI2018

Argobots: A Lightweight Low-Level Threading and Tasking Framework

In the past few decades, a number of user-level threading and tasking models have been proposed in the literature to address the shortcomings of OS-level threads, primarily with respect to cost and flexibility. Current state-of-the-art user-level threading and tasking models, however, are either too specific to applications or architectures or are not as powerful or flexible. In this paper, we present Argobots, a lightweight, low-level threading and tasking framework that is designed as a portable and performant substrate for high-level programming models or runtime systems. Argobots offers a carefully designed execution model that balances generality of functionality with providing a rich set of controls to allow specialization by the user or high-level programming model. We describe the design, implementation, and optimization of Argobots and present integrations with three example high-level models: OpenMP, MPI, and co-located I/O service. Evaluations show that (1) Argobots outperforms existing generic threading runtimes; (2) our OpenMP runtime offers more efficient interoperability capabilities than production OpenMP runtimes do; (3) when MPI interoperates with Argobots instead of Pthreads, it enjoys reduced synchronization costs and better latency hiding capabilities; and (4) I/O service with Argobots reduces interference with co-located applications, achieving performance competitive with that of the Pthreads version.

Seo, Sangmin (ORCID:0000000295159836)↗
DOE OSTI2017

Implementing the OpenACC Data Model

Programming accelerators today usually requires managing separate virtual and physical memories, such as allocating space in and copying data between host and device memories. The OpenACC API provides data directives and clauses to control this behavior where it is required. This paper describes how the data model is supported in current OpenACC implementations, ranging from research compilers (OpenUH and OpenARC) to a commercial compiler (the PGI OpenACC compiler). This includes implementation of the data directives and clauses, testing whether the data is already present on the device, OpenCL support, managing asynchronous data transfers and memory allocations, handling aliased data, reusing device memory, managing partially present data, and support for shared memory between host and device. Lastly, it also discusses on-going work to manage large, complex dynamic data structures.

Wolfe, Michael↗
DOE OSTI2018

Optimal allocation of series FACTS devices in large‐scale systems

Series flexible AC transmission systems devices, such as the variable series reactor, have the ability to continuously regulate the transmission line reactance so as to control power flow. This study presents a new approach to optimally locating such devices in the transmission network considering multiple operating states and contingencies. To investigate optimal investment, a single target year planning with three different load patterns is considered. The transmission contingencies may occur under any of the three load conditions and the coupling constraints between base case and contingencies are included. A reformulation technique transforms the original mixed integer non‐linear programming model into mixed integer linear programming model. To further relieve the computational burden and enable the planning model to be directly applied to practical large‐scale systems, a two‐phase decomposition algorithm is introduced. Detailed numerical simulation results on IEEE 118‐bus system and the Polish 2383‐bus system illustrate the efficient performance of the proposed algorithm.

Zhang, Xiaohu↗