Traditional state-based technique of controlled execution, whereby programs are reexecuted repeatedly in order to examine various states of the computation does not work in case of parallel programs. Although lack of reproducibility in parallel programs can be circumvented by incorporating replay techniques [][28], contending with a large state space, the requirement of stopping the computation in a consistent global state for meaningful debugging [16][32][14][][34][33], and perturbations due to physical asynchrony are harder to handle. State-based techniques provide neither an adequate abstraction mechanism to handle the large state space nor a flexible specification mechanism to identify meaningful consistent states in a methodical way.
Event-based approaches provide solutions for most of the shortcomings of state-based breakpoint-oriented debugging. The perturbations due to physical asynchrony can be filtered out by analyzing the behavior in logical time [22][10][][]. They allow exploration of the program behavior in a hierarchical fashion by providing sophisticated abstraction mechanism, and hence make it easy for the user to contend with the huge amount of trace data generated by parallel programs. Issues of global consistency do not arise, since the modeling is done in terms of local events and not local states. These three characteristics - support of hierarchical abstraction mechanism, avoidance of the need to specify and select globally consistent states, and the adaptation to the physical asynchrony engendered by a lack of global clock - make event-based approaches superior than the state-based counterparts in the initial stages of debugging.
Currently available event-based debugging tools, however, have their own limitations - their feedback on the matching of the model to the execution behavior is often limited to a ``match/mismatch'' vocabulary, the visualizations they employ to illuminate program behavior are not scalable, and they are unable to track the error manifested in the abstract model down to the offending source construct. The limited vocabulary and non-scalability of visualization can be attributed to existing systems' insistence on modeling precision and process-centric depiction of behavior respectively, and thus can be addressed with the right design decisions. The inability to track an error back to the source code is, however, a more fundamental problem - it is a direct consequence of eliminating any consideration of local states in event-based modeling. The very attribute that enables event-based approaches to avoid consistency issues makes it impossible for them to track an error back to the source code construct.
An effective debugging strategy is thus necessarily a hybrid strategy that integrates the event- and the state-based approaches in a meaningful way. Such a strategy might, for example, employ event-based techniques [22][20][12][5][4] at the highest level where gross patterns of process interactions are investigated. As debugging proceeds and the focus of attention narrows, the behavior of progressively smaller parts of the program could be analyzed in progressively finer detail, using a combination of event- and state-based techniques. Finally, at the lowest level, when the error has been isolated to specific sections of sequential code, traditional state-based techniques [40][24][23] could be used. This strategy effectively addresses all the issues that we have raised initially. The initial use of event-based techniques focus the user's attention on manageable portions of the state space and - as we will see below - provides the basis for establishing consistent, global breakpoints, which allows us to employ standard state examination technique to relate an error first detected at a high level of abstraction to the source code construct that causes it.No such integration has been contemplated before perhaps due to a dogmatic adherence to breakpoint specification only in terms of local state predicates. In this paper, we present an integrated event- and state-based debugging strategy that outperforms state predicate-based breakpointing schemes by using a novel strategy of setting globally consistent breakpoints using abstract events.
Our Ave/Ariadne
debugging environment has three main components:
the modeling language and its use of logical time (discussed in Section 2),
scalable visual feedback and query interface based on a spreadsheet
(discussed in Section 3), and the abstract event based setting of global
breakpoints (discussed in Section 4). A single programming example will be used
to illustrate the three components in detail. In Section 5, we
highlight a case where the standard way of breakpoint specification
based on local state predicates proves quite inadequate; and we show
how our integrated scheme can handle the situation very naturally.
Section 6 presents the conclusions of the research.