Next generation architectures and systems being deployed are characterized by high concurrency, low memory per-core, and multi-levels of hierarchy and heterogeneity. These characteristics bring out new challenges in energy efficiency, fault-tolerance and scalability. It is commonly believed that software has the biggest share of the responsibility to tackle these challenges. In other words, this responsibility is delegated to the next generation programming models and their associated middleware/runtimes. This workshop focuses on different aspects of programming models such as Task-based parallelism (X10, OCR, Habanero, Legion, Charm++, HPX), PGAS (OpenSHMEM, UPC, CAF, Chapel, etc.), Directive-based languages (OpenMP, OpenACC), Accelerator programming (CUDA, OpenCL), Hybrid MPI+X, etc. It also focuses on their associated middleware (unified runtimes, interoperability for hybrid programming, tight integration of MPI+X, support for accelerators) for next generation systems and architectures. Objective of ESPM2 workshop is to serve as a forum that brings together researchers from academia and industry to share knowledge and their experience, on working in the areas of programming models, runtime systems, compilation and languages, and application developers.

Topics of interest to the ESPM2 workshop include (but are not limited to):

  • New programming models, languages and constructs for exploiting high concurrency and heterogeneity
  • Experience with and improvements for existing parallel languages and run-time environments such as:
    • MPI
    • PGAS (OpenSHMEM, UPC, CAF, Chapel, UPC++, etc.)
    • Directive-based programming (OpenMP, OpenACC)
    • Asynchronous Task-based models (Charm++, OCR, Habanero, Legion, X10, HPX, etc)
    • Hybrid MPI+X models
    • BigData (Hadoop, Spark, etc), and
    • Deep Learning (Caffe, Microsoft CNTK, Google TensorFlow)
  • Parallel compilers, programming tools, and environments
  • Software and system support for extreme scalability including fault tolerance
  • Programming environments for heterogeneous multi-core systems and accelerators such as KNL, OpenPOWER, ARM, GPUs, FPGAs, MICs and DSPs

Papers should present original research and should provide sufficient background material to make them accessible to the broader community.

Workshop Program

8:45 - 9:00

Opening Remarks

9:00 - 10:00


Speaker: Katherine Yelick, UC Berkeley/LBNL

Title: Solved Problems, Unsolved Problems, and Non-Problems in Exascale Programming Models Slides

Abstract: For several years hardware experts have argued that exascale systems will be constrained by power density and total system energy, and will require new programming models and implementation strategies to achieve good performance. The programming models research community identified the need for fine-grained parallelism, asynchronous execution, one-sided communication, autotuning, communication-avoiding algorithms, dynamic scheduling, resilience and many other exascale solutions and exascale systems will look like and what major programming model challenges remain. The open problems include performance portability, trading off locality and load balancing, and avoiding synchronization and communication, along with correctness and resilience concerns. But I will argue that the next phase in exascale computing research needs to focus on science breakthroughs that will be enabled by these systems and the programming model problems that arise from the science. The applications are also evolving to use more complex multi-physics models and multiscale methods, to incorporate observational data into simulations, and to analyze complex scientific data sets.
I will briefly summarize the trends in computing hardware and emerging applications, will consider some of the programming models solutions, and identify the open questions and the various paths for transitioning successful research ideas intro production solutions to improve the productivity of scientific programmers and the performance of their programs. I will also, time permitting, look ahead at some of the challenges beyond exascale computing, where the energy challenges get worse, transistor density scaling ends, and more radical hardware architecture approaches may be needed.

10:00 - 10:30

Coffee Break

10:30 - 12:30

Research Paper Session I : Emerging Programming Models

Session Chair: Huo Zhigang - Institute of Computing Technology, Chinese Academy of Sciences, China

PPL: An Abstract Runtime System for Hybrid Parallel Programming, Alex Brooks, Hoang-Vu Dang, Nikoli Dryden and Marc Snir - (University of Illinois at Urbana-Champaign) Slides

ACPdl: Data-Structure and Global Memory Allocator Library over a Thin PGAS-Layer, Yuichiro Ajima, Takafumi Nose, Kazushige Saga, Naoyuki Shida and Shinji Sumimoto - (Fujitsu Limited) Slides

Fault Tolerance Features of a New Multi-SPMD Programming/Execution Environment, Miwako Tsuji (RIKEN AICS), Serge Petiton (CNRS/LIFL) and Mitsuhisa Sato (RIKEN AICS/University of Tsukuba) Slides

Higher-level Parallelization for Local and Distributed Asynchronous Task-Based Programming, Hartmut Kaiser (CCT/LSU), Thomas Heller, Daniel Bourgeois (CCT/LSU) and Dietmar Fey (Friedrich-Alexander-University) Slides

12:30 - 2:00

Lunch Break

2:00 - 2:30

Invited Talk

Speaker: Olivier Tardieu, Research Staff Member T.J. Watson Research Center, Yorktown, NY, USA

Title: Resilient and Elastic APGAS Slides

Abstract: The APGAS programming model (Asynchronous Partitioned Global Address Space) is a simple but powerful model of concurrency and distribution, known primarily as the foundation of the X10 programming language but also developed for Java and Scala. APGAS combines PGAS with asynchrony. The data in an application is logically partitioned into places. The computation is organized into lightweight asynchronous tasks. APGAS can express both regular and irregular parallelism, within and across shared-memory nodes in a distributed system. Recently APGAS has been enriched to support failure-aware and elastic programming. Resilient applications can detect the loss of a place and implement recovery strategies. Elastic applications can dynamically add places to a running instance. In this talk, I will give an introduction to resilient and elastic APGAS, discussing design principles, implementation efforts, and applications.

2:30 - 3:00

Research Paper Session II: GPU Computing

Session Chair: Khaled Hamidouche - The Ohio State University

The Scalable Petascale Data-Driven Approach for the Cholesky Factorization with Multiple GPUs, Yuki Tsujita (Tokyo Institute of Technology), Toshio Endo (Tokyo Institute of Technology/JST CREST) and Katsuki Fujisawa (Kyushu University/JST CREST) Slides

3:00 - 3:30

Coffee Break

3:30 - 4:00

Research Paper Session: Short Papers

Session Chair: Takeshi Nanri - Kyushu University, Japan

Hyper-Q-Aware Intranode MPI Collectives on the GPU, Iman Faraji and Ahmad Afsahi - (Queen's University) Slides

Task Characterization-driven Scheduling of Multiple Applications in a Task-based Runtime, Kavitha Chandrasekar (Georgia Institute of Technology), Balasubramanian Seshasayee (Intel Federal), Ada Gavrilovska (Georgia Institute of Technology) and Karsten Schwan (Georgia Institute of Technology) Slides

4:00 - 5:30

Panel Topic : Programming Models for Exascale Systems: What, When and How?

Panel Moderator : Karl Schulz, Intel Corporation

Panel Members:

5:30 - 5:40

Closing Remarks

Organizing Committee

Program Chairs

Program Committee

Image Gallery

Coming Soon!