Most sequential debugging tools provide support for conditional breakpoints, which halt the program whenever a predicate condition is satisfied. There are several interpretations of the parallel equivalent to this feature. Miller and Choi[Mil88] discuss this issue in detail, and present definitions of distributed predicates, with an algorithm to detect them and an algorithm to halt the system after detection. A simple predicate (SP) depends on the state and execution flow of a single process. Disjunctive (DP) and conjunctive predicates (CP) are combinations of SPs across processes. A linked predicate (LP) is specified as a sequence of simple or disjunctive predicates.
Simple predicates are detectable by sequential debuggers. Disjunctive predicates are equally trivial to detect (since only one SP must be detected), but the problem of halting the distributed program in a consistent state is not trivial. Linked predicates, which are similar to chains in Ariadne[Kun96], can be detected using an algorithm presented in [Mil88].
Detection of conjunctive predicates is somewhat more difficult. With
no single global time, it's impossible to say that n SPs are true at
the same time, so a CP must be defined according to the partial
ordering provided by Lamport's happened before relation. For
two processes 
and 
, a set of virtual time pairs 
is defined such that 
is true at time 
and 
is true
at time 
. Then the conjunction 
is true at
time-pair 
if this time-pair is consistent with the Lamport
partial ordering. Pairs that are ordered can be detected with Linked
predicates. Pairs that are not ordered cannot be consistently
detected except with the use of tracing and replay--see
[Man92].
If the ZPL were implemented on a fine-grained parallel machine where a separate thread could be spawned for each region element, Miller and Choi's algorithms could be used, unmodified, for predicate breakpoint detection. However, the presence of mloops in the object code further complicates the issue of detecting conjunctive predicates, as well as the issue of halting the computation in a consistent state.