SEARCH · Engineering Papers
Results for “Programming models”
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.
GPU-aware Communication with UCX in Parallel Programming Models: Charm++, MPI, and Python
Explore the source record for details and available documents.
Comparison of Kokkos and CUDA Programming Models for Key Kernels in the Monte Carlo Transport Algorithm.
Abstract not provided.
Towards Distributed Software Resilience in Asynchronous Many-Task Programming Models.
Abstract not provided.
Towards Distributed Software Resilience in Asynchronous Many-Task Programming Models.
Abstract not provided.
New and Future Capabilities for the Kokkos Programming Model.
Abstract not provided.
Adaptive cache management based on programming model information
A processing system selectively allocates space to store a group of one or more cache lines at a cache level of a cache hierarchy having a plurality of cache levels based on memory access patterns of a software application executing at the processing system. The processing system generates bit vectors indicating which cache levels are to allocate space to store groups of one or more cache lines based on the memory access patterns, which are derived from data granularity and movement information. Based on the bit vectors, the processing system provides hints to the cache hierarchy indicating the lowest cache level that can exploit the reuse potential for a particular data.
An Evaluative Comparison of Performance Portability across GPU Programming Models
Explore the source record for details and available documents.
Taking GPU Programming Models to Task for Performance Portability
Explore the source record for details and available documents.
The Minos Computing Library: Efficient Parallel Programming for Extremely Heterogeneous Systems
Hardware specialization has become the silver bullet to achieve efficient high performance, from Systems-on-Chip systems, where hardware specialization can be ``extreme'', to large-scale HPC systems. As the complexity of the systems increases, so does the complexity of programming such architectures in a portable way. This work introduces the Minos Computing Library (MCL), as system software, programming model, and programming model runtime that facilitate programming extremely heterogeneous systems. MCL supports the execution of several multi-threaded applications within the same compute node, performs asynchronous execution of application tasks, efficiently balances computation across hardware resources, and provides performance portability. We show that code developed on a personal desktop automatically scales up to fully utilize powerful workstations with 8 GPUs and down to power-efficient embedded systems. MCL provides up to 17.5x speedup over OpenCL on NVIDIA DGX-1 systems and up to 1.88x speedup on single-GPU systems. In multi-application workloads, MCL dynamically resource allocation provides up to 2.43x performance improvement over manual, static allocation of computing resources.
Colorado Better Buildings Project. Final Report
The Colorado Better Buildings project intended to bring new and existing energy efficiency model programs to market with regional collaboration and funding partnerships. The goals for Boulder County and its program partners were to advance energy efficiency investments, stimulate economic growth in Colorado and advance the state’s energy independence. Collectively, three counties set out to complete 9,025 energy efficiency upgrades in 2.5 years and they succeeded in doing so. Energy efficiency upgrades have been completed in more than 11,000 homes and businesses in these communities. Boulder County and its partners received a $25 million BetterBuildings grant from the U.S. Department of Energy under the American Recovery and Reinvestment Act in the summer of 2010. This was also known as the Energy Efficiency and Conservation Block Grants program. With this funding, Boulder County, the City and County of Denver, and Garfield County set out to design programs for the residential and commercial sectors to overcome key barriers in the energy upgrade process. Since January 2011, these communities have paired homeowners and business owners with an Energy Advisor – an expert to help move from assessment to upgrade with minimal hassle. Pairing this step-by-step assistance with financing incentives has effectively addressed many key barriers, resulting in energy efficiency improvements and happy customers. An expert energy advisor guides the building owner through every step of the process, coordinating the energy assessment, interpreting results for a customized action plan, providing a list of contractors, and finding and applying for all available rebates and low-interest loans. In addition to the expert advising and financial incentives, the programs also included elements of social marketing, technical assistance, workforce development and contractor trainings, project monitoring and verification, and a cloud-based customer data system to coordinate among field advisors and across local governments and local service vendors. A portion of the BetterBuildings grant went to the Metro Mayors Caucus (MMC) who worked in partnership with the Denver Regional Council of Governments (DRCOG) to conduct a series of 10 energy efficiency workshops for local government officials and other interested parties. The workshops helped showcase lessons learned on energy efficiency and helped guide other local governments in the establishment of similar programs. The workshops covered a wide range of energy efficiency and renewable energy topics such as clean energy finance, social mobilization and communications, specific case studies of Colorado towns, energy efficiency codes, net zero buildings and solar power. Since the programs launched in January 2011, these communities have collectively spurred economic investments in energy efficiency, achieved greater than 5:1 leveraging of grant funds, saved energy and reduced greenhouse gas emissions, provided trainings for a robust local energy contractor network, and proved out viable and replicable program models that local utilities and other communities are adopting, with long lasting market transformation.
Performance Modeling and Testing of Distributed Electronics in PV Systems; NREL (National Renewable Energy Laboratory)
Computer modeling is able to predict the performance of distributed power electronics (microinverters, power optimizers) in PV systems. However, details about partial shade and other mismatch must be known in order to give the model accurate information to go on. This talk will describe recent updates in NREL’s System Advisor Model program to model partial shading losses with and without distributed power electronics, along with experimental validation results. Computer modeling is able to predict the performance of distributed power electronics (microinverters, power optimizers) in PV systems. However, details about partial shade and other mismatch must be known in order to give the model accurate information to go on. This talk will describe recent updates in NREL’s System Advisor Model program to model partial shading losses.
Leveraging Compiler-Based Translation to Evaluate a Diversity of Exascale Platforms
Accelerator-based heterogeneous computing is the de facto standard in current and upcoming exascale machines. These heterogeneous resources empower computational scientists to select a machine or platform well-suited to their domain or applications. However, this diversity of machines also poses challenges related to programming model selection: inconsistent availability of programming models across different exascale systems, lack of performance portability for those programming models that do span several systems, and inconsistent performance between different models on a single platform. We explore these challenges on exascale-similar hardware, including AMD MI100 and NVIDIA A100 GPUs. By extending the sourceto-source compiler OpenARC, we demonstrate the power of automated translation of applications written in a single frontend programming model (OpenACC) into a variety of backend models (OpenMP, OpenCL, CUDA, HIP) that span the upcoming exascale environments. This translation enables us to compare performance within and across devices and to analyze programming model behavior with profiling tools.
Modeling Bilevel Programs in Pyomo
We describe new capabilities for modeling bilevel programs within the Pyomo modeling software. These capabilities include new modeling components that represent subproblems, modeling transformations for re-expressing models with bilevel structure in other forms, and optimize bilevel programs with meta-solvers that apply transformations and then perform op- timization on the resulting model. We illustrate the breadth of Pyomo's modeling capabilities for bilevel programs, and we describe how Pyomo's meta-solvers can perform local and global optimization of bilevel programs.
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
Manycore Performance-Portability: Kokkos Multidimensional Array Library
Large, complex scientific and engineering application code have a significant investment in computational kernels to implement their mathematical models. Porting these computational kernels to the collection of modern manycore accelerator devices is a major challenge in that these devices have diverse programming models, application programming interfaces (APIs), and performance requirements. The Kokkos Array programming model provides library-based approach to implement computational kernels that are performance-portable to CPU-multicore and GPGPU accelerator devices. This programming model is based upon three fundamental concepts: (1) manycore compute devices each with its own memory space, (2) data parallel kernels and (3) multidimensional arrays. Kernel execution performance is, especially for NVIDIA® devices, extremely dependent on data access patterns. Optimal data access pattern can be different for different manycore devices – potentially leading to different implementations of computational kernels specialized for different devices. The Kokkos Array programming model supports performance-portable kernels by (1) separating data access patterns from computational kernels through a multidimensional array API and (2) introduce device-specific data access mappings when a kernel is compiled. An implementation of Kokkos Array is available through Trilinos [Trilinos website, http://trilinos.sandia.gov/, August 2011].
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.