Parallel programs can have complex behaviors that are difficult to debug. We advocate a two-level strategy in which an event-based approach is first used to investigate high-level patterns of process interactions and then, as the focus of attention narrows, a state-based approach is used to investigate lower-level program details. Event-based techniques focus the user's attention on manageable portions of the state space, provide the basis for establishing consistent and meaningful breakpoints, permit replay, and allow manipulations that filter the effects of asynchrony. State-based techniques offer a familiar environment for examining an execution to an arbitrary level of detail and make it easier to relate detected anomalies to source code errors. The combination of these techniques provides comprehensive debugging support.
We report here on preliminary work that combines event- and state-based debugging approaches within the TAU program analysis environment . We build on an earlier prototype  which combined our event-based debugger, Ariadne, with Intel's state-based debugger, ipd . Combining Ariadne with a debugger in TAU provides us with a more realistic programming environment for assessing the strengths of mixed event- and state-based strategies. TAU is an environment for programming in the pC++ data-parallel language ; in this paper, we introduce extensions to event-based behavioral modeling that support object-parallel languages and provide new mechanisms for establishing meaningful breakpoints in object-oriented code. In addition, we introduce the TAU program interaction and control infrastructure that allows the integration of debugging and visualization tools as cooperating clients of a single agent.
In Section 2, we briefly describe the Ariadne debugger. Ariadne was designed for use with explicitly parallel languages and required some modifications to its modeling and replay/breakpointing facilities for pC++. The modifications are described in Sections 3 and 4. In Section 5, we introduce the TAU program interaction and control infrastructure. Finally, in Section 6, we present our conclusions and outline future directions, focusing on the debugging facilities that will be needed for more complex object-parallel languages that incorporate task parallelism.