X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/edb58d998573dba62c74537dcacce8b4b9a7df80..50753d5f8442a47c17c4035724201a18a7ff6146:/src/mc/explo/UdporChecker.cpp diff --git a/src/mc/explo/UdporChecker.cpp b/src/mc/explo/UdporChecker.cpp index da236e29c8..550e5b7c7f 100644 --- a/src/mc/explo/UdporChecker.cpp +++ b/src/mc/explo/UdporChecker.cpp @@ -4,6 +4,11 @@ * 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/History.hpp" +#include "src/mc/explo/udpor/maximal_subsets_iterator.hpp" + #include #include @@ -11,11 +16,9 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_udpor, mc, "Logging specific to verification namespace simgrid::mc::udpor { -UdporChecker::UdporChecker(const std::vector& args) : Exploration(args) +UdporChecker::UdporChecker(const std::vector& args) : Exploration(args, true) { - /* Create initial data structures, if any ...*/ - - // TODO: Initialize state structures for the search + // Initialize the map } void UdporChecker::run() @@ -28,25 +31,21 @@ void UdporChecker::run() // TODO: Move computing the root configuration into a method on the Unfolding auto initial_state = get_current_state(); - auto root_event = std::make_unique(std::make_shared(), EventSet()); + 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(std::move(C_root), EventSet(), EventSet(), std::move(initial_state), EventSet()); + explore(C_root, EventSet(), EventSet(), std::move(initial_state), EventSet()); XBT_INFO("UDPOR exploration terminated -- model checking completed"); } -void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ptr stateC, EventSet prev_exC) +void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std::unique_ptr stateC, + EventSet prev_exC) { - // Perform the incremental computation of exC - // - // TODO: This method will have side effects on - // the unfolding, but the naming of the method - // suggests it is doesn't have side effects. We should - // reconcile this in the future - auto [exC, enC] = compute_extension(C, prev_exC); + auto exC = compute_exC(C, *stateC, prev_exC); + const auto enC = compute_enC(C, exC); // If enC is a subset of D, intuitively // there aren't any enabled transitions @@ -55,21 +54,17 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ // "sleep-set blocked" trace. if (enC.is_subset_of(D)) { - if (C.get_events().size() > 0) { - - // g_var::nb_traces++; - - // TODO: Log here correctly - // XBT_DEBUG("\n Exploring executions: %d : \n", g_var::nb_traces); - // ... - // ... + if (not C.get_events().empty()) { + // Report information... } // 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()) { get_remote_app().check_deadlock(); } @@ -79,13 +74,13 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ // TODO: Add verbose logging about which event is being explored - UnfoldingEvent* e = select_next_unfolding_event(A, enC); + const 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 the application into stateCe and make note of that state move_to_stateCe(*stateC, *e); auto stateCe = record_current_state(); @@ -102,11 +97,8 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ // 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 = compute_partial_alternative(D, C, K); - if (!J.empty()) { - J.subtract(C.get_events()); + if (auto J = C.compute_k_partial_alternative_to(D, this->unfolding, K); J.has_value()) { // Before searching the "right half", we need to make // sure the program actually reflects the fact @@ -115,7 +107,8 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ restore_program_state_to(*stateC); // 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()); + explore(C, D, std::move(J_minus_C), std::move(stateC), std::move(prev_exC)); } // D <-- D - {e} @@ -125,22 +118,75 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::unique_ clean_up_explore(e, C, D); } -std::tuple UdporChecker::compute_extension(const Configuration& C, const EventSet& prev_exC) const +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{ : H } - UnfoldingEvent* e_cur = C.get_latest_event(); - EventSet exC = prev_exC; + // ex(C) = ex(C' + {e_cur}) = ex(C') / {e_cur} + + // U{ : 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); - // ... fancy computations + 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)); + } + } + } + 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; + + // Determining if `a` is enabled here might not be possible while looking at `a` opaquely + // We leave the implementation as-is to ensure that any addition would be simple + // if it were ever added + 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; - return std::tuple(exC, enC); + for (const auto e : exC) { + if (not e->conflicts_with(C)) { + enC.insert(e); + } + } + return enC; } void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e) @@ -153,13 +199,15 @@ 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); + state.execute_next(next_actor, get_remote_app()); } void UdporChecker::restore_program_state_to(const State& stateC) { - // TODO: Perform state regeneration in the same manner as is done - // in the DFSChecker.cpp + get_remote_app().restore_initial_state(); + // TODO: We need to have the stack of past states available at this + // point. Since the method is recursive, we'll need to keep track of + // this as we progress } std::unique_ptr UdporChecker::record_current_state() @@ -167,12 +215,12 @@ 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; } -UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC) +const UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC) { if (!enC.empty()) { return *(enC.begin()); @@ -186,15 +234,23 @@ UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, con 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 + 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); + } } RecordTrace UdporChecker::get_record_trace()