* 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/maximal_subsets_iterator.hpp"
#include <xbt/asserts.h>
#include <xbt/log.h>
-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 ...*/
-
- // TODO: Initialize state structures for the search
+ // Initialize the map
}
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 [3]
- EventSet A, D;
- Configuration C;
- EventSet prev_exC;
+ 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<UnfoldingEvent>(EventSet(), std::make_shared<Transition>());
+ auto* root_event_handle = root_event.get();
+ unfolding.insert(std::move(root_event));
+ C_root.add_event(root_event_handle);
- 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<UnfoldingEvent>(-1, "", EventSet(), initial_state_id);
- explore(std::move(C), std::move(A), std::move(D), {}, root_event.get(), std::move(prev_exC));
+ 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::list<EventSet> max_evt_history,
- UnfoldingEvent* e_cur, EventSet prev_exC)
+void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std::unique_ptr<State> stateC,
+ EventSet prev_exC)
{
- // Perform the incremental computation of exC
- auto [exC, enC] = compute_extension(C, max_evt_history, e_cur, 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
// "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
// TODO: Add verbose logging about which event is being explored
- const auto next_state_id = observe_unfolding_event(*e_cur);
-
- 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");
- e->set_state_id(next_state_id);
+
+ // Move the application into stateCe and actually make note of that state
+ move_to_stateCe(*stateC, *e);
+ auto stateCe = record_current_state();
// Ce := C + {e}
Configuration Ce = C;
Ce.add_event(e);
- max_evt_history.push_back(Ce.get_maximal_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));
+ explore(Ce, D, std::move(A), std::move(stateCe), std::move(exC));
// 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()) {
+ if (auto J = compute_partial_alternative(D, C, K); !J.empty()) {
J.subtract(C.get_events());
- max_evt_history.pop_back();
+
+ // 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);
// Explore(C, D + {e}, J \ C)
- explore(C, D, std::move(J), std::move(max_evt_history), e_cur, std::move(prev_exC));
+ explore(C, D, std::move(J), std::move(stateC), std::move(prev_exC));
}
// D <-- D - {e}
clean_up_explore(e, C, D);
}
-std::tuple<EventSet, EventSet> UdporChecker::compute_extension(const Configuration& C,
- const std::list<EventSet>& max_evt_history,
- UnfoldingEvent* e_cur, 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]
- // ex(C + {e_cur}) = ex(C) / {e_cur} + U{<a, > : H }
- EventSet exC = prev_exC;
+ // 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);
- EventSet enC;
- return std::tuple<EventSet, EventSet>(exC, enC);
+ 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;
}
-State& UdporChecker::get_state_referenced_by(const UnfoldingEvent& event)
+EventSet UdporChecker::compute_exC_by_enumeration(const Configuration& C, const std::shared_ptr<Transition> action)
{
- 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();
+ // Here we're computing the following:
+ //
+ // U{<a, K> : 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<UnfoldingEvent>(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;
}
-StateHandle UdporChecker::observe_unfolding_event(const UnfoldingEvent& event)
+EventSet UdporChecker::compute_enC(const Configuration& C, const EventSet& exC) const
{
- auto& state = this->get_state_referenced_by(event);
- const aid_t next_actor = state.next_transition();
+ 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_;
// TODO: Add the trace if possible for reporting a bug
xbt_assert(next_actor >= 0, "\n\n****** INVARIANT VIOLATION ******\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");
- 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_to(const State& stateC)
{
- auto next_state = this->get_current_state();
- const auto next_state_id = this->state_manager_.record_state(std::move(next_state));
+ // TODO: Perform state regeneration in the same manner as is done
+ // in the DFSChecker.cpp
+}
+
+std::unique_ptr<State> 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;
+
+ 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());
std::vector<std::string> UdporChecker::get_textual_trace()
{
+ // TODO: Topologically sort the events of the latest configuration
+ // and iterate through that topological sorting
std::vector<std::string> trace;
return trace;
}
