X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2f2db04b850386899392bc06568f17f071f8620f..HEAD:/src/mc/explo/UdporChecker.cpp diff --git a/src/mc/explo/UdporChecker.cpp b/src/mc/explo/UdporChecker.cpp index 4d89514798..f5c512f480 100644 --- a/src/mc/explo/UdporChecker.cpp +++ b/src/mc/explo/UdporChecker.cpp @@ -5,44 +5,45 @@ #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 #include #include +#include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_udpor, mc, "Logging specific to verification using UDPOR"); namespace simgrid::mc::udpor { -UdporChecker::UdporChecker(const std::vector& args) : Exploration(args) -{ - // Initialize the map -} +UdporChecker::UdporChecker(const std::vector& args) : Exploration(args) {} void UdporChecker::run() { XBT_INFO("Starting a UDPOR exploration"); - // 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 [3] - Configuration C_root; - - // TODO: Move computing the root configuration into a method on the Unfolding - auto initial_state = get_current_state(); - auto root_event = std::make_unique(EventSet(), std::make_shared()); - auto* root_event_handle = root_event.get(); - unfolding.insert(std::move(root_event)); - C_root.add_event(root_event_handle); - - explore(C_root, EventSet(), EventSet(), std::move(initial_state), EventSet()); - + 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(const Configuration& C, EventSet D, EventSet A, std::unique_ptr stateC, - EventSet prev_exC) +void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, EventSet prev_exC) { - auto exC = compute_exC(C, *stateC, 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 @@ -50,34 +51,37 @@ void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std:: // 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 // state reached by `C` (denoted `state(C)`), i.e. by some // execution of the transitions in C obeying the causality - // relation. Here, then, we would be in 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; } - - // 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"); - - // Move the application into stateCe and actually make note of that state - move_to_stateCe(*stateC, *e); - auto stateCe = record_current_state(); + 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; @@ -87,24 +91,48 @@ void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std:: exC.remove(e); // Explore(C + {e}, D, A \ {e}) - explore(Ce, D, std::move(A), std::move(stateCe), std::move(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; - if (auto J = compute_partial_alternative(D, C, K); !J.empty()) { - J.subtract(C.get_events()); - + 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 `stateC` (the recursive - // search moved the program into `stateCe`) - restore_program_state_to(*stateC); + // 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) - explore(C, D, std::move(J), std::move(stateC), std::move(prev_exC)); + 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} @@ -127,66 +155,41 @@ EventSet UdporChecker::compute_exC(const Configuration& C, const State& stateC, 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` (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()) { - // First check for a specialized function that can compute the extension - // set "quickly" based on its type. Otherwise, fall back to computing - // the set "by hand" - const auto specialized_extension_function = incremental_extension_functions.find(transition->type_); - if (specialized_extension_function != incremental_extension_functions.end()) { - exC.form_union((specialized_extension_function->second)(C, transition)); - } else { - exC.form_union(this->compute_exC_by_enumeration(C, transition)); + 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_exC_by_enumeration(const Configuration& C, const std::shared_ptr action) -{ - // Here we're computing the following: - // - // U{ : K is maximal, `a` depends on all of K, `a` enabled at config(K) } - // - // where `a` is the `action` given to us. Note that `a` is presumed to be enabled - EventSet incremental_exC; - - for (auto begin = - maximal_subsets_iterator(C, {[&](const UnfoldingEvent* e) { return e->is_dependent_with(action.get()); }}); - begin != maximal_subsets_iterator(); ++begin) { - const EventSet& maximal_subset = *begin; - - // TODO: Determine if `a` is enabled here - const bool enabled_at_config_k = false; - - if (enabled_at_config_k) { - auto candidate_handle = std::make_unique(maximal_subset, action); - if (auto candidate_event = candidate_handle.get(); not unfolding.contains_event_equivalent_to(candidate_event)) { - // This is a new event (i.e. one we haven't yet seen) - unfolding.insert(std::move(candidate_handle)); - incremental_exC.insert(candidate_event); - } - } - } - - return incremental_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); } } 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" @@ -194,13 +197,41 @@ void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e) "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); + 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_to(const State& stateC) +void UdporChecker::restore_program_state_with_current_stack() { - // TODO: Perform state regeneration in the same manner as is done - // in the DFSChecker.cpp + 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_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()); + } } std::unique_ptr UdporChecker::record_current_state() @@ -208,50 +239,115 @@ std::unique_ptr UdporChecker::record_current_state() auto next_state = this->get_current_state(); // In UDPOR, we care about all enabled transitions in a given state - next_state->mark_all_enabled_todo(); + next_state->consider_all(); 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()) { - return *(enC.begin()); + 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?"); } - for (const auto& event : A) { - if (enC.contains(event)) { - return event; - } + // 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(*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(*min_event); } - return nullptr; -} - -EventSet UdporChecker::compute_partial_alternative(const EventSet& D, const Configuration& C, const unsigned k) const -{ - // TODO: Compute k-partial alternatives using [2] - return EventSet(); } 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 UdporChecker::get_textual_trace() -{ - // TODO: Topologically sort the events of the latest configuration - // and iterate through that topological sorting - std::vector trace; - return trace; -} - } // namespace simgrid::mc::udpor namespace simgrid::mc {