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 559 records · Page 31

In Situ Indexing and Query Processing of AMR Data

We have developed the first, holistic, Adaptive Mesh Refinement (AMR) capable, in situ query framework to ensure the tractability of the current- and next-generation AMR simulation analysis on the path to extreme scale. We have addressed key issues pertaining to in situ analysis, memory hierarchy, generalized parallel indexing, index-compression, and real-time access pattern detection. We have published the following research papers in high profile peer reviewed computer science conferences: (a) Parallel In Situ Detection of Connected Components in Adaptive Mesh Refinement Data; (b) AMR-aware In Situ Indexing and Scalable Querying; (c) Pattern-driven dynamic data layout optimization; (d) In situ Storage Layout Optimization for AMR Spatio-temporal Read Accesses; (e) AMRZone: A Runtime AMR Data Sharing Framework for Scientific Applications; (f) Exploring Memory Hierarchy and Network Topology for Runtime AMR Data Sharing Across Scientific Applications.

96 KNOWLEDGE MANAGEMENT AND PRESERVATION↗

Swift/T Guide

Swift/T is a hierarchical, parallel programming system that allows you to rapidly develop many-task workflows that call into sequential code concurrently. It is implemented with a compiler and runtime system; the Swift/Turbine Compiler (STC) allows you to write Swift programs and run them using Turbine. At runtime, Swift/T programs are MPI programs capable of utilizing very large supercomputers.

97 MATHEMATICS AND COMPUTING↗

Evaluation of Accuracy and Performance of a Bilinear Interpolator with Dense EOS Tables in xRage

This study investigates the performance and accuracy of simulations using air and deuterium equation-of-state (EOS) tables that have been densified coupled with linear interpolation, as opposed to the default rational interpolation used in EOSPAC. EOS tables that are densified by adding in more temperature and density points that have been calculated by the rational function interpolator are able to improve the accuracy of the linear interpolator by over 50%. There was no change in runtime performance for a simulation using a dense EOS table with linear interpolation. In a memory limited case, dense EOS tables had no apparent effect on the simulation runtime or memory usage.

97 MATHEMATICS AND COMPUTING↗

Data Locality Enhancement of Dynamic Simulations for Exascale Computing (Final Report)

