namespace simgrid::mc::udpor {
-UdporChecker::UdporChecker(const std::vector<char*>& args) : Exploration(args, true) {}
+UdporChecker::UdporChecker(const std::vector<char*>& args) : Exploration(args) {}
void UdporChecker::run()
{
// possibility is that we've finished running everything, and
// we wouldn't be in deadlock then)
if (enC.empty()) {
- XBT_VERB("Maximal configuration detected. Checking for deadlock...");
+ XBT_VERB("**************************");
+ XBT_VERB("*** TRACE INVESTIGATED ***");
+ XBT_VERB("**************************");
+ XBT_VERB("Execution sequence:");
+ for (auto const& s : get_textual_trace())
+ XBT_VERB(" %s", s.c_str());
get_remote_app().check_deadlock();
}
// that we are searching again from `state(C)`. While the
// stack of states is properly adjusted to represent
// `state(C)` all together, the RemoteApp is currently sitting
- // at some *future* state with resepct to `state(C)` since the
- // recursive calls have moved it there.
+ // at some *future* state with respect to `state(C)` since the
+ // recursive calls had moved it there.
restore_program_state_with_current_stack();
// Explore(C, D + {e}, J \ C)
EventSet exC = prev_exC;
exC.remove(e_cur);
+ // IMPORTANT NOTE: In order to have deterministic results, we need to process
+ // the actors in a deterministic manner so that events are discovered by
+ // UDPOR in a deterministic order. The processing done here always processes
+ // actors in a consistent order since `std::map` is by-default ordered using
+ // `std::less<Key>` (see the return type of `State::get_actors_list()`)
for (const auto& [aid, actor_state] : stateC.get_actors_list()) {
- for (const auto& transition : actor_state.get_enabled_transitions()) {
- XBT_DEBUG("\t Considering partial extension for %s", transition->to_string().c_str());
- EventSet extension = ExtensionSetCalculator::partially_extend(C, &unfolding, transition);
- exC.form_union(extension);
+ const auto& enabled_transitions = actor_state.get_enabled_transitions();
+ if (enabled_transitions.empty()) {
+ XBT_DEBUG("\t Actor `%ld` is disabled: no partial extensions need to be considered", aid);
+ } else {
+ XBT_DEBUG("\t Actor `%ld` is enabled", aid);
+ for (const auto& transition : enabled_transitions) {
+ XBT_DEBUG("\t Considering partial extension for %s", transition->to_string().c_str());
+ EventSet extension = ExtensionSetCalculator::partially_extend(C, &unfolding, transition);
+ exC.form_union(extension);
+ }
}
}
return exC;
EventSet UdporChecker::compute_enC(const Configuration& C, const EventSet& exC) const
{
EventSet enC;
- for (const auto e : exC) {
- if (not e->conflicts_with(C)) {
+ for (const auto* e : exC) {
+ if (C.is_compatible_with(e)) {
enC.insert(e);
}
}
for (const std::unique_ptr<State>& state : state_stack) {
if (state == state_stack.back()) /* If we are arrived on the target state, don't replay the outgoing transition */
break;
- state->get_transition()->replay(get_remote_app());
+ state->get_transition_out()->replay(get_remote_app());
}
}
"empty before attempting to select an event from it?");
}
+ // UDPOR's exploration is non-deterministic (as is DPOR's)
+ // in the sense that at any given point there may
+ // be multiple paths that can be followed. The correctness and optimality
+ // of the algorithm remains unaffected by the route taken by UDPOR when
+ // given multiple choices; but to ensure that SimGrid itself has deterministic
+ // behavior on all platforms, we always pick events with lower id's
+ // to ensure we explore the unfolding deterministically.
if (A.empty()) {
- return const_cast<UnfoldingEvent*>(*(enC.begin()));
- }
-
- for (const auto& event : A) {
- if (enC.contains(event)) {
- return const_cast<UnfoldingEvent*>(event);
- }
+ const auto min_event = std::min_element(enC.begin(), enC.end(),
+ [](const auto e1, const auto e2) { return e1->get_id() < e2->get_id(); });
+ return const_cast<UnfoldingEvent*>(*min_event);
+ } else {
+ const auto intersection = A.make_intersection(enC);
+ const auto min_event = std::min_element(intersection.begin(), intersection.end(),
+ [](const auto e1, const auto e2) { return e1->get_id() < e2->get_id(); });
+ return const_cast<UnfoldingEvent*>(*min_event);
}
- return nullptr;
}
void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const Configuration& C, const EventSet& D)
{
- // // The "clean-up set" conceptually represents
- // // those events which will no longer be considered
- // // by UDPOR during its exploration. The concept is
- // // introduced to avoid modification during iteration
- // // over the current unfolding to determine who needs to
- // // be removed. Since sets are unordered, it's quite possible
- // // that e.g. two events `e` and `e'` such that `e < e'`
- // // which are determined eligible for removal are removed
- // // in the order `e` and then `e'`. Determining that `e'`
- // // needs to be removed requires that its history be in
- // // tact to e.g. compute the conflicts with the event.
- // //
- // // Thus, we compute the set and remove all of the events
- // // at once in lieu of removing events while iterating over them.
- // // We can hypothesize that processing the events in reverse
- // // topological order would prevent any issues concerning
- // // the order in which are processed
- // EventSet clean_up_set;
-
- // // Q_(C, D, U) = C u D u U (complicated expression)
- // // See page 9 of "Unfolding-based Partial Order Reduction"
-
- // // "C u D" portion
- // const EventSet C_union_D = C.get_events().make_union(D);
-
- // // "U (complicated expression)" portion
- // const EventSet conflict_union = std::accumulate(
- // C_union_D.begin(), C_union_D.end(), EventSet(), [&](const EventSet acc, const UnfoldingEvent* e_prime) {
- // return acc.make_union(unfolding.get_immediate_conflicts_of(e_prime));
- // });
-
- // const EventSet Q_CDU = C_union_D.make_union(conflict_union.get_local_config());
-
- // XBT_DEBUG("Computed Q_CDU as '%s'", Q_CDU.to_string().c_str());
-
- // // Move {e} \ Q_CDU from U to G
- // if (not Q_CDU.contains(e)) {
- // XBT_DEBUG("Moving %s from U to G...", e->to_string().c_str());
- // clean_up_set.insert(e);
- // }
-
- // // foreach ê in #ⁱ_U(e)
- // for (const auto* e_hat : this->unfolding.get_immediate_conflicts_of(e)) {
- // // Move [ê] \ Q_CDU from U to G
- // const EventSet to_remove = e_hat->get_history().subtracting(Q_CDU);
- // XBT_DEBUG("Moving {%s} from U to G...", to_remove.to_string().c_str());
- // clean_up_set.form_union(to_remove);
- // }
- // // this->unfolding.remove(clean_up_set);
+ // The "clean-up set" conceptually represents
+ // those events which will no longer be considered
+ // by UDPOR during its exploration. The concept is
+ // introduced to avoid modification during iteration
+ // over the current unfolding to determine who needs to
+ // be removed. Since sets are unordered, it's quite possible
+ // that e.g. two events `e` and `e'` such that `e < e'`
+ // which are determined eligible for removal are removed
+ // in the order `e` and then `e'`. Determining that `e'`
+ // needs to be removed requires that its history be in
+ // tact to e.g. compute the conflicts with the event.
+ //
+ // Thus, we compute the set and remove all of the events
+ // at once in lieu of removing events while iterating over them.
+ // We can hypothesize that processing the events in reverse
+ // topological order would prevent any issues concerning
+ // the order in which are processed
+ EventSet clean_up_set;
+
+ // Q_(C, D, U) = C u D u U (complicated expression)
+ // See page 9 of "Unfolding-based Partial Order Reduction"
+
+ // "C u D" portion
+ const EventSet C_union_D = C.get_events().make_union(D);
+
+ // "U (complicated expression)" portion
+ const EventSet conflict_union = std::accumulate(
+ C_union_D.begin(), C_union_D.end(), EventSet(), [&](const EventSet& acc, const UnfoldingEvent* e_prime) {
+ return acc.make_union(unfolding.get_immediate_conflicts_of(e_prime));
+ });
+
+ const EventSet Q_CDU = C_union_D.make_union(conflict_union.get_local_config());
+
+ XBT_DEBUG("Computed Q_CDU as '%s'", Q_CDU.to_string().c_str());
+
+ // Move {e} \ Q_CDU from U to G
+ if (not Q_CDU.contains(e)) {
+ XBT_DEBUG("Moving %s from U to G...", e->to_string().c_str());
+ clean_up_set.insert(e);
+ }
+
+ // foreach ê in #ⁱ_U(e)
+ for (const auto* e_hat : this->unfolding.get_immediate_conflicts_of(e)) {
+ // Move [ê] \ Q_CDU from U to G
+ const EventSet to_remove = e_hat->get_local_config().subtracting(Q_CDU);
+ XBT_DEBUG("Moving {%s} from U to G...", to_remove.to_string().c_str());
+ clean_up_set.form_union(to_remove);
+ }
+
+ // TODO: We still perhaps need to
+ // figure out how to deal with the fact that the previous
+ // extension sets computed for past configurations
+ // contain events that may be removed from `U`. Perhaps
+ // it would be best to keep them around forever (they
+ // are moved to `G` after all and can be discarded at will,
+ // which means they may never have to be removed at all).
+ //
+ // Of course, the benefit of moving them into the set `G`
+ // is that the computation for immediate conflicts becomes
+ // more efficient (we have to search all of `U` for such conflicts,
+ // and there would be no reason to search those events
+ // that UDPOR has marked as no longer being important)
+ // For now, there appear to be no "obvious" issues (although
+ // UDPOR's behavior is often far from obvious...)
+ this->unfolding.mark_finished(clean_up_set);
}
RecordTrace UdporChecker::get_record_trace()
{
RecordTrace res;
for (auto const& state : state_stack)
- res.push_back(state->get_transition());
+ res.push_back(state->get_transition_out().get());
return res;
}
-std::vector<std::string> UdporChecker::get_textual_trace()
-{
- std::vector<std::string> trace;
- for (auto const& state : state_stack) {
- const auto* t = state->get_transition();
- trace.push_back(xbt::string_printf("%ld: %s", t->aid_, t->to_string().c_str()));
- }
- return trace;
-}
-
} // namespace simgrid::mc::udpor
namespace simgrid::mc {