namespace simgrid::mc {
-xbt::signal<void()> DFSExplorer::on_exploration_start_signal;
-xbt::signal<void()> DFSExplorer::on_backtracking_signal;
+xbt::signal<void(RemoteApp&)> DFSExplorer::on_exploration_start_signal;
+xbt::signal<void(RemoteApp&)> DFSExplorer::on_backtracking_signal;
-xbt::signal<void(State*)> DFSExplorer::on_state_creation_signal;
+xbt::signal<void(State*, RemoteApp&)> DFSExplorer::on_state_creation_signal;
-xbt::signal<void(State*)> DFSExplorer::on_restore_system_state_signal;
-xbt::signal<void()> DFSExplorer::on_restore_initial_state_signal;
-xbt::signal<void(Transition*)> DFSExplorer::on_transition_replay_signal;
-xbt::signal<void(Transition*)> DFSExplorer::on_transition_execute_signal;
+xbt::signal<void(State*, RemoteApp&)> DFSExplorer::on_restore_system_state_signal;
+xbt::signal<void(RemoteApp&)> DFSExplorer::on_restore_initial_state_signal;
+xbt::signal<void(Transition*, RemoteApp&)> DFSExplorer::on_transition_replay_signal;
+xbt::signal<void(Transition*, RemoteApp&)> DFSExplorer::on_transition_execute_signal;
-xbt::signal<void()> DFSExplorer::on_log_state_signal;
+xbt::signal<void(RemoteApp&)> DFSExplorer::on_log_state_signal;
void DFSExplorer::check_non_termination(const State* current_state)
{
for (auto state = stack_.rbegin(); state != stack_.rend(); ++state)
- if (Api::get().snapshot_equal((*state)->get_system_state(), current_state->get_system_state())) {
+ if (*(*state)->get_system_state() == *current_state->get_system_state()) {
XBT_INFO("Non-progressive cycle: state %ld -> state %ld", (*state)->get_num(), current_state->get_num());
XBT_INFO("******************************************");
XBT_INFO("*** NON-PROGRESSIVE CYCLE DETECTED ***");
void DFSExplorer::log_state() // override
{
- on_log_state_signal();
+ on_log_state_signal(get_remote_app());
XBT_INFO("DFS exploration ended. %ld unique states visited; %ld backtracks (%lu transition replays, %lu states "
"visited overall)",
- State::get_expanded_states(), backtrack_count_, Api::get().mc_get_visited_states(),
+ State::get_expanded_states(), backtrack_count_, mc_model_checker->get_visited_states(),
Transition::get_replayed_transitions());
}
void DFSExplorer::run()
{
- on_exploration_start_signal();
+ on_exploration_start_signal(get_remote_app());
/* This function runs the DFS algorithm the state space.
* We do so iteratively instead of recursively, dealing with the call stack manually.
* This allows one to explore the call stack at will. */
XBT_DEBUG("Exploration depth=%zu (state:%ld; %zu interleaves)", stack_.size(), state->get_num(),
state->count_todo());
- Api::get().mc_inc_visited_states();
+ mc_model_checker->inc_visited_states();
// Backtrack if we reached the maximum depth
if (stack_.size() > (std::size_t)_sg_mc_max_depth) {
int next = state->next_transition();
if (next < 0) { // If there is no more transition in the current state, backtrack.
- XBT_DEBUG("There remains %zu actors, but none to interleave (depth %zu).",
- mc_model_checker->get_remote_process().actors().size(), stack_.size() + 1);
+ XBT_DEBUG("There remains %d actors, but none to interleave (depth %zu).", state->get_actor_count(),
+ stack_.size() + 1);
- if (mc_model_checker->get_remote_process().actors().empty()) {
+ if (state->get_actor_count() == 0) {
mc_model_checker->finalize_app();
XBT_VERB("Execution came to an end at %s (state: %ld, depth: %zu)", get_record_trace().to_string().c_str(),
state->get_num(), stack_.size());
/* Actually answer the request: let's execute the selected request (MCed does one step) */
state->execute_next(next);
- on_transition_execute_signal(state->get_transition());
+ on_transition_execute_signal(state->get_transition(), 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()->aid_,
state->get_transition()->to_string().c_str(), stack_.size(), state->get_num(), state->count_todo());
- std::string req_str;
- if (dot_output != nullptr)
- req_str = state->get_transition()->dot_string();
-
/* Create the new expanded state (copy the state of MCed into our MCer data) */
- auto next_state = std::make_unique<State>(get_session());
- on_state_creation_signal(next_state.get());
+ auto next_state = std::make_unique<State>(get_remote_app());
+ on_state_creation_signal(next_state.get(), get_remote_app());
if (_sg_mc_termination)
this->check_non_termination(next_state.get());
}
}
- if (dot_output != nullptr)
- std::fprintf(dot_output, "\"%ld\" -> \"%ld\" [%s];\n", state->get_num(), next_state->get_num(),
- req_str.c_str());
+ mc_model_checker->dot_output("\"%ld\" -> \"%ld\" [%s];\n", state->get_num(), next_state->get_num(),
+ state->get_transition()->dot_string().c_str());
- } else if (dot_output != nullptr)
- std::fprintf(dot_output, "\"%ld\" -> \"%ld\" [%s];\n", state->get_num(),
- visited_state_->original_num == -1 ? visited_state_->num : visited_state_->original_num,
- req_str.c_str());
+ } else
+ mc_model_checker->dot_output("\"%ld\" -> \"%ld\" [%s];\n", state->get_num(),
+ visited_state_->original_num == -1 ? visited_state_->num
+ : visited_state_->original_num,
+ state->get_transition()->dot_string().c_str());
stack_.push_back(std::move(next_state));
}
{
backtrack_count_++;
XBT_VERB("Backtracking from %s", get_record_trace().to_string().c_str());
- on_backtracking_signal();
+ on_backtracking_signal(get_remote_app());
stack_.pop_back();
- get_session().check_deadlock();
+ get_remote_app().check_deadlock();
/* Traverse the stack backwards until a state with a non empty interleave set is found, deleting all the states that
* have it empty in the way. For each deleted state, check if the request that has generated it (from its
/* If asked to rollback on a state that has a snapshot, restore it */
State* last_state = stack_.back().get();
if (const auto* system_state = last_state->get_system_state()) {
- Api::get().restore_state(system_state);
- on_restore_system_state_signal(last_state);
+ system_state->restore(&get_remote_app().get_remote_process());
+ on_restore_system_state_signal(last_state, get_remote_app());
return;
}
/* if no snapshot, we need to restore the initial state and replay the transitions */
- get_session().restore_initial_state();
- on_restore_initial_state_signal();
+ get_remote_app().restore_initial_state();
+ on_restore_initial_state_signal(get_remote_app());
/* Traverse the stack from the state at position start and re-execute the transitions */
for (std::unique_ptr<State> const& state : stack_) {
if (state == stack_.back()) /* If we are arrived on the target state, don't replay the outgoing transition */
break;
state->get_transition()->replay();
- on_transition_replay_signal(state->get_transition());
+ on_transition_replay_signal(state->get_transition(), get_remote_app());
/* Update statistics */
- Api::get().mc_inc_visited_states();
+ mc_model_checker->inc_visited_states();
}
}
-DFSExplorer::DFSExplorer(Session* session) : Exploration(session)
+DFSExplorer::DFSExplorer(const std::vector<char*>& args) : Exploration(args)
{
reductionMode_ = reduction_mode;
if (_sg_mc_termination)
(reductionMode_ == ReductionMode::none ? "none"
: (reductionMode_ == ReductionMode::dpor ? "dpor" : "unknown")));
- get_session().take_initial_snapshot();
-
XBT_DEBUG("Starting the DFS exploration");
- auto initial_state = std::make_unique<State>(get_session());
+ auto initial_state = std::make_unique<State>(get_remote_app());
XBT_DEBUG("**************************************************");
stack_.push_back(std::move(initial_state));
}
-Exploration* create_dfs_exploration(Session* session)
+Exploration* create_dfs_exploration(const std::vector<char*>& args)
{
- return new DFSExplorer(session);
+ return new DFSExplorer(args);
}
} // namespace simgrid::mc