The development of modern processors exhibits two trends that complicate the optimizations of modern software. The first is the increasing sensitivity of processors' throughput to irregularities in computation. With more processors produced through a massive integration of simple cores, future systems will increasingly favor regular data-level parallel computations, but deviate from the needs of applications with complex patterns. Some evidences are already shown on Graphic Processing Units (GPU): Irregular data accesses (e.g., indirect references A[D[i]]) and conditional branches are limiting many GPU applications' performance at a level an order of magnitude lower than the peak of GPU. The second hardware trend is the growing gap between memory bandwidth and the aggregate speed—that is, the sum of all cores' computing power—of a Chip Multiprocessor (CMP). Despite the capped growth of the peak CPU speed, the aggregate speed of a CMP keeps increasing as more cores get into a single chip. It is expected that by 2018, node concurrency in an exascale system will increase by hundreds of times, whereas, memory bandwidth will expand by only 10 to 20 times. Consequently, data movement and storage is expected to consume more than 70% of the total system power. Bridging this gap is difficult; the complexities of modern CMP memory hierarchy make it even harder: Data cache becomes shared among computing units, and the sharing is often non-uniform—whether two computing units share a cache depends on their proximity and the level of the cache. On the recent IBM Power7 architecture, for instance, four hardware contexts (or SMT threads) in a core share the entire memory hierarchy, all cores in one chip share an on-chip L3 cache, and cores across chips share L3 and main memory through off-chip connections. These two trends complicate the translation of computing power into performance, especially for a program with either intensive data accesses or complex patterns in data accesses or control flow paths. Unfortunately, both attributes present and will persist in a class of important applications. For instance, many scientific simulations deal with a large volume of data. And meanwhile, as most real-world processes are non-uniform and evolving (e.g., the evolution of a galaxy or the process of a drug injection), both the computations and data accesses of these programs tend to be irregular and dynamically changing. Currently, the lack of support to these applications on modern CMP severely limits their performance. On GPU, as our recent study shows and other studies echo, performance enhancement of a factor of integers is possible when memory accesses or control flows are streamlined for a set of GPU applications. On multicore CPU, our studies show that traditional locality enhancement, for being oblivious to the new features of multicore memory hierarchy, may even cause large slowdown to data-intensive dynamic applications. The severity of the issues is expected to worsen as the two hardware trends continue. Some recent studies try to match software with the trends, but in a limited scope or manner. For irregularities on GPU, most studies focus on irregularities analyzable through static analysis (e.g., data accesses in regular loops). Dynamic irregularities are harder to address because the needed analysis and transformations typically have to happen at run time. Some other research resorts to hardware extensions, an actual adoption of which is unclear for the entailed space cost and complexity. For data locality, recent years have seen some exploitations of the new memory hierarchy on multicore for performance, but most of them are on process or thread scheduling, rather than program transformations. Our recent study reveals that program-level transformations may magnify the scheduling benefits by a factor of seven, concluding that program-level transformation should play a central role for data locality enhancement on modern CMP. But research in this direction has been sparse, and most have focused on data layout or cache performance modeling, rather than program transformations to match with the new memory hierarchy features. Overall, it is still an open question how to bridge the gap between dynamic computations and the two prominent properties of modern processors. The goal of this project is to develop a set of techniques and software tools to enhance the matching between memory accesses in dynamic simulations and the prominent features of modern and future CMP, alleviating the memory performance issues for petascale and exascale computing. This report summarizes the discoveries and products produced throughout this project. It includes free launch, a new software approach to overcoming the shortcomings of both methods; coherence-free multiview, an approach that allows multiple views of a single data object to co-exist on GPU memory during a GPU kernel execution; algorithmic optimizations to data analytics problems, especially those that involve lots of distance calculations. Supporting dynamic parallelism is important for GPU to benefit a broad range of applications. There are currently two fundamental ways for programs to exploit dynamic parallelism on GPU: a software-based approach with software-managed worklists, and a hardware-based approach through dynamic subkernel launches. Neither is satisfactory. The former is complicated to program and is often subject to some load imbalance; the latter suffers large runtime overhead. In this work, we propose free launch, a new software approach to overcoming the shortcomings of both methods. It allows programmers to use subkernel launches to express dynamic parallelism. It employs a novel compiler-based code transformation named subkernel launch removal to replace the subkernel launches with the reuse of parent threads. Coupled with an adaptive task assignment mechanism, the transformation reassigns the tasks in the subkernels to the parent threads with a good load balance. The technique requires no hardware extensions, immediately deployable on existing GPUs. It keeps the programming convenience of the subkernel launch-based approach while avoiding its large runtime overhead. Meanwhile, its superior load balancing makes it outperform manual worklist-based techniques by 3X on average. The work was published at the 48th Annual IEEE/ACM International Symposium on Microarchitecture (Micro'2015). A Graphic Processing Unit (GPU) system is typically equipped with many types of memory (e.g., global, constant, texture, shared, cache). Data placement determines what data are placed on which type of memory, essential for GPU memory performance. Prior optimizations of data placement always require a single view of a data object on memory, which limits the optimization effectiveness. In this work, we propose coherence-free multiview, an approach that allows multiple views of a single data object to co-exist on GPU memory during a GPU kernel execution. We demonstrate that under certain conditions, the multiple views can remain incoherent while facilitating enhanced data placement. We present a theorem and some compiler support to ensure the soundness of the usage of coherence-free multiview. We further develop reference-discerning data placement, a new way to enhance data placements on GPU. It enables more flexible data placements by using coherence-free multiview to leverage the slack in coherence requirement of some GPU programs. Experiments on three types of GPU systems show that, with less than 200KB space cost, the new data placement technique can provide a 1.6X average (up to 4.27X) speedup. In addition, we have examined algorithmic optimizations to data analytics problems, especially those that involve lots of distance calculations. Computing distances among data points is an essential part of many important algorithms in data analytics, graph analysis, and other domains. In each of these domains, developers have spent significant manual effort optimizing algorithms, often through novel applications of the triangle equality, in order to minimize the number of distance computations in the algorithms. In this work, we observe that many algorithms across these domains can be generalized as an instance of a generic distance-related abstraction. Based on this abstraction, we derive seven principles for correctly applying the triangular inequality to optimize distance-related algorithms. Guided by the findings, we develop Triangular OPtimizer (TOP), the first software framework that is able to automatically produce optimized algorithms that either matches or outperforms manually designed algorithms for solving distance-related problems. TOP achieves up to 237x speedups and 2.5X on average. The work has been published at the 32nd International Conference on Machine Learning (ICML'15) and the 41st International Conference on Very Large Data Bases (VLDB'15).

42 ENGINEERING↗

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↗

