* under the terms of the license (GNU LGPL) which comes with this package. */
#include "src/mc/explo/UdporChecker.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 {
+namespace simgrid::mc::udpor {
UdporChecker::UdporChecker(const std::vector<char*>& args) : Exploration(args)
{
/* Create initial data structures, if any ...*/
- XBT_INFO("Starting a UDPOR exploration");
// TODO: Initialize state structures for the search
}
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 the former paper described in [3]
+ // 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;
- /**
- * Maintains the mapping between handles referenced by events in
- * the current state of the unfolding
- */
- StateManager state_manager_;
-
- const auto initial_state = std::make_unique<State>(get_remote_app());
+ 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), {EventSet()}, std::move(D), std::move(A), root_event.get(), std::move(prev_exC));
+ explore(std::move(C), std::move(A), std::move(D), {}, root_event.get(), std::move(prev_exC));
+
+ XBT_INFO("UDPOR exploration terminated -- model checking completed");
}
-void UdporChecker::explore(Configuration C, std::list<EventSet> max_evt_history, EventSet D, EventSet A,
- UnfoldingEvent* cur_evt, EventSet prev_exC)
+void UdporChecker::explore(Configuration C, EventSet D, EventSet A, std::list<EventSet> max_evt_history,
+ UnfoldingEvent* e_cur, EventSet prev_exC)
{
// Perform the incremental computation of exC
- auto [exC, enC] = this->extend(C, max_evt_history, *cur_evt, prev_exC);
+ auto [exC, enC] = compute_extension(C, max_evt_history, e_cur, prev_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)) {
- // Log traces
- if (C.events_.size() > 0) {
+ if (C.get_events().size() > 0) {
// g_var::nb_traces++;
// 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
+ // state reached by `C` (denoted `state(C)`), i.e. by some
// execution of the transitions in C obeying the causality
- // relation). Hence, it is at this point we should check for a deadlock
+ // relation. Here, then, we would be in a deadlock.
if (enC.empty()) {
get_remote_app().check_deadlock();
}
return;
}
- UnfoldingEvent* e = this->select_next_unfolding_event(A, enC);
- if (e == nullptr) {
- XBT_ERROR("\n\n****** CRITICAL ERROR ****** \n"
- "UDPOR guarantees that an event will be chosen here, yet no events were actually chosen...\n"
- "******************");
- DIE_IMPOSSIBLE;
- }
-
// TODO: Add verbose logging about which event is being explored
- // TODO: Execute the transition associated with the event
- // and map the new state
+ const auto next_state_id = observe_unfolding_event(*e_cur);
- // const auto cur_state_id = cur_evt->get_state_id();
- // auto curEv_StateId = currentEvt->get_state_id();
- // auto nextState_id = App::app_side_->execute_transition(curEv_StateId, e->get_transition_tag());
- // e->set_state_id(nextState_id);
+ 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);
- // Configuration is the same + event e
- // C1 = C + {e}
- Configuration C1 = C;
- C1.events_.insert(e);
- C1.updateMaxEvent(e);
+ // Ce := C + {e}
+ Configuration Ce = C;
+ Ce.add_event(e);
- max_evt_history.push_back(C1.maxEvent);
-
- // A <-- A \ {e}, ex(C) <-- ex(C) \ {e}
+ max_evt_history.push_back(Ce.get_maximal_events());
A.remove(e);
exC.remove(e);
// Explore(C + {e}, D, A \ {e})
- this->explore(C1, max_evt_history, D, A, e, exC);
+ explore(Ce, D, std::move(A), max_evt_history, e, 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 = this->compute_partial_alternative(D, C, K);
+ auto J = compute_partial_alternative(D, C, K);
if (!J.empty()) {
- J.subtract(C.events_);
+ J.subtract(C.get_events());
max_evt_history.pop_back();
- explore(C, max_evt_history, D, J, cur_evt, prev_exC);
+
+ // Explore(C, D + {e}, J \ C)
+ explore(C, D, std::move(J), std::move(max_evt_history), e_cur, std::move(prev_exC));
}
// D <-- D - {e}
D.remove(e);
- this->clean_up_explore(e, C, D);
+
+ // Remove(e, C, D)
+ 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
+{
+ // 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;
+ exC.remove(e_cur);
+
+ EventSet enC;
+ return std::tuple<EventSet, EventSet>(exC, enC);
}
-std::tuple<EventSet, EventSet> UdporChecker::extend(const Configuration& C, const std::list<EventSet>& max_evt_history,
- const UnfoldingEvent& cur_event, const EventSet& prev_exC) const
+State& UdporChecker::get_state_referenced_by(const UnfoldingEvent& event)
{
- // exC.remove(cur_event);
+ 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();
+}
- // TODO: Compute extend() as it exists in tiny_simgrid
+StateHandle UdporChecker::observe_unfolding_event(const UnfoldingEvent& event)
+{
+ auto& state = this->get_state_referenced_by(event);
+ const aid_t next_actor = state.next_transition();
+
+ // TODO: Add the trace if possible for reporting a bug
+ xbt_assert(next_actor >= 0, "\n\n****** INVARIANT VIOLATION ******\n"
+ "In reaching this execution path, UDPOR ensures that at least one\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();
+}
- // exC.subtract(C);
- return std::tuple<EventSet, EventSet>();
+StateHandle UdporChecker::record_current_state()
+{
+ auto next_state = this->get_current_state();
+ const auto next_state_id = this->state_manager_.record_state(std::move(next_state));
+
+ // In UDPOR, we care about all enabled transitions in a given state
+ next_state->mark_all_enabled_todo();
+ return next_state_id;
}
UnfoldingEvent* UdporChecker::select_next_unfolding_event(const EventSet& A, const EventSet& enC)
{
- // TODO: Actually select an event here
+ if (!enC.empty()) {
+ return *(enC.begin());
+ }
+
+ for (const auto& event : A) {
+ if (enC.contains(event)) {
+ return event;
+ }
+ }
return nullptr;
}
-EventSet UdporChecker::compute_partial_alternative(const EventSet& D, const EventSet& C, const unsigned k) const
+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 EventSet& C, const EventSet& D)
+void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const Configuration& C, const EventSet& D)
{
// TODO: Perform clean up here
}
return trace;
}
+} // namespace simgrid::mc::udpor
+
+namespace simgrid::mc {
+
Exploration* create_udpor_checker(const std::vector<char*>& args)
{
- return new UdporChecker(args);
+ return new simgrid::mc::udpor::UdporChecker(args);
}
} // namespace simgrid::mc