Search

Reproducibility of results is a cornerstone of the scientific method. Scientific computing encounters two challenges when aiming for this goal. Firstly, reproducibility should not depend on details of the runtime environment, such as the compiler version or computing environment, so results are verifiable by third-parties. Secondly, different versions of software code executed in the same runtime environment should produce consistent numerical results for physical quantities. In this manuscript, we test the feasibility of reproducing scientific results obtained using the IllinoisGRMHD code that is part of an open-source community software for simulation in relativistic astrophysics, the Einstein Toolkit. We verify that numerical results of simulating a single isolated neutron star with IllinoisGRMHD can be reproduced, and compare them to results reported by the code authors in 2015. We use two different supercomputers: Expanse at SDSC, and Stampede2 at TACC. By compiling the source code archived along with the paper on both Expanse and Stampede2, we find that IllinoisGRMHD reproduces results published in its announcement paper up to errors comparable to round-off level changes in initial data parameters. We also verify that a current version of IllinoisGRMHD reproduces these results once we account for bug fixes which have occurred since the original publication. [ABSTRACT FROM AUTHOR]

Python is becoming increasingly popular in scientific computing. The package MPI for Python (mpi4py) allows writing efficient parallel programs that scale across multiple nodes. However, it does not support non-contiguous data via slices, which is a well-known feature of NumPy. In this work, we therefore evaluate several methods to support the direct transfer of non-contiguous arrays in mpi4py. This significantly simplifies the code, while the performance basically stays the same. In a PingPong-, Stencil- and Lattice-Boltzmann-Benchmark, we compare the common manual copying, a NumPy-Copy design and a design that is based on MPI derived datatypes. In one case, the MPI derived datatype design could achieve a speedup of 15% in a Stencil-Benchmark on four compute nodes. Our designs are superior to naive manual copies, but for maximum performance manual copies with pre-allocated buffers or MPI persistent communication will be a better choice. [ABSTRACT FROM AUTHOR]

Since simulation became the third pillar of scientific research, several forms of computers have become available to drive computer aided simulations, and nowadays, clusters are the most popular type of computers supporting these tasks. For instance, cluster settings, such as the so-called supercomputers, cluster of workstations (COW), cluster of desktops (COD), and cluster of virtual machines (COV) have been considered in literature to embrace a variety of scientific applications. However, those scientific applications categorized as high-performance computing (HPC) are conceptually restricted to be addressed only by supercomputers. In this aspect, we introduce the notions of cluster overhead and cluster coupling to assess the capacity of non-HPC systems to handle HPC applications. We also compare the cluster overhead with an existing measure of overhead in computing systems, the total parallel overhead, to explain the correctness of our methodology. The evaluation of capacity considers the seven dwarfs of scientific computing, which are well-known, scientific computing building blocks considered in the development of HPC applications. The evaluation of these building blocks provides insights regarding the strengths and weaknesses of non-HPC systems to deal with future HPC applications developed with one or a combination of these algorithmic building blocks. [ABSTRACT FROM AUTHOR]

In this work, we have analyzed the input/output (I/O) activities of Cori, which is a high-performance computing system at the National Energy Research Scientific Computing Center at Lawrence Berkeley National Laboratory. Our analysis results indicate that most users do not adjust storage configurations but rather use the default settings. In addition, owing to the interference from many applications running simultaneously, the performance varies based on the system status. To configure file systems autonomously in complex environments, we developed DCA-IO, a dynamic distributed file system configuration adjustment algorithm that utilizes the system log information to adjust storage configurations automatically. Our scheme aims to improve the application performance and avoid interference from other applications without user intervention. Moreover, DCA-IO uses the existing system logs and does not require code modifications, an additional library, or user intervention. To demonstrate the effectiveness of DCA-IO, we performed experiments using I/O kernels of real applications in both an isolated small-sized Lustre environment and Cori. Our experimental results shows that our scheme can improve the performance of HPC applications by up to 263% with the default Lustre configuration. [ABSTRACT FROM AUTHOR]