Performance Analysis of Traditional and Data-Parallel Primitive Implementations of Visualization and Analysis Kernels

Measurements of absolute runtime are useful as a summary of performance when studying parallel visualization and analysis methods on computational platforms of increasing concurrency and complexity. We can obtain even more insights by measuring and examining more detailed measures from hardware performance counters, such as the number of instructions executed by an algorithm implemented in a particular way, the amount of data moved to/from memory, memory hierarchy utilization levels via cache hit/miss ratios, and so forth. This work focuses on performance analysis on modern multi-core platforms of three different visualization and analysis kernels that are implemented in different ways: one is "traditional", using combinations of C++ and VTK, and the other uses a data-parallel approach using VTK-m. Our performance study consists of measurement and reporting of several different hardware performance counters on two different multi-core CPU platforms. The results reveal interesting performance differences between these two different approaches for implementing these kernels, results that would not be apparent using runtime as the only metric.

97 MATHEMATICS AND COMPUTING↗

Detection of Defects in Additively Manufactured Metallic Materials with Machine Learning of Pulsed Thermography Images

Additive manufacturing (AM) is an emerging method for cost-efficient fabrication of nuclear reactor parts. AM of metallic structures for nuclear energy applications is currently based on laser powder bed fusion (LPBF) process, which can introduce internal material flaws, such as pores and anisotropy. Integrity of AM structures needs to be evaluated nondestructively because material flaws could lead to premature failures due to exposure to high temperature, radiation and corrosive environment in a nuclear reactor. Quality control (QC) requires nondestructive evaluation (NDE) of actual AM structures. Pulsed thermography is a potentially promising QC technique because it is scalable to arbitrary structure size. However, detection sensitivity of this method is limited by noises. We investigate separation of signal from noise in thermography images using several machine learning (ML) methods, including new spatio-temporal blind source separation (STBSS) and spatio-temporal sparse dictionary learning (STSDL) methods. Performance of the ML methods is benchmarked using thermography data obtained from imaging stainless steel 316L and Inconel 718 specimens produced LPBF method with imprinted calibrated porosity defects. The ML methods are ranked by F-score and execution runtime. The ML methods with higher accuracy require longer run time. However, this runtime is sufficiently short to perform QC within a realistic time frame.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

Development and Validation of Algorithms That Analyze Communicating Thermostat Data to Identify Enclosure Retrofit Opportunities

Annual energy savings of up to $\$ 4$ to $\$ 5$ billion could be achieved nationwide through basic insulation and heating system retrofits of existing homes. However, current utility energy efficiency programs are costly and challenging to scale. Customer acquisition occurs primarily through energy bill mailers, mass media, and online advertising that lack specificity about home-specific retrofit opportunities, expected energy savings, and cost-effectiveness. Specific retrofit opportunities are identified via on-site home energy assessments (HEAs) that are inconvenient to homeowners, expensive, and of variable accuracy. We developed computational algorithms that automatically analyze communicating thermostat (CT) heating data that could be used to increase the customer uptake of insulation and air sealing energy conservation measures (ECMs) by identifying homes with the most significant retrofit opportunities, estimating post-retrofit energy savings, and formulating home-specific outreach. The algorithms are based on an extended second-order grey-box model that characterizes a building’s thermal response using lumped elements, coupled with an empirical model of infiltration that accounts for both wind and stack effects. The basic parameters of the model correspond to actual physical parameters of the home, i.e., the home’s overall R-value of and the building envelope ACH50. Unlike the conventional approach, which estimates model parameters based on the best fit to the observed time-dependent room temperature, our approach derives correlations between the daily heating system runtime and temperature difference (indoor-outdoor) that are more robust to data quality issues in real-world applications. We also used HEA data for algorithm development and validation. With the help of our utility partners, Eversource and National Grid, we obtained data sets for hundreds of Massachusetts homes. For each home, these data sets included three sets of information anonymized by the utility: (1) CT data (HVAC runtime, room temperature, and, for some vendors, outdoor temperature and wind speed) collected by the CT vendor (one of three) over a heating season, (2) HEA report performed by the HEA vendor (same vendor for all homes), (3) Monthly utility gas bills coincident with the CT data (3 to 24 per home, depending on availability). For some homes, we also obtained blower-door test results. Initially, we applied the algorithms developed to homes with a single CT and then extended them to homes with two CTs by using an equivalent home approach. Finally, we developed algorithms for prediction of energy savings and a methodology of comparing our predictions with those generated by HEAs. The main technical results indicate that we can reliably identify homes with insulation and/or air sealing retrofit opportunities and provide accurate savings predictions. Our hypothesis is that the algorithms could be applied to utility energy efficiency programs to identify homes that could realize significant energy savings from insulation and/or air sealing retrofits. This information could then be used to reach out to those homes with highly customized outreach, thereby delivering increased program energy savings and cost-effectiveness. This would: Significantly increase the uptake rate of on-site HEAs, and Significantly increase the fraction of HEAs resulting in ECM implementation. To test these hypotheses, we designed and conducted a randomized controlled trial (RCT). The RCT results suggest that personal messaging leads to a two- to five-fold increase in the HEA uptake rate.

