* under the terms of the license (GNU LGPL) which comes with this package. */
#include "src/mc/explo/UdporChecker.hpp"
+#include "src/mc/api/State.hpp"
+#include "src/mc/explo/udpor/Comb.hpp"
+#include "src/mc/explo/udpor/ExtensionSetCalculator.hpp"
+#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>
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_udpor, mc, "Logging specific to MC safety verification ");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_udpor, mc, "Logging specific to verification using UDPOR");
namespace simgrid::mc::udpor {
-UdporChecker::UdporChecker(const std::vector<char*>& args) : Exploration(args)
-{
- /* Create initial data structures, if any ...*/
- XBT_INFO("Starting a UDPOR exploration");
-
- // TODO: Initialize state structures for the search
-}
+UdporChecker::UdporChecker(const std::vector<char*>& args) : Exploration(args) {}
void UdporChecker::run()
{
- // NOTE: `A`, `D`, and `C` are derived from the
- // original UDPOR paper [1], while
- // `prev_exC` arises from the incremental computation
- // of ex(C) from the former paper described in [3]
- EventSet A, D;
- Configuration C;
- EventSet prev_exC;
-
- /**
- * Maintains the mapping between handles referenced by events in
- * the current state of the unfolding
- */
- StateManager state_manager_;
-
- const auto initial_state = std::make_unique<State>(get_remote_app());
- const auto initial_state_id = state_manager_.record_state(std::move(initial_state));
- const auto root_event = std::make_unique<UnfoldingEvent>(-1, "", EventSet(), initial_state_id);
- explore(std::move(C), {EventSet()}, std::move(D), std::move(A), root_event.get(), std::move(prev_exC));
+ XBT_INFO("Starting a UDPOR exploration");
+ state_stack.clear();
+ state_stack.push_back(get_current_state());
+ explore(Configuration(), EventSet(), EventSet(), EventSet());
+ XBT_INFO("UDPOR exploration terminated -- model checking completed");
}
-void UdporChecker::explore(Configuration C, std::list<EventSet> max_evt_history, EventSet D, EventSet A,
- UnfoldingEvent* cur_evt, EventSet prev_exC)
+void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, EventSet prev_exC)
{
- // Perform the incremental computation of exC
- auto [exC, enC] = this->extend(C, max_evt_history, *cur_evt, prev_exC);
+ 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)) {
-
- // Log traces
- if (C.events_.size() > 0) {
-
- // g_var::nb_traces++;
-
- // TODO: Log here correctly
- // XBT_DEBUG("\n Exploring executions: %d : \n", g_var::nb_traces);
- // ...
- // ...
- }
+ 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
- // state reached by `C` (denoted `state(C)`) (i.e. by some
+ // state reached by `C` (denoted `state(C)`), i.e. by some
// execution of the transitions in C obeying the causality
- // relation). Hence, it is at this point we should check for a deadlock
+ // relation. Here, then, we may be in a deadlock (the other
+ // possibility is that we've finished running everything, and
+ // we wouldn't be in deadlock then)
if (enC.empty()) {
+ 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();
}
return;
}
+ 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);
- UnfoldingEvent* e = this->select_next_unfolding_event(A, enC);
- if (e == nullptr) {
- XBT_ERROR("\n\n****** CRITICAL ERROR ****** \n"
- "UDPOR guarantees that an event will be chosen here, yet no events were actually chosen...\n"
- "******************");
- DIE_IMPOSSIBLE;
- }
-
- // TODO: Add verbose logging about which event is being explored
-
- // TODO: Execute the transition associated with the event
- // and map the new state
-
- // const auto cur_state_id = cur_evt->get_state_id();
- // auto curEv_StateId = currentEvt->get_state_id();
- // auto nextState_id = App::app_side_->execute_transition(curEv_StateId, e->get_transition_tag());
- // e->set_state_id(nextState_id);
-
- // Configuration is the same + event e
- // C1 = C + {e}
- Configuration C1 = C;
- C1.events_.insert(e);
- C1.updateMaxEvent(e);
-
- max_evt_history.push_back(C1.maxEvent);
-
- // A <-- A \ {e}, ex(C) <-- ex(C) \ {e}
A.remove(e);
exC.remove(e);
// Explore(C + {e}, D, A \ {e})
- this->explore(C1, max_evt_history, D, A, e, exC);
+
+ // Move the application into stateCe (i.e. `state(C + {e})`) and make note of that state
+ 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.
+ // 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
+ state_stack.pop_back();
// D <-- D + {e}
D.insert(e);
- // TODO: Determine a value of K to use or don't use it at all
- constexpr unsigned K = 10;
- auto J = this->compute_partial_alternative(D, C, K);
- if (!J.empty()) {
- J.subtract(C.events_);
- max_evt_history.pop_back();
- explore(C, max_evt_history, D, J, cur_evt, prev_exC);
+ 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
+ // stack of states is properly adjusted to represent
+ // `state(C)` all together, the RemoteApp is currently sitting
+ // 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)
+ 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}
D.remove(e);
- this->clean_up_explore(e, C, D);
+
+ // Remove(e, C, D)
+ clean_up_explore(e, C, D);
+}
+
+EventSet UdporChecker::compute_exC(const Configuration& C, const State& stateC, const EventSet& prev_exC)
+{
+ // See eqs. 5.7 of section 5.2 of [3]
+ // C = C' + {e_cur}, i.e. C' = C - {e_cur}
+ //
+ // Then
+ //
+ // ex(C) = ex(C' + {e_cur}) = ex(C') / {e_cur} +
+ // U{<a, K> : K is maximal, `a` depends on all of K, `a` enabled at config(K) }
+ const UnfoldingEvent* e_cur = C.get_latest_event();
+ 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()) {
+ 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;
}
-std::tuple<EventSet, EventSet> UdporChecker::extend(const Configuration& C, const std::list<EventSet>& max_evt_history,
- const UnfoldingEvent& cur_event, const EventSet& prev_exC) const
+EventSet UdporChecker::compute_enC(const Configuration& C, const EventSet& exC) const
{
- // exC.remove(cur_event);
+ EventSet enC;
+ for (const auto* e : exC) {
+ if (C.is_compatible_with(e)) {
+ enC.insert(e);
+ }
+ }
+ return enC;
+}
- // TODO: Compute extend() as it exists in tiny_simgrid
+void UdporChecker::move_to_stateCe(State* state, UnfoldingEvent* e)
+{
+ 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"
+ "In reaching this execution path, UDPOR ensures that at least one\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");
+ 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));
+}
- // exC.subtract(C);
- return std::tuple<EventSet, EventSet>();
+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 */
+ 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_out()->replay(get_remote_app());
+ }
}
-UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC)
+std::unique_ptr<State> UdporChecker::record_current_state()
{
- // TODO: Actually select an event here
- return nullptr;
+ auto next_state = this->get_current_state();
+
+ // In UDPOR, we care about all enabled transitions in a given state
+ next_state->consider_all();
+
+ return next_state;
}
-EventSet UdporChecker::compute_partial_alternative(const EventSet& D, const EventSet& C, const unsigned k) const
+UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC)
{
- // TODO: Compute k-partial alternatives using [2]
- return EventSet();
+ if (enC.empty()) {
+ throw std::invalid_argument("There are no unfolding events to select. "
+ "Are you sure that you checked that en(C) was not "
+ "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()) {
+ 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);
+ }
}
-void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const EventSet& C, const EventSet& D)
+void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const Configuration& C, const EventSet& D)
{
- // TODO: Perform clean up here
+ // 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_out().get());
return res;
}
-std::vector<std::string> UdporChecker::get_textual_trace()
-{
- std::vector<std::string> trace;
- return trace;
-}
-
} // namespace simgrid::mc::udpor
namespace simgrid::mc {