Large simulations with many independent sub-simulations are common in scientific computing. There are numerous challenges, however, associated with performing such simulations in shared computing environments. For example, sub-simulations may have wildly varying completion times or not complete at all, leading to unpredictable runtimes as well as unbalanced and inefficient use of human and computational resources. In this study, we use the actor model of concurrent computation to improve both the resource utilization and fault tolerance for large-scale scientific computing simulations. More specifically, we use actors in the SUMMA model to manage a large-scale hydrological simulation over the North American continent with over 500,000 independent sub-simulations. We find that the actors implementation outperforms a standard array job submission as well as the job submission tool GNU Parallel by better balancing the computational load across processors. The actors implementation also improves fault tolerance and can eliminate the user intervention required to detect and re-submit failed jobs. [ABSTRACT FROM AUTHOR]

The efficient utilization of mixed-precision numerical linear algebra algorithms can offer attractive acceleration to scientific computing applications. Especially with the hardware integration of low-precision special-function units designed for machine learning applications, the traditional numerical algorithms community urgently needs to reconsider the floating point formats used in the distinct operations to efficiently leverage the available compute power. In this work, we provide a comprehensive survey of mixed-precision numerical linear algebra routines, including the underlying concepts, theoretical background, and experimental results for both dense and sparse linear algebra problems. [ABSTRACT FROM AUTHOR]

Data analytics has become an integral part of large-scale scientific computing. Among various data analytics frameworks, MapReduce has gained the most traction. Although some efforts have been made to enable efficient MapReduce for supercomputing systems, they are often limited to fairly homogeneous workloads where equal partitioning of input data across tasks results in essentially equal output or temporary data generated on each task. For workloads that are more skewed, however, current implementations can result in imbalance in memory usage and, consequently, can cause a slowdown in execution time and a loss in data scalability. To tackle this problem, we enhance a previously published memory-conscious MapReduce over MPI framework called Mimir. Our enhancements to Mimir include combiner and dynamic repartition optimizations to minimize and balance memory usage and to achieve close to optimal balance of the memory usage across processes and to reduce the execution time by up to 12 times. Experimental results show that Mimir can scale to at least 3072 processes on the Tianhe-2 supercomputer on skewed datasets. [ABSTRACT FROM AUTHOR]

Abstract The advection-reaction-diffusion equation is a rather general model that describes a variety of environmental processes, such as air pollution transport, aquifer recharge, groundwater contaminant transport and forest growth, among others. The resulting models are known to be computationally demanding, especially when the model covers large areas where in high resolution. In this context, the exponential increase in computational power of massively parallel computing devices, such as the General Purpose Graphics Processing Units (GPGPUs), has triggered a paradigm shift in scientific computing and environmental modelling. In this paper we present an environmental modelling solution based on a parallel implementation of the 2D advection-reaction-diffusion equation, tailored for GPGPU devices. The software is flexible, free, open-source and allows the modelling of a wide range of environmental phenomena, including those taking place in heterogeneous and anisotropic media. Performance tests show that the parallel GPU implementation can provide up to a 70-fold speedup in relation to an analogous CPU implementation. Highlights • PARMOD2D can be applied to a broad class of environmental models based on the Advection-Reaction-Diffusion equation. • The GPGPU-accelerated implementation provides up to a 70-fold speedup in processing time. • This GPGPU-accelerated framework for environmental models can deliver fast and accurate solutions to large-scale grids. [ABSTRACT FROM AUTHOR]

Abstract The development of practical quantum computers that can be used to solve real-world problems is in full swing driven by the ambitious expectation that quantum supremacy will be able to outperform classical super-computers. Like with any emerging compute technology, it needs early adopters in the scientific computing community to identify problems of practical interest that are suitable as proof-of-concept applications and to revise existing solution strategies and develop new ones that exploit the capabilities of the novel compute hardware. In this article we describe a conceptual framework for reducing the computational complexity of simulation-driven automated design optimization processes, which are nowadays widely used in computer-aided product development, by exploiting quantum supremacy. Our approach is based on the assumption that quantum computers will become part of hybrid high-performance computing platforms and can then be used as application-specific accelerator devices. [ABSTRACT FROM AUTHOR]

