Next: Static Analysis Tools
Up: Program Analysis Environments for
Previous: Introduction
We advocate the development of language-specific
program analysis environments.
The language we are targeting to demonstrate the benefits of such
an approach is pC++.
pC++ is a language extension to C++ designed to allow programmers
to compose distributed data structures with parallel execution semantics.
The basic concept behind pC++ is the notion of a distributed
collection, which is a type of concurrent aggregate ``container class''
[3].
More specifically, a collection is a structured set of objects
which are distributed across the processing elements of the computer
in a manner designed to be completely consistent with HPF [4].
To accomplish this, pC++ provides a very simple mechanism to build
``collections of objects'' from a base element class.
Member functions from this element class can be applied to the entire
collection (or a subset) in parallel.
This mechanism provides the user with a clean interface to
data-parallel style operations by simply calling member functions of the
base class.
In addition, there is a mechanism for encapsulating SPMD style computation
in a thread-based computing model that is both efficient and completely
portable.
To help the programmer build collections, the pC++ language includes a
library of standard collection classes that may be used (or
subclassed).
This includes classes such as DistributedArray, DistributedMatrix, DistributedVector, and DistributedGrid.
High-level parallel languages, including pC++, place special
requirements on the development and use of program analysis tools.
The 
toolset was designed to meet the following pC++ analysis
requirements:
-
Providing a user (program-level) view.
Elements of the graphical interface represent objects
of the pC++ programming paradigm: collections, classes, methods,
and functions.
These language-level objects appear in all utilities.
-
Support for high-level, parallel programming paradigms.
is designed and implemented in concert with the pC++
language system.
The most difficult challenge to the development of is in
determining what low-level performance (or debugging)
instrumentation must be specified for capturing high-level execution
abstractions, then translating performance data back to the
application/language level.
-
Integration with compilers and runtime systems.
uses the Sage++ toolkit [1] as an interface to the
pC++ compiler for instrumentation and accessing properties of program
objects.
is also integrated with the pC++ runtime system for
profiling and tracing support.
-
Portability, extensibility, and retargetability.
Because pC++ is intended to be portable, the tools have to be
portable as well.
We are using C++ and C to ensure an efficient and portable implementation.
The same reason led us to choose Tcl/Tk [7][6] for the
graphical interface.
The tools are implemented as graphical hypertools.
While they are distinct tools, they act in concert as if they were
a single application.
Each tool implements some well-defined tasks.
If one tool needs a feature of another one, it sends a message to
the other tool requesting it (e.g., display the
source code for a specific function).
This design allows easy extensions.
The Sage++ toolkit also supports Fortran-based languages, allowing
to be retargeted to other programming environments.
-
Usability.
We tried to make the toolset as user-friendly as
possible.
Many elements of the graphical user interface are analogous to
links in
hypertext systems: clicking on them brings up windows which
describe the element in more detail.
This allows the user to explore properties of the application
by simply interacting with elements of most interest.
The tools also support global features.
If a global feature is invoked in any of the tools, it is automatically
executed in all currently running tools.
Examples of global features include select-function,
select-class, and switch-application.
also includes a full hypertext help system.
Figure 1 shows the pC++ programming
environment and the associated tools architecture.
The pC++ compiler frontend takes a user program and
pC++ class library definitions (which provide predefined collection
types) and parses them into an abstract syntax tree (AST).
All access to the AST is done via the Sage++ library.
Through command line switches, the user can choose to compile a program for
profiling, tracing, and breakpoint debugging.
In these cases, the instrumentor is invoked to do the necessary
instrumentation in the AST.
The pC++ backend transforms the AST into plain C++ with calls into the
pC++ runtime system.
This C++ source code is then compiled and linked by the C++ compiler
on the target system.
The compilation and execution of pC++ programs can be controlled by
cosy (COmpile manager Status displaY).
This tool provides a high-level graphical interface for setting
compilation and execution parameters and selecting the parallel machine
where a program will run.
Figure 1: pC++ Programming Environment and Tools Architecture
The program and performance analysis environment is shown on the right side
of Figure 1.
They include the integrated TAU tools, profiling and tracing support, and
interfaces to stand-alone performance analysis tools developed partly by
other groups [13][5][2][11].
The toolset provides support for accessing static information
about the program and for querying and analyzing dynamic data obtained
from program execution.
The static and dynamic tools of the environment
are briefly described below; a more detailed discussion of these tools
can be found in [10][9].
Next: Static Analysis Tools
Up: Program Analysis Environments for
Previous: Introduction