32 ENERGY CONSERVATION, CONSUMPTION, AND UTILIZATI↗

Dynamic Species Reduction for Multi-Cycle CFD Simulations (Final Technical Report)

This project primarily sought to address some of the computational cost concerns of detailed simulations by developing improved methods of handling species transport, and chemical kinetics evaluation in a commercial 3D Computational Fluid Dynamics (CFD) environment. Secondary goals were to apply these techniques to fuels and conditions of interest to better understand the key species and reactions required to adequately capture cycle to cycle coupling. Improved modeling will lead to better understanding of these combustion modes and their dependence on fuel composition, which can then enable more clean and efficient engines, ultimately benefiting the consumer as well as the general public. Two approaches were used to address the computational cost. A “Dynamic Species Reduction” (DSR) procedure was developed to remove chemical species from the simulation during periods when chemical reactions were not expected to be important, particularly during gas exchange when temperatures are low and little fuel remains. This modelling procedure automatically detects relevant species to retain in the simulation domain based on their local concentration, removes species below a specified concentration threshold, and then adjusts the remaining species mass to conserve not only the number of H, C, and O atoms in each cell, but also the relative proportions between species and the heating value of the mixture in every cell. The second procedure was a “Product Directed Remapping” (PDR) updates the algorithm used to group individual computational cells for chemical kinetics evaluation to account for non-uniform temperature distributions and the CO to CO 2 ratio in the cells. The model techniques developed in this work successfully demonstrated computational performance improvements for a range of conditions relevant for Highly Dilute SI and HCCI engine operation. Runtime reductions of 10% were observed for small mechanisms, with further reductions of up to 36% observed for larger mechanisms. Improvements were primarily related to reducing the number of chemical species tracked during the gas exchange process using the Dynamic Species Reduction method. With smaller benefits observed from changes to the kinetics binning and evaluation strategy in the post combustion region using the PDR method. The results of this work show the potential for improved computational runtime for complicated simulations. They can and should be extended to additional conditions and new bio-derived and renewable fuels as they are developed and new kinetic mechanisms become available.

10 SYNTHETIC FUELS↗

GPU Acceleration of a Diagnostic Wind Solver

Reducing QUIC-Fire simulation runtimes is crucial in enabling simulation ensembles to guide science-driven prescribed fire planning in regions of complex terrain. Utilizing GPUs through OpenACC and Kokkos frameworks to accelerate generation of 3D windfields in QUIC-Fire would provide substantial speedup to the runtime of the code. Using GPUs for the Successive Over-Relaxation (SOR) algorithm utilized in QUIC-Fire will require deriving a ‘four colored’ version of the well explored ‘Red-Black’ SOR parallelization scheme. This effort could open the door for utilizing GPUs in other portions of the QUIC-Fire algorithm, increasing its viability in more complex and larger domains.

58 GEOSCIENCES↗

Faster Tensor Network Decoding for Topological Quantum Codes

We present a fast and Bayes-optimal-approximating tensor network decoder for planar quantum LDPC codes based on the tensor renormalization group algorithm, originally proposed by Levin, and Nave. By precomputing the renormalization group flow for the null syndrome, we need only recompute tensor contractions in the causal cone of the measured syndrome at the time of decoding. This allows us to achieve an overall runtime complexity of ($pnχ^6$) where p is the depolarizing noise rate, and χ is the cutoff value used to control singular value decomposition approximations used in the algorithm. We apply our decoder to the surface code in the code capacity noise model and compare its performance to the original matrix product state (MPS) tensor network decoder introduced by Bravyi, Suchara, and Vargo. The MPS decoder has a p-independent runtime complexity of $\mathcal{O}(nχ^3)$ resulting in significantly slower decoding times compared to our algorithm in the low-p regime.

97 MATHEMATICS AND COMPUTING↗

MPACT Testing and Benchmarking Results