A panel of experts--including Gordon Bell, Jack Dongarra, William E. (Bill) Johnston, Horst Simon, Erich Strohmaier, and Mateo Valero--discuss historical reflections on the past 30 years of the Supercomputing (SC) conference, its leading role for the professional community and some exciting future challenges. [ABSTRACT FROM AUTHOR]

We present a domain-decomposition-based preconditioner for the solution of partial differential equations (PDEs) that is resilient to both soft and hard faults. The algorithm reformulates the PDE as a sampling problem, followed by a solution update through data manipulation that is resilient to both soft and hard faults. This reformulation allows us to recast the problem as a set of independent tasks, and exploit data locality to reduce global communication. We discuss two different parallel implementations: (a) a single program multiple data (SPMD) version based on a one-to-one mapping between subdomain and MPI processes responsible for both state and computation; and (b) an asynchronous server–client implementation where all state information is held by the servers and clients are designed solely as computational units. We present a scalability comparison of both implementations under nominal conditions, showing efficiency within ~80% for up to 12,000 cores. We present a resilience analysis under different fault scenarios based on the server–client implementation. This framework provides resiliency to hard faults such that if a client crashes, it stops asking for work, and the servers simply distribute the work among all of the other clients alive. Erroneous subdomain solves (e.g. due to soft faults) appear as corrupted data, which is either rejected if that causes a task to fail, or is seamlessly filtered out during the regression stage through a suitable noise model. Three different types of faults are modeled: hard faults modeling nodes (or clients) crashing; soft faults occurring during the communication of the tasks between server and clients; and soft faults occurring during task execution. We demonstrate the resiliency of the approach for a 2D elliptic PDE, and explore the effect of the faults at various failure rates. [ABSTRACT FROM AUTHOR]

MADNESS (multiresolution adaptive numerical environment for scientific simulation) is a high-level software environment for solving integral and differential equations in many dimensions that uses adaptive and fast harmonic analysis methods with guaranteed precision that are based on multiresolution analysis and separated representations. Underpinning the numerical capabilities is a powerful petascale parallel programming environment that aims to increase both programmer productivity and code scalability. This paper describes the features and capabilities of MADNESS and briefly discusses some current applications in chemistry and several areas of physics. [ABSTRACT FROM AUTHOR]

As the scale of quantum molecular dynamics simulations has grown in time and system size, QMD codes must increase intranode and instruction-level parallelism to take advantage of emerging supercomputer architectures. The authors present one promising parallelization approach and illustrate its success on one of the world's most powerful systems. [ABSTRACT FROM AUTHOR]

For more than two decades, the TOP500 list has enjoyed incredible success as a metric for supercomputing performance and as a source of data for identifying technological trends. The project's editors reflect on its usefulness and limitations for guiding large-scale scientific computing into the exascale era. [ABSTRACT FROM AUTHOR]

Many scientific computing applications and engineering simulations exhibit noncontiguous I/O access patterns. Data sieving is an important technique to improve the performance of noncontiguous I/O accesses by combining small and noncontiguous requests into a large and contiguous request. It has been proven effective even though more data are potentially accessed than demanded. In this study, we propose a new data sieving approach namely performance model-directed data sieving, or PMD data sieving in short. It improves the existing data sieving approach from two aspects: (1) dynamically determines when it is beneficial to perform data sieving; and (2) dynamically determines how to perform data sieving if beneficial. It improves the performance of the existing data sieving approach considerably and reduces the memory consumption as verified by both theoretical analysis and experimental results. Given the importance of supporting noncontiguous accesses effectively and reducing the memory pressure in a large-scale system, the proposed PMD data sieving approach in this research holds a great promise and will have an impact on high-performance I/O systems. [ABSTRACT FROM AUTHOR]

