Scalable Tools Workshop

Software Tools for Mixed-Precision Program Analysis

Mike Lam

Abstract

Floating-point representation and arithmetic remain the predominant mechanism for real-valued computation despite many well-known issues such as roundoff error. As high-performance computing continues to scale, many computational scientists are seeking to reduce precision when possible to accelerate performance and alleviate memory requirements. In this talk, I will describe my recent work that seeks to facilitate such reduction of precision or in some other way provide insights about the accuracy or behavior of floating-point code, including a recent experimental prototype of an end-to-end source-level mixed-precision tuning system for HPC codes.

Pavilion 2.0: A Scalable Tool For Testing Large Scale Systems

Paul Ferrell

Abstract

PMU and Linux perf_events

Stefane Eranian

Abstract

There are new features in Icelake PMU which are very good. Also, time depending, I may be able to discuss data profiling. (to be updated)

Utilizing the Latest Features of Intel's Performance Monitoring Unit

Mike Chynoweth

Abstract

We will demonstrate some new methodologies we have developed for usage of the performance monitoring unit to debug difficult performance issues. New features including Timed Last Branch Records, Adaptive Precise Event Based Sampling and Extended PEBS will be utilized to debug real performance issues encountered and fixed in software.

Does your tool support PAPI SDEs yet?

Anthony Danalis

Abstract

In the past, PAPI development had focused primarily on hardware-specific performance metrics. However, the rapidly increasing complexity of software infrastructure poses new measurement and analysis challenges for the developers of large-scale applications that make use of external libraries and runtimes. In this talk, we will discuss our efforts to extend PAPI's role so that it becomes the de facto standard for exposing Software-Defined Events (SDEs), or in other words performance-critical events that originate from within layers of the software stack. Extending PAPI with SDEs enables tools to acquire a more complete picture regarding application performance, by monitoring both types of performance events---hardware and software---in a uniform way, through the same consistent PAPI interface. In addition to describing the functionality we offer through PAPI's SDE interface, we will show examples of how SDEs have been utilized by different software packages, and provide a thorough performance analysis of the overhead that results from inserting SDEs into performance critical codes.

Diogenes: Looking For An Honest CPU/GPU Performance Measurement Tool

Ben Welton,

Abstract

A Tool for Performance Analysis of GPU-Accelerated Applications

Keren Zhou

Abstract

ASSIST: Using performance analysis tools for driving Feedback Directed Optimization

William Jalby

Abstract

A Common Tools Interface as an MPIR Alternative

Andrew Gontarek

Abstract

The Common Tools Interface (CTI) is an infrastructure framework focused on enabling tool developers to interact with, and run tool daemons alongside, applications on HPC systems. CTI is a collection of interfaces along with underlying utilities that export services for use by tools. The goal of CTI is to define a set of interfaces that provide a tight semantic mapping between tools and the underlying HPC system. Tools have a common set of core functionality required during bootstrapping to start daemons alongside running application processes. CTI enables vendors to provide underlying implementations invisible to the interfacing tool to rapidly enable support on their systems. CTI was inspired by the MPIR Process Acquisition Interface and is meant to be a more robust replacement. A problem with the current MPIR design is that a tool is required to ptrace attach onto the starter process in order to harvest information about the running application. This is not a good fit for current HPC system designs. Some systems allow for intermediary nodes between where the user starts their application and where the starter process is actually run, requiring tools to route themselves to the node where the starter process resides. CTI solves this by providing an abstract API that allows the underlying implementation to handle the details transparent to the tool. Cray recently open sourced CTI as a reference implementation that can be used to explore future work related to defining a cross vendor tool interface suited for the modern era of HPC systems.

Optimizing Memory Bandwidth by Exploring Cache Utilization Efficiency at a Sub Cache-line Level

Ben Woodard, Will Cohen

Abstract

Hatchet: Pruning the Overgrowth in Parallel Profiles

Abhinav Bhatele

Abstract

Performance analysis of parallel codes is critical to ensure high efficiency and scalability to large process counts. A large number of profiling tools exist to instrument codes and gather performance data. However, analytics and visualization tools to analyze such data that are effective, easy-to-use, and programmable are limited. In this paper, we focus on the analytics of structured profiling data such as that obtained from calling context trees or nested region timers in the code. We present a set of techniques and operations that leverage modern data analysis libraries for parallel profile analysis. We have implemented these techniques in a Python-based library called Hatchet, that allows structured data to be filtered, aggregated, and pruned. Using performance datasets obtained from profiling parallel codes, we demonstrate how common performance analyses can be performed in a reproducible manner with only a few lines of Hatchet code.