X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f456852dd160e1f60f58e2a3ef37a0e688993fe0..239cd16f4e95031d3a106e487c1485726069f1d7:/src/mc/explo/UdporChecker.cpp diff --git a/src/mc/explo/UdporChecker.cpp b/src/mc/explo/UdporChecker.cpp index 3d97acdf6e..4863807268 100644 --- a/src/mc/explo/UdporChecker.cpp +++ b/src/mc/explo/UdporChecker.cpp @@ -5,7 +5,7 @@ #include "src/mc/explo/UdporChecker.hpp" #include "src/mc/api/State.hpp" -#include "src/mc/explo/udpor/CompatibilityGraph.hpp" +#include "src/mc/explo/udpor/maximal_subsets_iterator.hpp" #include #include @@ -41,13 +41,8 @@ void UdporChecker::run() 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, *stateC, 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 @@ -57,8 +52,7 @@ void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std:: if (enC.is_subset_of(D)) { if (not C.get_events().empty()) { - - // g_var::nb_traces++; + // Report information... } // When `en(C)` is empty, intuitively this means that there @@ -75,7 +69,7 @@ void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std:: // 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" @@ -120,8 +114,7 @@ void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std:: clean_up_explore(e, C, D); } -std::tuple UdporChecker::compute_extension(const Configuration& C, const State& stateC, - 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} @@ -129,9 +122,9 @@ std::tuple UdporChecker::compute_extension(const Configurati // Then // // ex(C) = ex(C' + {e_cur}) = ex(C') / {e_cur} + - // U{ : K is maximal, `a` depends on all of K, `a` enabled at K } - UnfoldingEvent* e_cur = C.get_latest_event(); - EventSet exC = prev_exC; + // 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); for (const auto& [aid, actor_state] : stateC.get_actors_list()) { @@ -141,45 +134,56 @@ std::tuple UdporChecker::compute_extension(const Configurati // 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)); + exC.form_union((specialized_extension_function->second)(C, transition)); } else { - exC.form_union(this->compute_extension_by_enumeration(C, *transition)); + exC.form_union(this->compute_exC_by_enumeration(C, transition)); } } } - - EventSet enC; - // TODO: Compute enC based on conflict relations - - return std::tuple(exC, enC); + return exC; } -EventSet UdporChecker::compute_extension_by_enumeration(const Configuration& C, const Transition& action) const +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 K } + // U{ : K is maximal, `a` depends on all of K, `a` enabled at config(K) } // - // where `a` is the `action` given to us. + // where `a` is the `action` given to us. Note that `a` is presumed to be enabled EventSet incremental_exC; - // We only consider those combinations of events for which `action` is dependent with - // the action associated with any given event ("`a` depends on all of K") - const std::unique_ptr G = C.make_compatibility_graph_filtered_on([=](UnfoldingEvent* e) { - const auto e_transition = e->get_transition(); - return action.depends(e_transition); - }); + 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: Now that the graph has been constructed, enumerate - // all possible k-cliques of the complement of G + // TODO: Determine if `a` is enabled here + const bool enabled_at_config_k = false; - // TODO: For each enumeration, check all possible - // combinations of selecting a single event from - // each set associated with the graph nodes + 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)) { + enC.insert(e); + } + } + return enC; +} + void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e) { const aid_t next_actor = e.get_transition()->aid_; @@ -190,7 +194,7 @@ 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) @@ -209,7 +213,7 @@ std::unique_ptr UdporChecker::record_current_state() 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());