#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 <xbt/asserts.h>
#include <xbt/log.h>
+#include <xbt/string.hpp>
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)
-{
- // Initialize the map
-}
+UdporChecker::UdporChecker(const std::vector<char*>& 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]
- 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);
-
- explore(C_root, EventSet(), EventSet(), std::move(initial_state), EventSet());
-
+ 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(const Configuration& C, EventSet D, EventSet A, std::unique_ptr<State> stateC,
- EventSet prev_exC)
+void UdporChecker::explore(const Configuration& C, EventSet D, EventSet A, EventSet prev_exC)
{
- auto exC = compute_exC(C, *stateC, 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
// exploration would lead to a so-called
// "sleep-set blocked" trace.
if (enC.is_subset_of(D)) {
-
if (not C.get_events().empty()) {
// Report information...
}
// 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();
- DIE_IMPOSSIBLE;
}
return;
"UDPOR guarantees that an event will be chosen at each point in\n"
"the search, yet no events were actually chosen\n"
"*********************************\n\n");
-
- // Move the application into stateCe and 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);
exC.remove(e);
// Explore(C + {e}, D, A \ {e})
- explore(Ce, D, std::move(A), std::move(stateCe), 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);
constexpr unsigned K = 10;
- if (auto J_minus_C = compute_k_partial_alternative(D, C, K); J_minus_C.has_value()) {
+ 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 `stateC` (the recursive
- // search moved the program into `stateCe`)
- restore_program_state_to(*stateC);
+ // 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_minus_C.value()), std::move(stateC), 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}
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));
- }
+ EventSet extension = ExtensionSetCalculator::partially_extend(C, &unfolding, transition);
+ exC.form_union(extension);
}
}
return exC;
begin != maximal_subsets_iterator(); ++begin) {
const EventSet& maximal_subset = *begin;
- // TODO: Determine if `a` is enabled here
+ // Determining if `a` is enabled here might not be possible while looking at `a` opaquely
+ // We leave the implementation as-is to ensure that any addition would be simple
+ // if it were ever added
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);
- }
+ auto event = std::make_unique<UnfoldingEvent>(maximal_subset, action);
+ const auto handle = unfolding.insert(std::move(event));
+ incremental_exC.insert(handle);
}
}
return incremental_exC;
"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)
+void UdporChecker::restore_program_state_with_current_stack()
{
get_remote_app().restore_initial_state();
- // TODO: We need to have the stack of past states available at this
- // point. Since the method is recursive, we'll need to keep track of
- // this as we progress
+
+ /* Traverse the stack from the state at position start and re-execute the transitions */
+ for (const std::unique_ptr<State>& 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<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();
+ next_state->consider_all();
return next_state;
}
return nullptr;
}
-std::vector<const UnfoldingEvent*> UdporChecker::pick_k_partial_alternative_events(const EventSet& D,
- const unsigned k) const
-{
- const unsigned size = std::min(k, static_cast<unsigned>(D.size()));
- std::vector<const UnfoldingEvent*> D_hat(size);
-
- // Potentially select intelligently here (e.g. perhaps pick events
- // with transitions that we know are totally independent)...
- //
- // For now, simply pick the first `k` events (any subset suffices)
- std::copy_n(D.begin(), size, D_hat.begin());
- return D_hat;
-}
-
-std::optional<EventSet> UdporChecker::compute_k_partial_alternative(const EventSet& D, const Configuration& C,
- const unsigned k) const
-{
- // 1. Select k (of |D|, whichever is smaller) arbitrary events e_1, ..., e_k from D
- const auto D_hat = pick_k_partial_alternative_events(D, k);
-
- // 2. Build a U-comb <s_1, ..., s_k> of size k, where spike `s_i` contains
- // all events in conflict with `e_i`
- //
- // 3. EXCEPT those events e' for which [e'] + C is not a configuration or
- // [e'] intersects D
- Comb comb(k);
-
- for (const auto* e : this->unfolding) {
- for (unsigned i = 0; i < k; i++) {
- const auto& e_i = D_hat[i];
- if (const auto e_local_config = History(e);
- e_i->conflicts_with(e) and (not D.contains(e_local_config)) and C.is_compatible_with(e_local_config)) {
- comb[i].push_back(e);
- }
- }
- }
-
- // 4. Find any such combination <e_1', ..., e_k'> in comb satisfying
- // ~(e_i' # e_j') for i != j
- // Note: This is a VERY expensive operation: it enumerates all possible
- // ways to select an element from each spike
-
- const auto map_events = [](const std::vector<Spike::const_iterator>& spikes) {
- std::vector<const UnfoldingEvent*> events;
- for (const auto& event_in_spike : spikes) {
- events.push_back(*event_in_spike);
- }
- return EventSet(std::move(events));
- };
- const auto alternative =
- std::find_if(comb.combinations_begin(), comb.combinations_end(),
- [&map_events](const auto& vector) { return map_events(vector).is_conflict_free(); });
-
- // No such alternative exists
- if (alternative == comb.combinations_end()) {
- return std::nullopt;
- }
-
- // 5. J := [e_1] + [e_2] + ... + [e_k] is a k-partial alternative
- return History(map_events(*alternative)).get_event_diff_with(C);
-}
-
void UdporChecker::clean_up_explore(const UnfoldingEvent* e, const Configuration& C, const EventSet& D)
{
const EventSet C_union_D = C.get_events().make_union(D);
RecordTrace UdporChecker::get_record_trace()
{
RecordTrace res;
+ for (auto const& state : state_stack)
+ res.push_back(state->get_transition());
return res;
}
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;
+ 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;
}
