Tuesday

TBON-FS: Scalable Group File Operations
Mike Brim, University of Wisconsin

Distributed systems for High-Performance Computing, corporate intranets, and cloud computing continue to increase in scale to meet the world's computational demands. The scale of these systems introduces new challenges for users, administrators, applications, and tools and middleware. One such challenge is performing the same file operations across large groups of files on distributed hosts. To address this challenge, we have defined a new idiom, group file operations, that is a natural, intuitive, and portable abstraction for performing file operations on groups, and designed TBON-FS, a scalable distributed file system supporting group file operations on thousands of distributed files.

This talk will briefly review the group file operation idiom and TBON-FS architecture, demonstrate how group file operations were used to create several parallel tools for management of distributed systems, and provide a glimpse into ongoing research.

Tree-based Parallel Smith-Waterman Gene Sequencing
Avrilia Floratou, University of Wisconsin

Biological sequence comparison is an important tool for researchers in molecular biology. There are several algorithms for sequence comparison, The Smith-Waterman algorithm, based on dynamic programming, is one of the most important algorithms in bioinformatics as it obtains the best local alignments. However, it is not widely used due to its huge memory requirements and high CPU demand. Several parallel implementations of the Smith-Waterman algorithm that improve its performance have been proposed. In this talk, I will present a tree-based Parallel Smith-Waterman algorithm that further improves performance by being deployed over a tree of distributed nodes.Moreover, we significantly reduce the memory space required in comparison with the existing parallel implementations. This study is an intense evaluation of MRNet as a vehicle to support scalable high-end application development.

Providing Order to Extreme Scale Debugging Chaos
Dong Ahn, Lawrence Livermore National Laboratory

HPC applications continue to grow in complexity, often combining large numbers of independent modules or libraries. Further, they require increasingly high numbers of processing cores to solve the largest and most demanding physics and mathematical problems. These trends significantly complicate application design, development, and testing. In particular, debugging, an integral part of the software development cycle, through this complexity and scale is becoming increasingly challenging. In this talk, we will present our recent work on the Stack Trace Analysis Tool (STAT), a debugging tool that aids in diagnosing correctness problems that emerge at large scale. We will first review the key concepts of this tool and our recent scalability opmitization work in which we identified and addressed some of the technical challenges that only surfaced at extreme scale. Then, we will present our on-going research that combines static and dynamic analysis techniques to provide increasingly fine-grain analyses, which includes the capability that scalably classifies MPI tasks based on their temporal order.

Using Dyninst to Detect Roundoff Error
Mike Lam, University of Maryland

Roundoff error is an artifact of floating-point representation and is a well-studied topic in numerical computing. Most efforts thus far have been devoted to calculating offline bounds for roundoff error, since inserting online error tracking into existing codes is error- prone and introduces a high performance penalty. We are exploring the possibility of using Dyninst to automatically insert floating-point error tracking, as well as to detect events such as cancellation that may cause a catastrophic loss of significance. We have developed a prototype and will discuss directions for future research.

Demo Session I
Binary Rewriting and DyninstAPI

Demo Session II

Static and Dynamic Code Discovery in Stripped Binaries

The ability to locate the code in a program binary is essential to all binary analysis tasks. Most techniques for identifying binary code are highly dependent on symbol information to find code in program binaries, and are ineffective on programs that have had their symbol information stripped away.

We will demonstrate the ability to statically identify code in stripped binaries by leveraging the regularity that exists in compiler-generated code. We identify function entry points based on a collection of patterns that we have extracted from large collections of program binaries using machine learning techniques. This information allows us to statically identify compiler-generated code with high coverage and accuracy.

75% of malicious programs contain code that is initially compressed or encrypted and is therefore only accessible to dynamic analysis. We will demonstrate a hybrid static and dynamic technique for discovering and analyzing the code in such programs. We identify code that is statically present in the binary using parsing techniques, and discover dynamically generated and modified code at runtime, producing a dynamically updated analysis of the code in the binary.

Demo Sessions III
Applications of Binary Slicing using Dyninst

This session demonstrates how Dyninst can be used for various static analysis techniques using binary slicing. We first demonstrate how Dyninst can construct DWARF tags for formal parameters in the function prologue. Then, we demonstrate how Dyninst can be used in eliminating unnecessary indirect calls by replacing them with direct calls; and in reducing the size of the binary by eliminating unreachable functions which were not removed by the compiler.

Demo Session IV
MRNet: Features Du Jour

In this demo, we will demonstrate the new MRNet facilities for performance data collection by monitoring a parallel Smith-Waterman MRNet application. Additionally, we will show off many parallel system administration tools built using TBON-FS, a system for group file operations layered over MRNet.