* 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/CompatibilityGraph.hpp"
#include <xbt/asserts.h>
#include <xbt/log.h>
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()
// 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>(std::make_shared<Transition>(), EventSet());
+ 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);
- explore(std::move(C_root), EventSet(), EventSet(), std::move(initial_state), EventSet());
+ 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::unique_ptr<State> stateC, 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
//
// 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, prev_exC);
+ auto [exC, enC] = compute_extension(C, *stateC, 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)) {
- if (C.get_events().size() > 0) {
+ if (not C.get_events().empty()) {
// g_var::nb_traces++;
-
- // TODO: Log here correctly
- // XBT_DEBUG("\n Exploring executions: %d : \n", g_var::nb_traces);
- // ...
- // ...
}
// When `en(C)` is empty, intuitively this means that there
// 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());
// Before searching the "right half", we need to make
clean_up_explore(e, C, D);
}
-std::tuple<EventSet, EventSet> UdporChecker::compute_extension(const Configuration& C, const EventSet& prev_exC) const
+std::tuple<EventSet, EventSet> UdporChecker::compute_extension(const Configuration& C, const State& stateC,
+ const EventSet& prev_exC) const
{
// 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, > : H }
+ // 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;
exC.remove(e_cur);
- // ... fancy computations
+ 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_extension_by_enumeration(C, *transition));
+ }
+ }
+ }
EventSet enC;
+ // TODO: Compute enC based on conflict relations
+
return std::tuple<EventSet, EventSet>(exC, enC);
}
+EventSet UdporChecker::compute_extension_by_enumeration(const Configuration& C, const Transition& action) const
+{
+ // Here we're computing the following:
+ //
+ // U{<a, K> : K is maximal, `a` depends on all of K, `a` enabled at K }
+ //
+ // where `a` is the `action` given to us.
+ 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);
+ });
+
+ // TODO: Now that the graph has been constructed, enumerate
+ // all possible k-cliques of the complement of G
+
+ // TODO: For each enumeration, check all possible
+ // combinations of selecting a single event from
+ // each set associated with the graph nodes
+
+ return incremental_exC;
+}
+
void UdporChecker::move_to_stateCe(State& state, const UnfoldingEvent& e)
{
const aid_t next_actor = e.get_transition()->aid_;
