scholarly journals Programming Heterogeneous Clusters with Accelerators Using Object-Based Programming

2011 ◽  
Vol 19 (1) ◽  
pp. 47-62 ◽  
Author(s):  
David M. Kunzman ◽  
Laxmikant V. Kalé
Keyword(s):  
Molecular Dynamics ◽  
High Performance ◽  
Programming Model ◽  
Runtime System ◽  
Heterogeneous Cluster ◽  
Heterogeneous Clusters ◽  
Cache Hierarchies ◽  
Object Based ◽  
Application Data ◽  
Performance Computing

Heterogeneous clusters that include accelerators have become more common in the realm of high performance computing because of the high GFlop/s rates such clusters are capable of achieving. However, heterogeneous clusters are typically considered hard to program as they usually require programmers to interleave architecture-specific code within application code. We have extended the Charm++ programming model and runtime system to support heterogeneous clusters (with host cores that differ in their architecture) that include accelerators. We are currently focusing on clusters that include commodity processors, Cell processors, and Larrabee devices. When our extensions are used to develop code, the resulting code is portable between various homogeneous and heterogeneous clusters that may or may not include accelerators. Using a simple example molecular dynamics (MD) code, we demonstrate our programming model extensions and runtime system modifications on a heterogeneous cluster comprised of Xeon and Cell processors. Even though there is no architecture-specific code in the example MD program, it is able to successfully make use of three core types, each with a different ISA (Xeon, PPE, SPE), three SIMD instruction extensions (SSE, AltiVec/VMX and the SPE's SIMD instructions), and two memory models (cache hierarchies and scratchpad memories) in a single execution. Our programming model extensions abstract away hardware complexities while our runtime system modifications automatically adjust application data to account for architectural differences between the various cores.

GPU-accelerated molecular dynamics: State-of-art software performance and porting from Nvidia CUDA to AMD HIP

2021 ◽  
pp. 109434202110082
Author(s):  
Nikolay Kondratyuk ◽  
Vsevolod Nikolskiy ◽  
Daniil Pavlov ◽  
Vladimir Stegailov
Keyword(s):  
Molecular Dynamics ◽  
High Performance ◽  
Software Performance ◽  
Computing Systems ◽  
Accelerated Molecular Dynamics ◽  
Nvidia Cuda ◽  
Software And Hardware ◽  
Management Capabilities ◽  
Utilization Time ◽  
Performance Computing

Classical molecular dynamics (MD) calculations represent a significant part of the utilization time of high-performance computing systems. As usual, the efficiency of such calculations is based on an interplay of software and hardware that are nowadays moving to hybrid GPU-based technologies. Several well-developed open-source MD codes focused on GPUs differ both in their data management capabilities and in performance. In this work, we analyze the performance of LAMMPS, GROMACS and OpenMM MD packages with different GPU backends on Nvidia Volta and AMD Vega20 GPUs. We consider the efficiency of solving two identical MD models (generic for material science and biomolecular studies) using different software and hardware combinations. We describe our experience in porting the CUDA backend of LAMMPS to ROCm HIP that shows considerable benefits for AMD GPUs comparatively to the OpenCL backend.

Computational Steering of Interactive Material Flow Simulations

2008 ◽  
Author(s):  
Stefan Lietsch ◽  
Christoph Laroque ◽  
Henning Zabel
Keyword(s):  
Fluid Dynamics ◽  
Molecular Dynamics ◽  
Material Flow ◽  
High Performance ◽  
Flow Simulation ◽  
Computational Steering ◽  
Flow Simulations ◽  
Distributed Simulations ◽  
Computational Fluid Dynamics Cfd ◽  
Performance Computing

In this paper we present the integration of computational steering techniques into the interactive material flow simulation d3FACT insight. This kind of simulation differs from traditional, long running High Performance Computing (HPC) simulations such as Computational Fluid Dynamics (CFD) or Molecular Dynamics in many aspects. One very important aspect is that these simulations run in (soft) real-time, thus the corresponding visualization needs to be updated after every step of the simulation. In turn, this allows to let changes, made through the visualization, impact the actual simulation and again, to see the effects in visualization. To allow this kind of control over the simulation and to further provide a flexible basis to integrate several instances of simulation, visualization and steering components, we used and enhanced a self-developed computational steering platform, which fits best for the needs of highly interactive and distributed simulations. Thereby we are able to realize multi-user and comparative scenarios which were not possible in this field of simulations before.

scholarly journals Experiences Using Hybrid MPI/OpenMP in the Real World: Parallelization of a 3D CFD Solver for Multi-Core Node Clusters

2010 ◽  
Vol 18 (3-4) ◽  
pp. 127-138 ◽  
Author(s):  
Gabriele Jost ◽  
Bob Robins
Keyword(s):  
Real World ◽  
High Performance ◽  
Programming Model ◽  
Hybrid Approach ◽  
Underwater Vehicles ◽  
Core Node ◽  
Real World Application ◽  
Hardware Platforms ◽  
Control Surfaces ◽  
Performance Computing

Today most systems in high-performance computing (HPC) feature a hierarchical hardware design: shared-memory nodes with several multi-core CPUs are connected via a network infrastructure. When parallelizing an application for these architectures it seems natural to employ a hierarchical programming model such as combining MPI and OpenMP. Nevertheless, there is the general lore that pure MPI outperforms the hybrid MPI/OpenMP approach. In this paper, we describe the hybrid MPI/OpenMP parallelization of IR3D (Incompressible Realistic 3-D) code, a full-scale real-world application, which simulates the environmental effects on the evolution of vortices trailing behind control surfaces of underwater vehicles. We discuss performance, scalability and limitations of the pure MPI version of the code on a variety of hardware platforms and show how the hybrid approach can help to overcome certain limitations.

scholarly journals Scalability of DL_POLY on High Performance Computing Platform

2017 ◽  
Vol 29 (3) ◽  
Author(s):  
Mabule Samuel Mabakane ◽  
Daniel Mojalefa Moeketsi ◽  
Anton Lopis
Keyword(s):  
Molecular Dynamics ◽  
High Performance Computing ◽  
High Performance ◽  
Computing Platform ◽  
Speed Up ◽  
Linux Cluster ◽  
Large Systems ◽  
Performance Computing ◽  
Better Than

This paper presents a case study on the scalability of several versions of the molecular dynamics code (DL_POLY) performed on South Africa‘s Centre for High Performance Computing e1350 IBM Linux cluster, Sun system and Lengau supercomputers. Within this study different problem sizes were designed and the same chosen systems were employed in order to test the performance of DL_POLY using weak and strong scalability. It was found that the speed-up results for the small systems were better than large systems on both Ethernet and Infiniband network. However, simulations of large systems in DL_POLY performed well using Infiniband network on Lengau cluster as compared to e1350 and Sun supercomputer.

Programming Paradigms in High Performance Computing

2015 ◽  
pp. 303-330
Author(s):  
Venkat N Gudivada ◽  
Jagadeesh Nandigam ◽  
Jordan Paris
Keyword(s):  
Shared Memory ◽  
High Performance ◽  
Programming Model ◽  
Commodity Prices ◽  
Massive Datasets ◽  
Programming Techniques ◽  
Performance Programming ◽  
High Performance Computers ◽  
Programming Paradigms ◽  
Performance Computing

Availability of multiprocessor and multi-core chips and GPU accelerators at commodity prices is making personal supercomputers a reality. High performance programming models help apply this computational power to analyze and visualize massive datasets. Problems which required multi-million dollar supercomputers until recently can now be solved using personal supercomputers. However, specialized programming techniques are needed to harness the power of supercomputers. This chapter provides an overview of approaches to programming High Performance Computers (HPC). The programming paradigms illustrated include OpenMP, OpenACC, CUDA, OpenCL, shared-memory based concurrent programming model of Haskell, MPI, MapReduce, and message-based distributed computing model of Erlang. The goal is to provide enough detail on various paradigms to help the reader understand the fundamental differences and similarities among the paradigms. Example programs are chosen to illustrate the salient concepts that define these paradigms. The chapter concludes by providing research directions and future trends in programming high performance computers.

scholarly journals Transparent fault tolerance for scalable functional computation

2016 ◽  
Vol 26 ◽  
Author(s):  
ROBERT STEWART ◽  
PATRICK MAIER ◽  
PHIL TRINDER
Keyword(s):  
Fault Tolerance ◽  
High Performance Computing ◽  
High Performance ◽  
Large Scale ◽  
Programming Model ◽  
Fault Tolerant ◽  
Fault Recovery ◽  
Actor Model ◽  
Work Stealing ◽  
Performance Computing

AbstractReliability is set to become a major concern on emergent large-scale architectures. While there are many parallel languages, and indeed many parallel functional languages, very few address reliability. The notable exception is the widely emulated Erlang distributed actor model that provides explicit supervision and recovery of actors with isolated state. We investigate scalable transparent fault tolerant functional computation with automatic supervision and recovery of tasks. We do so by developing HdpH-RS, a variant of the Haskell distributed parallel Haskell (HdpH) DSL with Reliable Scheduling. Extending the distributed work stealing protocol of HdpH for task supervision and recovery is challenging. To eliminate elusive concurrency bugs, we validate the HdpH-RS work stealing protocol using the SPIN model checker. HdpH-RS differs from the actor model in that its principal entities are tasks, i.e. independent stateless computations, rather than isolated stateful actors. Thanks to statelessness, fault recovery can be performed automatically and entirely hidden in the HdpH-RS runtime system. Statelessness is also key for proving a crucial property of the semantics of HdpH-RS: fault recovery does not change the result of the program, akin to deterministic parallelism. HdpH-RS provides a simple distributed fork/join-style programming model, with minimal exposure of fault tolerance at the language level, and a library of higher level abstractions such as algorithmic skeletons. In fact, the HdpH-RS DSL is exactly the same as the HdpH DSL, hence users can opt in or out of fault tolerant execution without any refactoring. Computations in HdpH-RS are always as reliable as the root node, no matter how many nodes and cores are actually used. We benchmark HdpH-RS on conventional clusters and an High Performance Computing platform: all benchmarks survive Chaos Monkey random fault injection; the system scales well e.g. up to 1,400 cores on the High Performance Computing; reliability and recovery overheads are consistently low even at scale.

On the performance of molecular dynamics applications on current high-end systems

2005 ◽  
Vol 363 (1833) ◽  
pp. 1987-1998 ◽  
Author(s):  
Joachim Hein ◽  
Fiona Reid ◽  
Lorna Smith ◽  
Ian Bush ◽  
Martyn Guest ◽  
...  
Keyword(s):  
Molecular Dynamics ◽  
High Performance Computing ◽  
Molecular Simulation ◽  
High Performance ◽  
Replicated Data ◽  
Present Generation ◽  
Parallel Molecular Dynamics ◽  
Performance Computing ◽  
Simulation Codes

The effective exploitation of current high performance computing (HPC) platforms in molecular simulation relies on the ability of the present generation of parallel molecular dynamics code to make effective utilisation of these platforms and their components, including CPUs and memory. In this paper, we investigate the efficiency and scaling of a series of popular molecular dynamics codes on the UK's national HPC resources, an IBM p690+ cluster and an SGI Altix 3700. Focusing primarily on the Amber , Dl_Poly and Namd simulation codes, we demonstrate the major performance and scalability advantages that arise through a distributed, rather than a replicated data approach.

Sign in / Sign up

Export Citation Format

Share Document