This document provides detailed reactivity and fission rate distribution results for MPACT for the Core Physics Benchmark Progression Problems 1-5, including comparisons to initial startup data from Watts Bar Nuclear Unit 1. Also included are computer requirements and runtimes for each type of problem and feedback for issues encountered during the testing. Testing for the benchmark problems that do not require thermal-hydraulic feedback has been very successful. Testing for the coupled problems (6 and 7) is still ongoing and will be documented in a future revision or separate document. A few issues have been identified needing more research/investigation before all of these problems have ideal solutions. These items are included in the Section 8 near the end of this document. MPACT has successfully solved all of the zero power core physics progression problems. The computer resources required and runtimes were all acceptable, though faster cases would be preferable considering there was no thermal-hydraulic feedback. MPACT converged very reliably for all 3D problems, expect in a few isolated studies where very thin axial planes were purposely created to attempt to quantify the errors in the control rod tip homogenization model. Despite the issues listed in Section 8, the accuracy of MPACT compared to the reference solution is considered to be very good.

21 SPECIFIC NUCLEAR REACTORS AND ASSOCIATED PLANTS↗

Improving the Performance of NEML2 with Modern Graph Compilation Backends

NEML2 vectorizes constitutive-model evaluation for large-scale multiphysics simulation, using PyTorch as its tensor backend so that a batch of material-point updates runs on CPU or GPU through a single implementation. In the two prior reports in this series it was a C++-native library, deployed through TorchScript tracing and just-in-time (JIT) compilation; it has since been rewritten from the ground up into a Python-native library deployed through Ahead-of-Time Inductor (AOTInductor), a modern PyTorch graph-compilation backend. The rewrite is driven by a persistent tension, not a language preference: NEML2 composes constitutive models at runtime from a registry of small, independently-authored pieces, and that flexibility is difficult to reconcile with the compile-time knowledge an efficient GPU kernel needs. This report documents the rewrite and the investment that accompanied it: the AOTInductor export pipeline that turns a Python-authored model into a portable, Python-free compiled artifact loadable from pure C++; the eager and compiled runtimes and the new implicit solver layer built on them; a head-to-head benchmark of legacy JIT against AOTInductor; the physics-model catalog and its worked examples; the developer tooling; and the corresponding overhaul of MOOSE’s NEML2 integration that lets MOOSE consume it. A central objective is to examine whether modern PyTorch graph-compilation backends are effective for MOOSE GPU integration. The benchmark answers directly: AOTInductor outperforms legacy JIT on every GPU scenario measured, by 1.0–4.5×. Modern graph-compilation backends are effective for MOOSE GPU integration, and AOTInductor specifically – not compilation in the abstract – is why.

