conpar94.ftp (Раздаточные материалы)

Submitted to: CONPAR 94 - VAPP VI, University of Linz, Austria, September 6-8, 1994.TAU: A Portable Parallel ProgramAnalysis1Environment for pC++Bernd Mohr, Darryl Brown, Allen MalonyDepartment of Computer and Information ScienceUniversity of Oregon, Eugene, Oregon 97403fmohr, darrylb, malonyg@cs.uoregon.eduAbstractThe realization of parallel language systems that oer high-level programmingparadigms to reduce the complexity of application development, scalable runtime mechanisms to support variable size problem sets, and portable compiler platforms to provide access to multiple parallel architectures, places additional demands on the toolsfor program development and analysis.

The need for integration of these tools intoa comprehensive programming environment is even more pronounced and will requiremore sophisticated use of the language system technology (i.e., compiler and runtimesystem). Furthermore, the environment requirements of high-level support for the programmer, large-scale applications, and portable access to diverse machines also applyto the program analysis tools.In this paper, we discuss (TAU, Tuning and Analysis Utilities), a rst prototypefor an integrated and portable program analysis environment for pC++, a parallelobject-oriented language system.

is integrated with the pC++ system in that itrelies heavily on compiler and transformation tools (specically, the Sage++ toolkit)for its implementation. The paper describes the design and functionality of andshows its application in practice.Keywords: parallel programming environments, parallel languages, integratedprogram analysis tools, proling, event tracing1 IntroductionThe unavailability of comprehensive, user-oriented programming environments is one of theforemost obstacles to the routine application of parallel, high performance computing technology. Most critical is the need for advances in integrated parallel debugging, performanceevaluation, and program visualization tools [2].

Current tools fail to adequately addressparallel programming productivity requirements for several reasons:1This research is supported by DARPA under Rome Labs contract AF 30602-92-C-0135.1(R1) Providing a user (program-level) view. Tool development has been dominated byeorts directed at the execution level (e.g., ecient implementation of monitoring[1]). In consequence, tool users are given little support for \translating" program-levelsemantics to and from low-level, execution measurements and runtime data.(R2) Support for high-level, parallel programming languages. The development of advanced parallel languages (e.g., HPF [6] and pC++ [14]) further separates the userfrom execution-time reality, because of the complex transformations and optimizationsthat take place between the layers of language abstraction, runtime paradigm, andexecution environment.(R3) Integration with compilers and runtime systems.

The majority of debugging andperformance analysis tools have been developed independent of parallel languages andruntime systems, resulting in poor reuse of base-level technology, incompatibilities intool functionality, and interface inconsistencies in the user environment.(R4) Portability, extensibility, retargetability. Users of portable languages should be provided a consistent program development and analysis environment across multiple execution platforms. The tools should be extensible, so their functionality can be increasedto accommodate new language or runtime system features.

Support for retargetabilityallows the tool design to be easily reused for dierent parallel languages and systemenvironments.(R5) Usability. Implementing a high-level, portable, integrated tool does not automaticallyresult in an easy-to-use tool. In the past, less emphasis was put on well-designedinterfaces which led to very powerful but poorly used program analysis tools.These failures will become even more signicant as we move towards more general and robusthigh performance parallel languages with highly optimized runtime systems.Practically, the problems are ones of tool design technology rather than functionality:existing tools provide a variety of functionality, but they have not been successfully integratedinto usable parallel programming environments. One approach to improving integration isto base the design of tools on the particular performance and debugging requirements of theparallel language system in which the tools will be used.

In this manner, tool functionalitycan specically target program analysis support where tool application is well understood.However, unless tool implementation can leverage other programming system technology(e.g., the simple use of the compiler to implement instrumentation), the integration of thetools in the environment cannot be fully realized.We have designed and developed a parallel program analysis environment, (TAU,Tuning and Analysis Utilities), for a parallel, object-oriented language system, pC++. Inthis paper, we describe the design and show how programming productivity requirements2for pC++ are addressed in its implementation. Our goal is not to propose itself as ageneral purpose solution to parallel program analysis.

Rather, our goal is to demonstratethe potential benets of a new development strategy for program analysis tools, one thatpromotes meeting specic analysis requirements over providing general purpose functionality.The pC++ language system and the Sage++ restructuring toolkit that forms the basis ofthe pC++ compiler are briey described in x2. From this description, we develop a generalmodel of pC++ program observability and analysis. The environment for pC++, presentedin x3, is based on this model and reects the critical program analysis requirements ofthe pC++ language.

We outline the capabilities of the tools, showing specic instancesof their application and explaining how they are implemented in the pC++ programmingenvironment.2 A Brief Introduction to pC++pC++ is a language extension to C++ designed to allow programmers to compose distributeddata structures with parallel execution semantics. The basic concept behind pC++ is thenotion of a distributed collection, which is a type of concurrent aggregate \container class"[5, 7]. More specically, a collection is a structured set of objects which are distributed acrossthe processing elements of the computer in a manner designed to be completely consistentwith HPF Fortran [6]. To accomplish this, pC++ provides a very simple mechanism to build\collections of objects" from some base element class. Member functions from this elementclass can be applied to the entire collection (or a subset) in parallel.

This mechanism providesthe user with a clean interface to data-parallel style operations by simply calling memberfunctions of the base class. In addition, there is a mechanism for encapsulating SPMDstyle computation in a thread-based computing model that is both ecient and completelyportable. To help the programmer build collections, the pC++ language includes a libraryof standard collection classes that may be used (or subclassed).

This includes classes suchas DistributedArray, DistributedMatrix, DistributedVector, and DistributedGrid.In its current form, the pC++ compiler is a preprocessor that generates C++ code andmachine-independent calls to a portable runtime system. This is accomplished by using theobject-oriented compiler preprocessor toolkit Sage++ [3]. It provides the functions necessaryto read and restructure an internal representation of the pC++ program. After restructuring, the program is \unparsed" back into C++ code, which can be compiled on the targetarchitecture and linked with a runtime system specically designed for that machine (seeFigure 1).

pC++ and its runtime system have been ported to several shared memory anddistributed memory parallel systems, validating the system's goal of portability. The portsinclude the Kendall Square Research KSR-1, Intel Paragon, TMC CM-5, IBM SP-1, and3homogeneous clusters of UNIX workstations using PVM; work on porting pC++ to the CrayT3D and Meiko CS-2 is in progress.

More details about the pC++ language and runtimesystem can be found in [8, 9, 14, 15].2.1 An Observability and Analysis Model for pC++Collection denition and use are the key aspects for program analysis in the pC++ system.Programmers using pC++ require support for observing the collection data structures withrespect to both their object-oriented denition and their parallel execution semantics. Collection observation can be static and dynamic. In each case, a high-level language view is neededbecause the programmer should not have to know or understand the eects of pC++ programtransformations. The program analysis tools, on the other hand, do need to be able to access various information associated with a pC++ program, its compilation, and its execution.This data must be made consistent with the user's view of the pC++ programming paradigm,and with aspects of the program development and evaluation process in which the user isinvolved. For example, we can assume that the programmer is aware that collection elements are operated upon by multiple processors, but may not understand how the runtimesystem supports element access.