#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 <xbt/asserts.h>
#include <xbt/log.h>
void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, std::unique_ptr<State> 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
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
// 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"
clean_up_explore(e, C, D);
}
-std::tuple<EventSet, EventSet> 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}
// 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 K }
- UnfoldingEvent* e_cur = C.get_latest_event();
- EventSet exC = prev_exC;
+ // 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);
for (const auto& [aid, actor_state] : stateC.get_actors_list()) {
// 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<EventSet, EventSet>(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<Transition> action)
{
// Here we're computing the following:
//
- // U{<a, K> : K is maximal, `a` depends on all of K, `a` enabled at K }
+ // 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.
+ // 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<CompatibilityGraph> G = C.make_compatibility_graph_filtered_on([=](const 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<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;
}
+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_;
"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)
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());
