Monday Schedule

Overheads from instrumentation can be costly. As usage of DyninstAPI has trended towards more pervasive instrumentation (e.g, instrumenting every memory access in an application), controlling overhead costs for instrumentation has become more important. This talk will discuss a range of optimizations that have significantly reduced the overheads of DyninstAPI optimizations.

Abstract:

To analyze program performance using event traces it is required to instrument
the program with calls to the measurement library. For program
instrumentation, tools may make use of Dyninst's ability to rewrite a binary
program at execution time or statically rewriting it before execution. Some
tools have already provided instrumentation tools tailored to their specific
needs.

Analyzing current requirements for instrumentation with respect to selectivity
on the instrumentation side and configurability on the adapter side, we
provide an instrumentation tool that is configurable on both sides. This
gives the user the possibility to specify what he wants to instrument,
choosing between function instrumentation, call site instrumentation and loop
instrumentation. The tool itself tries to limit the instrumented code regions
to a reasonable level, evaluating call path information and if proven useful
other metrics applied to information available through Dyninst. In addition
the user may choose to write his own filter to restrict the instrumentation
of the program to regions of his or her interest.

The configurability on the adapter side gives tool developers the
possibility to write their own code to be inserted to make use of their existing
measurement library functions.

The current state of the tool will be presented including a short live
demonstration.

Abstract:

Binary instrumenters must ensure that instrumenting a program does not unexpectedly change its behavior. This is frequently complicated by the structural modifications required to inject new code into the binary. Current instrumenters rely on ad-hoc approximations of the impact of instrumenting a program on its behavior; as a result they may fail to correctly preserve its behavior or impose unnecessary overhead on the instrumented binary. We discuss an instrumentation technique, based on a formal specification of instrumentation, that guarantees preservation of visible behavior while frequently imposing lower overhead than current tools.

Abstract:

Complex software systems use many shared libraries frequently composed of large off-the-shelf components. Only a limited number of functions are used from these shared libraries. Historically demand paging prevented this from wasting large amounts of memory. Many high end systems lack virtual memory and thus must load the entire shared library into each node's memory. In this talk we demonstrate a system which decreases the memory footprint of applications by selectively loading only the used portions of the shared libraries. After profiling executables and shared libraries, our system rewrites all target shared libraries with a new function ordering and updated ELF program headers so that the loader only loads those functions that are likely to be used by a given application and includes a fallback user-level paging system to recover in the case of failures in our analysis. We present a case study that shows our system achieves more than 80% reduction in the number of pages that are loaded for several HPC applications while causing no performance overhead for reasonably long running programs.

Abstract:

This talk will describe two scalable tools developed at Livermore: Libra, a scalable load-balance analysis tool, and CAPEK: a clustering algorithm for massively distributed data. The parallel algorithms used in these tools are currently written in MPI and analyze data from hundreds of thousands or more processes. The focus of the talk will be on the infrastructure challenges faced in the design of these tools, particularly the use of StackwalkerAPI and SymtabAPI within Libra. We will also discuss potential MRNet implementations of both Libra and CAPEK.

Abstract:

Single-system image (SSI) name spaces allow tools and middleware to access distributed resources as if they were local, which greatly reduces development efforts and permits developers to focus on providing crucial functionality. Unfortunately, distributed systems containing tens of thousands of hosts present a huge challenge for efficient construction and use of SSI name spaces. Previous methods of name space composition are either inflexible, inefficient, or both. In this talk, I will present a new language for name space composition that allows for efficient, flexible, and scalable construction of SSI name spaces. I will describe how the language is used within TBON-FS to let clients construct name spaces tailored for use with our group file operation idiom, which eliminates iteration and provides scalable data aggregation when applying file operations to large groups of distributed files.

Abstract:

For the past several years the Paradyn team has been factoring the large DyninstAPI into smaller component pieces. This talk will review where we stand in the larger componentization effort and introduce two new components that are on the near horizon: ProcControlAPI and FlowGraphAPI. Finally, we will discuss efforts towards building new components for binary analysis.

Abstract:

Open|SpeedShop is an open source multi platform Linux performance tool that enables a comprehensive performance analysis of applications running on both single node and large scale IA64, IA32, EM64T, and AMD64 platforms. Recently, Open|SpeedShop has also been extended to run on capability systems, incl. Cray's XT5 and IBM's BG/P. O|SS builds on top of a broad list of community infrastructures, most notably Dyninst and MRNet from UW and UMD, libmonitor from Rice, and PAPI from UTK. Open|SpeedShop uses both dynamic instrumentation,
for online operation mode, and ld preload library interception, for offline operation mode. This talk will provide an update on the activities in the O|SS project and highlight new features as well as initial results of the newly supported platforms.

Abstract:

In this talk, we will present the current status of the binary rewriting interface in Dyninst. We will discribe a new feature that enables rewriting statically-linked binaries. We will discuss the conceptual challenges of implementing this new feature as well as some specific problems we faced during implementation. We will also present additions to the rewriter interface and some best practices for using the rewriter on statically-linked binaries. We will finish with a discussion of future directions for the binary rewriter including planned ports.

Abstract:

Auto-tuning has recently received its fair share of attention from the High Performance Computing community. Most auto-tuning approaches are specialized to work either on specific domains - dense/sparse linear algebra, stencil computations etc.; or only at certain stages of program execution - compile-time, launch-time or run-time. Real scientific applications, however, demand a cohesive environment that can efficiently provide auto-tuning solutions at all stages of application development and deployment. Towards that end, we have been developing a unified end-to-end approach to auto-tuning scientific applications. We call our system Active Harmony. A unique feature of our search-based auto-tuning system is a powerful parallel search backend, which leverages parallelism to effectively navigate the search space defined by compiler-level and application-level tunable parameters. Our system is general-purpose and the results demonstrate its applicability in tuning compiler-generated and application-specific input parameter spaces.

In this presentation, we will talk about our recent effort on making run-time tuning of parallel programs a practical goal. With the addition of runtime tuning capability, Active Harmony will provide a light-weight auto-tuning environment, which will allow on-the-fly adaptation of parallel applications during production executions. The system provides tuning options not only for symbolic parameters but also for parameters that require dynamic code-generation and compilation. Conceptually, this can be viewed as a merger of the traditional and just-in-time compilation.