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  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  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
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 . 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 .