Creating the next-generation high-performance simulation and analysis environment will be a significant challenge because of power and storage technology trends. Responding to these challenges will require rethinking and reframing how we approach visualization and analysis. A key difference is the need to keep track of a cost per insight in terms of power and storage used. To reduce power and storage costs, an emerging community consensus is that significantly more visualization and analysis should occur in situ--that is, during the simulation run while the data is resident in memory. Using this approach, we need to consider what scientific insights are sought, balanced by power and storage constraints, and then output only the minimal analysis data needed during the simulation run. Emerging research challenges include exploring what types of analysis questions can be answered during postprocessing with compact data products that are generated in situ and what mathematical or statistical techniques will best support this process. [ABSTRACT FROM PUBLISHER]

Power consumption is one of the main challenges to achieve Exascale performance. Current research trends aim at overcoming power consumption constraints using low‐power processors. Although new processors feature sensors that enable precise power measurements, they provide different interfaces to collect data, making it difficult to correlate performance with energy consumption. To overcome this issue, the authors developed a platform‐independent tool that collects power and energy data from homogeneous and heterogeneous systems. Using this tool, they provide a detailed comparison between a low‐power processor (ARM big.LITTLE) and a high performance processor (Intel Sandy Bridge‐EP) using all applications from the NAS parallel benchmarks and a real‐world soil irrigation simulator. The results show that the average power demand of Intel Sandy Bridge‐EP is within 12.6× to 152.4× higher than ARM big.LITTLE, whereas its average energy consumption is within 1.6× to 7.1× superior. Overall, ARM big.LITTLE presented a better performance/energy trade‐off when it takes <9.2× the execution time of Intel Sandy Bridge‐EP to solve the same problem. [ABSTRACT FROM AUTHOR]

To study the evolution of small solar system bodies like asteroids and comets, a fast method is needed to compute the self-gravity of systems composed of millions of particles. A proposed fully parallel shared-memory algorithm for dense, self-gravitating agglomerates scales efficiently with the number of particles as well as the number of computational resources. [ABSTRACT FROM PUBLISHER]

High-performance scientific applications are usually built from software modules written in multiple programming languages. This raises the issue of language interoperability which involves making calls between languages, converting basic types, and bridging disparate programming models. Babel provides a feature-rich, extensible, high-performance solution to the language interoperability problem currently supporting C, C++, FORTRAN 77, Fortran 90/95, Fortran 2003/2008, Python, and Java. Babel supports object-oriented programming features and interface semantics with runtime enforcement. In addition to in-process language interoperability, Babel includes remote method invocation to support hybrid parallel and distributed computing paradigms. [ABSTRACT FROM AUTHOR]

Scientific frontiers--astrophysics, whole genome sequencing, tectonic modeling, and so on--demand faster and bigger computers to analyze an avalanche of data and advance our knowledge. A quest for answers to these grand scientific challenges is the main motivation behind developing and building exascale supercomputers and beyond. [ABSTRACT FROM AUTHOR]

We advocate domain‐specific virtual processors (DSVP) as a portability layer for expressing and executing domain‐specific computational workloads on modern heterogeneous HPC architectures, with applications in quantum chemistry. Specifically, in this article we extend, generalize and better formalize the concept of a domain‐specific virtual processor as applied to scientific high‐performance computing. In particular, we introduce a system‐wide recursive (hierarchical) hardware encapsulation mechanism into the DSVP architecture and specify a concrete microarchitectural design of an abstract DSVP from which specialized DSVP implementations can be derived for specific scientific domains. Subsequently, we demonstrate, an example of a domain‐specific virtual processor specialized to numerical tensor algebra workloads, which is implemented in the ExaTENSOR library developed by the author with a primary focus on the quantum many‐body computational workloads on large‐scale GPU‐accelerated HPC platforms. [ABSTRACT FROM AUTHOR]

The computational requirements of simulating a sector of the universe led an international team of researchers to try concurrent processing on two supercomputers half a world apart. Data traveled nearly 27,000 km in 0.277 second, crisscrossing two oceans to go from Amsterdam to Tokyo and back. [ABSTRACT FROM PUBLISHER]