A User-level Intro to EMSL Cascade Supercomputer by Amity Andersen

Download: PDF

IDEAs Webinar Series

Session 1

What All Codes Should Do: Overview of Best Practices in HPC Software Development

This presentation will describe the lifecycle of scientific software and important ways in which it differs from other software development. We will provide a compilation of software engineering best practices that have generally been found to be useful by science communities, and we will provide guidelines for adoption of practices based on the size and the scope of the project.

Session 2

Developing, Configuring, Building, and Deploying HPC Software Developing, Configuring, Building, and Deploying HPC Software

This presentation will provide an overview of development environments and how to configure, build, and deploy HPC software using some of the tools that are frequently used in the community. We will also discuss ways in which these and other tools are best utilized by various categories of scientific software developers, ranging from small teams through moderate/large teams.

Session 3

Distributed Version Control and Continuous Integration Testing

This presentation will discuss how to set up a project on GitHub, illustrate the use of pull requests to incorporate code changes, and show how Travis CI can be used to boost confidence that changes will not break existing code.

Session 4

Testing and Documenting your Code

This presentation will provide guidelines on testing and documentation that can help to ensure high-quality and long-lived HPC software. We will present methodologies, with examples, for developing tests and adopting regular automated testing. We also will provide guidelines for minimum, adequate, and good documentation practices depending on the available resources of the development team.

Session 5

How the HPC Environment is Different from the Desktop (and Why)

This talk will discuss how supercomputers are unique and explain how that impacts their use.

Session 6

An Introduction to High-Performance Parallel I/O

This talk will introduce the basic parallel I/O concepts and will provide guidelines on obtaining better I/O performance on large-scale parallel platforms.

Session 7

Basic Performance Analysis and Optimization – An Ant Farm Approach

This presentation discusses the basic concepts around optimizing code for the HPC systems of today and tomorrow. We’ll discuss profiling strategies, tools (for profiling and debugging) and common issues with both internode communication and on-node parallelism. We will give an overview of traditional optimizations areas in HPC applications like parallel IO and MPI strong and weak scaling as well as topics relevant for modern GPU and many-core systems like threading, SIMD/AVX, SIMT and effectively using cache and memory hierarchies.

Session 8

Python in HPC

Python’s powerful elegance has driven its adoption at HPC centers for job orchestration, visualization, exploratory data analysis, and even simulation. But maximizing performance from Python applications can be challenging especially on supercomputing architectures. This webinar will explain those challenges with a practical emphasis on using Python at NERSC, ALCF, and OLCF. We will outline a variety of performance optimization strategies, tools for measuring and addressing performance problems, and establish best practices for Python in HPC.

Session 9

Intermediate Git

This presentation will emphasize intermediate-level tutorial and reference information about the Git version control (VC) system. This overview takes the view that the best way to learn to use Git effectively is to learn it as a data structure and a set of algorithms to manipulate that data structure. This perspective is important because the Git command-line interface is widely considered to be overly complex and confusing. For example, a Git command like ‘checkout’ can do wildly different things depending on the other arguments passed into the command or the state of the Git repository. But Git is still the dominant VC system; many people consider that Git has won the version control wars due to its power and flexibility.

Session 10

Using the Roofline Model and Intel Advisor

In this webinar, we will begin by introducing the Roofline Model and its “Cache-Aware” variant. We will proceed with some general guidelines and historical approaches to Roofline-based program analysis. Next, we will provide a short discussion of how changes in data locality and arithmetic intensity of two canonical benchmarks visually manifest in the context of these two Roofline formulations. Subsequently, we will provide two demonstrations of using Intel Advisor and the Roofline model within Intel Advisor. The first demo will be primarily instructive on how to compile, benchmark, and use Advisor. The second demo will focus on using variants of a simple benchmark to highlight changes in the Roofline model as well as providing correlation to Advisor’s other capabilities. We will conclude with a few comments on future directions.

Session 11

Barely Sufficient Project Management: A few techniques for improving your scientific software development efforts

Software development is an essential activity for many scientific teams. Modeling, simulation and data analysis, using team-developed software, are increasing valuable for scientific discovery and engineering. Many teams use informal, ad hoc approaches for managing their software efforts. While sufficient for many efforts, a modest emphasis on team models and processes c an substantially improve developer productivity and software sustainability. In this presentation, we discuss several light-weight techniques for managing scientific software efforts. Using checklists, policy statements and a Kanban workflow system, we emphasize techniques for managing the initiation and exit of team members, approaches to synthesizing team culture, and ways to improve communication within a team and with its stakeholders.