Hu, Gary (Tianchen) [Argonne National Laboratory (↗

Improving performance via mini-applications.

Application performance is determined by a combination of many choices: hardware platform, runtime environment, languages and compilers used, algorithm choice and implementation, and more. In this complicated environment, we find that the use of mini-applications - small self-contained proxies for real applications - is an excellent approach for rapidly exploring the parameter space of all these choices. Furthermore, use of mini-applications enriches the interaction between application, library and computer system developers by providing explicit functioning software and concrete performance results that lead to detailed, focused discussions of design trade-offs, algorithm choices and runtime performance issues. In this paper we discuss a collection of mini-applications and demonstrate how we use them to analyze and improve application performance on new and future computer platforms.

97 MATHEMATICS AND COMPUTING↗

Caffeine: CoArray Fortran Framework of Efficient Interfaces to Network Environments

This paper provides an introduction to the CoArray Fortran Framework of Efficient Interfaces to Network Environments (Caffeine), a parallel runtime library built atop the GASNet-EX exascale networking library. Caffeine leverages several non-parallel Fortran features to write type- and rank-agnostic interfaces and corresponding procedure definitions that support parallel Fortran 2018 features, including communication, collective operations, and related services. One major goal is to develop a runtime library that can eventually be considered for adoption by LLVM Flang, enabling that compiler to support the parallel features of Fortran. The paper describes the motivations behind Caffeine's design and implementation decisions, details the current state of Caffeine's development, and previews future work. We explain how the design and implementation offer benefits related to software sustainability by lowering the barrier to user contributions, reducing complexity through the use of Fortran 2018 C-interoperability features, and high performance through the use of a lightweight communication substrate.

Rouson, Damian↗

Idiomatic Correctness-Checking via Julienne in Fortran 2023

This paper presents a unified approach to unit testing and runtime assertion checking using Fortran 2023. The paper describes the support for our approach in the Julienne framework. Julienne leverages recent Fortran standards to implement object-oriented design patterns, support testing parallel programs, and implement functional programming patterns in order to craft idioms inspired by natural-language expressions. The presented idioms employ novel operators to write expressions that evaluate to a test-diagnosis object encapsulating two components: (1) the test outcome or assertion outcome and (2) an automatically generated diagnostic string. Two other novel aspects of the approach include (1) the ability to enforce assertions inside pure procedures and (2) the ability to output rich diagnostic information inside pure procedures during error termination when assertions fail. The latter capability mitigates against a reason that Fortran programmers commonly cite for not writing pure procedures: difficulty obtaining useful program output inside pure procedures when debugging code. This paper demonstrates how the adoption of the proposed idioms leads naturally to a unifying theme across two otherwise disparate technologies: unit testing and runtime assertion checking. Finally, this paper describes the usage of the Julienne testing framework for writing unit tests and assertions in the Matcha high-performance computing application and the Fiats deep learning library.

Rouson, Damian↗

Agile Acceleration of LLVM Flang Support for Fortran 2018 Parallel Programming

The LLVM Flang compiler ("Flang") is currently Fortran 95 compliant, and the frontend can parse Fortran 2018. However, Flang does not have a comprehensive 2018 test suite and does not fully implement the static semantics of the 2018 standard. We are investigating whether agile software development techniques, such as pair programming and test-driven development (TDD), can help Flang to rapidly progress to Fortran 2018 compliance. Because of the paramount importance of parallelism in high-performance computing, we are focusing on Fortran’s parallel features, commonly denoted “Coarray Fortran.” We are developing what we believe are the first exhaustive, open-source tests for the static semantics of Fortran 2018 parallel features, and contributing them to the LLVM project. A related effort involves writing runtime tests for parallel 2018 features and supporting those tests by developing a new parallel runtime library: the CoArray Fortran Framework of Efficient Interfaces to Network Environments (Caffeine).

Rasmussen, Katherine↗

Advancing Replicable Solutions for High-Performance Homes in the Southeast - JMC - Patrick Square

The work presented in this report advances the goals of the U.S. Department of Energy Building America program by improving the energy peformance of affordable and market-rate housing. Southface Energy Institute (Southface), part of the U.S. Department of Energy Building America research team Partnership for Home Innovation, worked with owners and builders with various market constraints and ultimate goals for three projects in three climate zones (CZs): Savannah Gardens in Savannah, Georgia (CZ 2); JMC Patrick Square in Clemson, South Carolina (CZ 3); and LaFayette in LaFayette, Georgia (CZ 4). This report documents the design process, computational energy modeling, construction, envelope performance metrics, long-term monitoring results, and successes and failures of the design and execution of these highperformance homes. The JMC Patrick Square project is a single floor with 1,828 ft2 of conditioned living space, three bedrooms, two bathrooms, and an attached two-car garage. This small-scale production builder wanted to increase its level of energy efficiency beyond its current green building practices, including bringing ducts into conditioned space. The team met this goal through a combination of upgrade measures and achieved many Zero Energy Ready Home program requirements. Monitoring the four ducted HPWHs in LaFayette and one in Savannah revealed that HPWH exhaust air impacts attic air during HPWH runtime only, and attic conditions return to previous levels shortly after the HPWH turns off. The HPWH did not appear to impact the loads on the heating and cooling systems, which were also placed in the attic. HPWHs should not be considered dehumidifiers if one is needed in an attic or basement/crawlspace. Ducting the HPWHs did not negatively impact performance compared to other published data of field performance. Changing duct configurations also did not alter the coefficient of performance. HPWHs in efficiency mode (heat pump only) could satisfy hot water demand for most residents. This mode maximizes energy efficiency. Adding .5 in. of insulated sheathing using the Huber ZIP System R Sheathing reduced peak summer temperatures and increased minimum winter temperatures inside the wall assemblies compared to the neighboring home. The neighboring home experienced significantly more risk of condensation and failed the American Society of Heating, Refrigerating and Air-Conditioning Engineers, Inc., Standard 160-2009: Criteria for Moisture-Control Design Analysis in Buildings. Despite the fact that energy modeling predicted only a 2% annual savings from the insulated sheathing, preliminary data indicate that reduced heating, ventilating, and air-conditioning runtimes and energy consumption attributed to this measure provide significantly greater savings. Additional research is necessary.

Array↗