X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/12738f4e4c65c28e13238dea16d7bacbee8b8b65..afbb946d52d6d23ea7c9b83ee6c0ba50ce5d9972:/src/mc/explo/UdporChecker.cpp diff --git a/src/mc/explo/UdporChecker.cpp b/src/mc/explo/UdporChecker.cpp index 6d6afb9458..15cc3ec9fb 100644 --- a/src/mc/explo/UdporChecker.cpp +++ b/src/mc/explo/UdporChecker.cpp @@ -4,43 +4,36 @@ * 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 #include +#include -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& args) : Exploration(args) -{ - /* Create initial data structures, if any ...*/ - - // TODO: Initialize state structures for the search -} +UdporChecker::UdporChecker(const std::vector& args) : Exploration(args, true) {} 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] - EventSet A, D; - Configuration C; - EventSet prev_exC; - - auto initial_state = get_current_state(); - const auto initial_state_id = state_manager_.record_state(std::move(initial_state)); - const auto root_event = std::make_unique(-1, "", EventSet(), initial_state_id); - explore(std::move(C), std::move(A), std::move(D), {}, root_event.get(), std::move(prev_exC)); - + 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, EventSet D, EventSet A, std::list max_evt_history, - 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] = compute_extension(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); // If enC is a subset of D, intuitively // there aren't any enabled transitions @@ -48,22 +41,17 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::list 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(); } @@ -73,38 +61,49 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::listset_state_id(next_state_id); - - // Ce = C + {e} + // Ce := C + {e} Configuration Ce = C; Ce.add_event(e); - max_evt_history.push_back(Ce.get_maxmimal_events()); A.remove(e); exC.remove(e); // Explore(C + {e}, D, A \ {e}) - explore(Ce, D, std::move(A), max_evt_history, e, 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; - auto J = compute_partial_alternative(D, C, K); - if (!J.empty()) { - J.subtract(C.get_events()); - max_evt_history.pop_back(); + 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 + // 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 resepct to `state(C)` since the + // recursive calls have moved it there. + restore_program_state_with_current_stack(); // Explore(C, D + {e}, J \ C) - explore(C, D, std::move(J), std::move(max_evt_history), cur_evt, 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(prev_exC)); } // D <-- D - {e} @@ -114,36 +113,42 @@ void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::list UdporChecker::compute_extension(const Configuration& C, - const std::list& max_evt_history, - UnfoldingEvent* cur_event, - const EventSet& prev_exC) const +EventSet UdporChecker::compute_exC(const Configuration& C, const State& stateC, const EventSet& prev_exC) { - EventSet exC = prev_exC; - - exC.remove(cur_event); - - EventSet enC; - return std::tuple(exC, enC); + // 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{ : 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()) { + for (const auto& transition : actor_state.get_enabled_transitions()) { + EventSet extension = ExtensionSetCalculator::partially_extend(C, &unfolding, transition); + exC.form_union(extension); + } + } + return exC; } -State& UdporChecker::get_state_referenced_by(const UnfoldingEvent& event) +EventSet UdporChecker::compute_enC(const Configuration& C, const EventSet& exC) const { - const auto state_id = event.get_state_id(); - const auto wrapped_state = this->state_manager_.get_state(state_id); - xbt_assert(wrapped_state != std::nullopt, - "\n\n****** INVARIANT VIOLATION ******\n" - "To each UDPOR event corresponds a state, but state %lu does not exist. " - "Please report this as a bug.\n" - "*********************************\n\n", - state_id); - return wrapped_state.value().get(); + EventSet enC; + for (const auto e : exC) { + if (not e->conflicts_with(C)) { + enC.insert(e); + } + } + return enC; } -StateHandle UdporChecker::observe_unfolding_event(const UnfoldingEvent& event) +void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e) { - auto& state = this->get_state_referenced_by(event); - const aid_t next_actor = state.next_transition(); + 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" @@ -151,23 +156,40 @@ StateHandle UdporChecker::observe_unfolding_event(const UnfoldingEvent& event) "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); - return this->record_current_state(); + state.execute_next(next_actor, get_remote_app()); } -StateHandle UdporChecker::record_current_state() +void UdporChecker::restore_program_state_with_current_stack() { - auto next_state = this->get_current_state(); - const auto next_state_id = this->state_manager_.record_state(std::move(next_state)); + 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()->replay(get_remote_app()); + } +} + +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(); - return next_state_id; + 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()) { + 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?"); + } + + if (A.empty()) { return *(enC.begin()); } @@ -179,26 +201,40 @@ 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() { RecordTrace res; + for (auto const& state : state_stack) + res.push_back(state->get_transition()); return res; } std::vector UdporChecker::get_textual_trace() { std::vector trace; + for (auto const& state : state_stack) { + const auto* t = state->get_transition(); + trace.push_back(xbt::string_printf("%ld: %s", t->aid_, t->to_string().c_str())); + } return trace; }