#include "src/mc/explo/udpor/History.hpp"
#include "src/mc/explo/udpor/maximal_subsets_iterator.hpp"
+#include <numeric>
#include <xbt/asserts.h>
#include <xbt/log.h>
#include <xbt/string.hpp>
auto& stateC = *state_stack.back();
auto exC = compute_exC(C, stateC, prev_exC);
const auto enC = compute_enC(C, exC);
+ XBT_DEBUG("explore(C, D, A) with:\n"
+ "C\t := %s \n"
+ "D\t := %s \n"
+ "A\t := %s \n"
+ "ex(C)\t := %s \n"
+ "en(C)\t := %s \n",
+ C.to_string().c_str(), D.to_string().c_str(), A.to_string().c_str(), exC.to_string().c_str(),
+ enC.to_string().c_str());
+ XBT_DEBUG("ex(C) has %zu elements, of which %zu are in en(C)", exC.size(), enC.size());
// If enC is a subset of D, intuitively
// there aren't any enabled transitions
// exploration would lead to a so-called
// "sleep-set blocked" trace.
if (enC.is_subset_of(D)) {
- if (not C.get_events().empty()) {
- // Report information...
- }
+ XBT_DEBUG("en(C) is a subset of the sleep set D (size %zu); if we "
+ "kept exploring, we'd hit a sleep-set blocked trace",
+ D.size());
+ XBT_DEBUG("The current configuration has %zu elements", C.get_events().size());
// When `en(C)` is empty, intuitively this means that there
// are no enabled transitions that can be executed from the
// 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...");
get_remote_app().check_deadlock();
}
return;
}
-
- // TODO: Add verbose logging about which event is being explored
-
- const UnfoldingEvent* e = select_next_unfolding_event(A, enC);
+ UnfoldingEvent* e = select_next_unfolding_event(A, enC);
xbt_assert(e != nullptr, "\n\n****** INVARIANT VIOLATION ******\n"
"UDPOR guarantees that an event will be chosen at each point in\n"
"the search, yet no events were actually chosen\n"
"*********************************\n\n");
+ XBT_DEBUG("Selected event `%s` (%zu dependencies) to extend the configuration", e->to_string().c_str(),
+ e->get_immediate_causes().size());
+
// Ce := C + {e}
Configuration Ce = C;
Ce.add_event(e);
// Explore(C + {e}, D, A \ {e})
// Move the application into stateCe (i.e. `state(C + {e})`) and make note of that state
- move_to_stateCe(stateC, *e);
+ move_to_stateCe(&stateC, e);
state_stack.push_back(record_current_state());
explore(Ce, D, std::move(A), std::move(exC));
- // Prepare to move the application back one state.
+ // Prepare to move the application back one state.
// We need only remove the state from the stack here: if we perform
// another `Explore()` after computing an alternative, at that
// point we'll actually create a fresh RemoteProcess
// D <-- D + {e}
D.insert(e);
- constexpr unsigned K = 10;
- if (auto J = C.compute_k_partial_alternative_to(D, this->unfolding, K); J.has_value()) {
+ XBT_DEBUG("Checking for the existence of an alternative...");
+ if (auto J = C.compute_alternative_to(D, this->unfolding); J.has_value()) {
// Before searching the "right half", we need to make
// sure the program actually reflects the fact
// that we are searching again from `state(C)`. While the
// Explore(C, D + {e}, J \ C)
auto J_minus_C = J.value().get_events().subtracting(C.get_events());
+
+ XBT_DEBUG("Alternative detected! The alternative is:\n"
+ "J\t := %s \n"
+ "J / C := %s\n"
+ "UDPOR is going to explore it...",
+ J.value().to_string().c_str(), J_minus_C.to_string().c_str());
explore(C, D, std::move(J_minus_C), std::move(prev_exC));
+ } else {
+ XBT_DEBUG("No alternative detected with:\n"
+ "C\t := %s \n"
+ "D\t := %s \n"
+ "A\t := %s \n",
+ C.to_string().c_str(), D.to_string().c_str(), A.to_string().c_str());
}
// D <-- D - {e}
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);
}
return enC;
}
-void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e)
+void UdporChecker::move_to_stateCe(State* state, UnfoldingEvent* e)
{
- const aid_t next_actor = e.get_transition()->aid_;
+ const aid_t next_actor = e->get_transition()->aid_;
// TODO: Add the trace if possible for reporting a bug
xbt_assert(next_actor >= 0, "\n\n****** INVARIANT VIOLATION ******\n"
"one transition of the state of an visited event is enabled, yet no\n"
"state was actually enabled. Please report this as a bug.\n"
"*********************************\n\n");
- state.execute_next(next_actor, get_remote_app());
+ auto latest_transition_by_next_actor = state->execute_next(next_actor, get_remote_app());
+
+ // The transition that is associated with the event was just
+ // executed, so it's possible that the new version of the transition
+ // (i.e. the one after execution) has *more* information than
+ // that which existed *prior* to execution.
+ //
+ //
+ // ------- !!!!! UDPOR INVARIANT !!!!! -------
+ //
+ // At this point, we are leveraging the fact that
+ // UDPOR will not contain more than one copy of any
+ // transition executed by any actor for any
+ // particular step taken by that actor. That is,
+ // if transition `i` of the `j`th actor is contained in the
+ // configuration `C` currently under consideration
+ // by UDPOR, then only one and only one copy exists in `C`
+ //
+ // This means that we can referesh the transitions associated
+ // with each event lazily, i.e. only after we have chosen the
+ // event to continue our execution.
+ e->set_transition(std::move(latest_transition_by_next_actor));
}
void UdporChecker::restore_program_state_with_current_stack()
{
+ XBT_DEBUG("Restoring state using the current stack");
get_remote_app().restore_initial_state();
/* Traverse the stack from the state at position start and re-execute the transitions */
return next_state;
}
-const UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC)
+UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC)
{
if (enC.empty()) {
throw std::invalid_argument("There are no unfolding events to select. "
}
if (A.empty()) {
- return *(enC.begin());
+ return const_cast<UnfoldingEvent*>(*(enC.begin()));
}
for (const auto& event : A) {
if (enC.contains(event)) {
- return event;
+ return const_cast<UnfoldingEvent*>(event);
}
}
return nullptr;
void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const Configuration& C, const EventSet& D)
{
- const EventSet C_union_D = C.get_events().make_union(D);
- const EventSet es_immediate_conflicts = this->unfolding.get_immediate_conflicts_of(e);
- const EventSet Q_CDU = C_union_D.make_union(es_immediate_conflicts.get_local_config());
-
- // Move {e} \ Q_CDU from U to G
- if (Q_CDU.contains(e)) {
- this->unfolding.remove(e);
- }
-
- // foreach ê in #ⁱ_U(e)
- for (const auto* e_hat : es_immediate_conflicts) {
- // Move [ê] \ Q_CDU from U to G
- const EventSet to_remove = e_hat->get_history().subtracting(Q_CDU);
- this->unfolding.remove(to_remove);
- }
+ // // 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);
}
RecordTrace UdporChecker::get_record_trace()
