on_log_state_signal(get_remote_app());
XBT_INFO("DFS exploration ended. %ld unique states visited; %lu backtracks (%lu transition replays, %lu states "
"visited overall)",
- State::get_expanded_states(), backtrack_count_, visited_states_count_,
- Transition::get_replayed_transitions());
+ State::get_expanded_states(), backtrack_count_, Transition::get_replayed_transitions(),
+ visited_states_count_);
Exploration::log_state();
}
XBT_ERROR("/!\\ Max depth of %d reached! THIS **WILL** BREAK the reduction, which is not sound "
"when stopping at a fixed depth /!\\",
_sg_mc_max_depth.get());
- XBT_ERROR("/!\\ If bad things happen, disable dpor with --cfg=model-check/reduction:none /!\\");
+ XBT_ERROR("/!\\ If bad things happen, disable the reduction with --cfg=model-check/reduction:none /!\\");
} else {
XBT_WARN("/!\\ Max depth reached ! /!\\ ");
}
continue;
}
- if (_sg_mc_sleep_set && XBT_LOG_ISENABLED(mc_dfs, xbt_log_priority_verbose)) {
+ if (XBT_LOG_ISENABLED(mc_dfs, xbt_log_priority_verbose)) {
XBT_VERB("Sleep set actually containing:");
- for (auto& [aid, transition] : state->get_sleep_set())
+ for (const auto& [aid, transition] : state->get_sleep_set())
XBT_VERB(" <%ld,%s>", aid, transition->to_string().c_str());
}
/* Actually answer the request: let's execute the selected request (MCed does one step) */
- const auto executed_transition = state->execute_next(next, get_remote_app());
+ auto executed_transition = state->execute_next(next, get_remote_app());
on_transition_execute_signal(state->get_transition_out().get(), get_remote_app());
// If there are processes to interleave and the maximum depth has not been
// reached then perform one step of the exploration algorithm.
- XBT_VERB("Execute %ld: %.60s (stack depth: %zu, state: %ld, %zu interleaves)", state->get_transition_out()->aid_,
+ XBT_VERB("Execute %ld: %.150s (stack depth: %zu, state: %ld, %zu interleaves)", state->get_transition_out()->aid_,
state->get_transition_out()->to_string().c_str(), stack_.size(), state->get_num(), state->count_todo());
/* Create the new expanded state (copy the state of MCed into our MCer data) */
* we want to be sure that search "in that direction"
*/
execution_seq_.push_transition(std::move(executed_transition));
- xbt_assert(execution_seq_.get_latest_event_handle().has_value(),
- "No events are contained in the SDPOR/OPDPOR execution "
- "even though one was just added");
+ xbt_assert(execution_seq_.get_latest_event_handle().has_value(), "No events are contained in the SDPOR execution "
+ "even though one was just added");
const auto next_E_p = execution_seq_.get_latest_event_handle().value();
- for (const auto racing_event_handle : execution_seq_.get_reversible_races_of(next_E_p)) {
- const std::shared_ptr<State> prev_state = stack_[racing_event_handle];
- // NOTE: To incorporate the idea of attempting to select the "best"
- // backtrack point into SDPOR, instead of selecting the `first` initial,
- // we should instead compute all choices and decide which is best
- if (const auto q =
- execution_seq_.get_first_sdpor_initial_from(racing_event_handle, prev_state->get_backtrack_set());
- q.has_value()) {
- prev_state->consider_one(q.value());
+ for (const auto e_race : execution_seq_.get_reversible_races_of(next_E_p)) {
+ State* prev_state = stack_[e_race].get();
+ const auto choices = execution_seq_.get_missing_source_set_actors_from(e_race, prev_state->get_backtrack_set());
+ if (not choices.empty()) {
+ // NOTE: To incorporate the idea of attempting to select the "best"
+ // backtrack point into SDPOR, instead of selecting the `first` initial,
+ // we should instead compute all choices and decide which is best
+ //
+ // Here, we choose the actor with the lowest ID to ensure
+ // we get deterministic results
+ const auto q =
+ std::min_element(choices.begin(), choices.end(), [](const aid_t a1, const aid_t a2) { return a1 < a2; });
+ prev_state->consider_one(*q);
opened_states_.emplace_back(std::move(prev_state));
}
}
continue;
if (valid != current)
*valid = std::move(*current);
- if (best == end(opened_states_) || prio > best_prio) {
+ if (best == end(opened_states_) || prio < best_prio) {
best_prio = prio;
best = valid;
}
for (auto iter = stack_.rbegin(); iter != stack_.rend(); ++iter) {
const auto& state = *iter;
state->do_odpor_unwind();
- if (!state->has_empty_tree()) {
+ XBT_DEBUG("\tPerformed ODPOR 'clean-up'. Sleep set has:");
+ for (const auto& [aid, transition] : state->get_sleep_set())
+ XBT_DEBUG("\t <%ld,%s>", aid, transition->to_string().c_str());
+ if (not state->has_empty_tree()) {
+ XBT_DEBUG("\t found the following non-empty WuT:\n"
+ "%s", state->string_of_wut().c_str());
return state;
}
}
XBT_DEBUG("ODPOR: Reversible race detected between events `%u` and `%u`", e, e_prime);
State& prev_state = *stack_[e];
if (const auto v = execution_seq_.get_odpor_extension_from(e, e_prime, prev_state); v.has_value()) {
- const auto result = prev_state.insert_into_wakeup_tree(v.value(), execution_seq_.get_prefix_before(e));
- switch (result) {
+ switch (prev_state.insert_into_wakeup_tree(v.value(), execution_seq_.get_prefix_before(e))) {
case odpor::WakeupTree::InsertionResult::root: {
- XBT_DEBUG("ODPOR: Reversible race with `%u` unaccounted for in the wakeup tree for "
- "the execution prior to event `%u`:",
- e_prime, e);
+ XBT_DEBUG("ODPOR: Reversible race with `%u`(%ld: %.20s) unaccounted for in the wakeup tree for "
+ "the execution prior to event `%u`(%ld: %.20s):",
+ e_prime, stack_[e_prime]->get_transition_out()->aid_,
+ stack_[e_prime]->get_transition_out()->to_string(true).c_str(), e,
+ prev_state.get_transition_out()->aid_,
+ prev_state.get_transition_out()->to_string(true).c_str());
break;
}
case odpor::WakeupTree::InsertionResult::interior_node: {
}
} else {
XBT_DEBUG("ODPOR: Ignoring race: `sleep(E')` intersects `WI_[E'](v := notdep(%u, E))`", e);
+ XBT_DEBUG("Sleep set contains:");
+ for (const auto& [aid, transition] : prev_state.get_sleep_set())
+ XBT_DEBUG(" <%ld,%s>", aid, transition->to_string().c_str());
}
}
}
