In this section, we give a brief overview of 
,
a first prototype for an integrated portable pC++ program and performance
analysis environment.
Elements of the graphical interface represent objects of
the pC++ programming model: collections, classes, methods, and functions.
These language-level objects appear in all tools.
By plan, was designed and developed in concert with the pC++ language
system.
It leverages pC++ language technology, especially in its use of the Sage++
toolkit [2] as an interface to the pC++ compiler for
instrumentation and for accessing properties of program objects.
is also integrated with the pC++ runtime system for
profiling and tracing support.
Because pC++ is intended to be portable, the tools are built to be
portable as well.
C++ and C are used to ensure portable and efficient implementation,
and similar reasons led us to choose Tcl/Tk [5][4] for the
graphical interface.
The tools are implemented as graphical hypertools.
While the tools are distinct, providing unique capabilities, they can act
in combination to provide enhanced functionality.
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).
With this design approach, the toolset can be easily extended.
can also be retargeted to other programming environments, for
instance those based on Fortran, which Sage++ toolkit supports.
One important goal in 's development was to make the toolset
as user-friendly as possible.
For this purpose, 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 the concept of 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.
For good measure, comes with a full hypertext help system.
Figure 2 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 which supports both shared and distributed memory
platforms.
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: pC++ Programming Environment and Tools Architecture
The program and performance analysis environment is shown on the right side
of Figure 2.
They include the integrated tools, profiling and tracing support, and
interfaces to stand-alone performance analysis tools developed partly by
other groups [9][8][7][6].
The toolset provides support for accessing static information
about the program and for querying and analyzing dynamic data obtained
from program execution.
A more detailed discussion of the tools can be found
in [12][11][10].