src/mc/api/State.cpp

   1 /* Copyright (c) 2008-2023. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "src/mc/api/State.hpp"
   7 #include "src/mc/api/strategy/BasicStrategy.hpp"
   8 #include "src/mc/api/strategy/MaxMatchComm.hpp"
   9 #include "src/mc/api/strategy/MinMatchComm.hpp"
  10 #include "src/mc/api/strategy/UniformStrategy.hpp"
  11 #include "src/mc/explo/Exploration.hpp"
  12 #include "src/mc/mc_config.hpp"
  13 #include "xbt/random.hpp"
  14
  15 #include <algorithm>
  16 #include <boost/range/algorithm.hpp>
  17
  18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_state, mc, "Logging specific to MC states");
  19
  20 namespace simgrid::mc {
  21
  22 long State::expended_states_ = 0;
  23
  24 State::State(RemoteApp& remote_app) : num_(++expended_states_)
  25 {
  26   XBT_VERB("Creating a guide for the state");
  27
  28   if (_sg_mc_strategy == "none")
  29     strategy_ = std::make_shared<BasicStrategy>();
  30   else if (_sg_mc_strategy == "max_match_comm")
  31     strategy_ = std::make_shared<MaxMatchComm>();
  32   else if (_sg_mc_strategy == "min_match_comm")
  33     strategy_ = std::make_shared<MinMatchComm>();
  34   else if (_sg_mc_strategy == "uniform") {
  35     xbt::random::set_mersenne_seed(_sg_mc_random_seed);
  36     strategy_ = std::make_shared<UniformStrategy>();
  37   } else
  38     THROW_IMPOSSIBLE;
  39
  40   remote_app.get_actors_status(strategy_->actors_to_run_);
  41 }
  42
  43 State::State(RemoteApp& remote_app, std::shared_ptr<State> parent_state)
  44     : incoming_transition_(parent_state->get_transition_out()), num_(++expended_states_), parent_state_(parent_state)
  45 {
  46   if (_sg_mc_strategy == "none")
  47     strategy_ = std::make_shared<BasicStrategy>();
  48   else if (_sg_mc_strategy == "max_match_comm")
  49     strategy_ = std::make_shared<MaxMatchComm>();
  50   else if (_sg_mc_strategy == "min_match_comm")
  51     strategy_ = std::make_shared<MinMatchComm>();
  52   else if (_sg_mc_strategy == "uniform")
  53     strategy_ = std::make_shared<UniformStrategy>();
  54   else
  55     THROW_IMPOSSIBLE;
  56   strategy_->copy_from(parent_state_->strategy_.get());
  57
  58   remote_app.get_actors_status(strategy_->actors_to_run_);
  59
  60   /* Copy the sleep set and eventually removes things from it: */
  61   /* For each actor in the previous sleep set, keep it if it is not dependent with current transition.
  62    * And if we kept it and the actor is enabled in this state, mark the actor as already done, so that
  63    * it is not explored*/
  64   for (const auto& [aid, transition] : parent_state_->get_sleep_set()) {
  65     if (not incoming_transition_->depends(transition.get())) {
  66       sleep_set_.try_emplace(aid, transition);
  67       if (strategy_->actors_to_run_.count(aid) != 0) {
  68         XBT_DEBUG("Actor %ld will not be explored, for it is in the sleep set", aid);
  69         strategy_->actors_to_run_.at(aid).mark_done();
  70       }
  71     } else
  72       XBT_DEBUG("Transition >>%s<< removed from the sleep set because it was dependent with incoming >>%s<<",
  73                 transition->to_string().c_str(), incoming_transition_->to_string().c_str());
  74   }
  75 }
  76
  77 std::size_t State::count_todo() const
  78 {
  79   return boost::range::count_if(this->strategy_->actors_to_run_, [](auto& pair) { return pair.second.is_todo(); });
  80 }
  81
  82 std::size_t State::count_todo_multiples() const
  83 {
  84   size_t count = 0;
  85   for (auto const& [_, actor] : strategy_->actors_to_run_)
  86     if (actor.is_todo())
  87       count += actor.get_times_not_considered();
  88
  89   return count;
  90 }
  91
  92 aid_t State::next_transition() const
  93 {
  94   XBT_DEBUG("Search for an actor to run. %zu actors to consider", strategy_->actors_to_run_.size());
  95   for (auto const& [aid, actor] : strategy_->actors_to_run_) {
  96     /* Only consider actors (1) marked as interleaving by the checker and (2) currently enabled in the application */
  97     if (not actor.is_todo() || not actor.is_enabled() || actor.is_done()) {
  98       if (not actor.is_todo())
  99         XBT_DEBUG("Can't run actor %ld because it is not todo", aid);
 100
 101       if (not actor.is_enabled())
 102         XBT_DEBUG("Can't run actor %ld because it is not enabled", aid);
 103
 104       if (actor.is_done())
 105         XBT_DEBUG("Can't run actor %ld because it has already been done", aid);
 106
 107       continue;
 108     }
 109
 110     return aid;
 111   }
 112   return -1;
 113 }
 114
 115 std::pair<aid_t, int> State::next_transition_guided() const
 116 {
 117   return strategy_->next_transition();
 118 }
 119
 120 aid_t State::next_odpor_transition() const
 121 {
 122   return wakeup_tree_.get_min_single_process_actor().value_or(-1);
 123 }
 124
 125 // This should be done in GuidedState, or at least interact with it
 126 std::shared_ptr<Transition> State::execute_next(aid_t next, RemoteApp& app)
 127 {
 128   // First, warn the guide, so it knows how to build a proper child state
 129   strategy_->execute_next(next, app);
 130
 131   // This actor is ready to be executed. Execution involves three phases:
 132
 133   // 1. Identify the appropriate ActorState to prepare for execution
 134   // when simcall_handle will be called on it
 135   auto& actor_state                        = strategy_->actors_to_run_.at(next);
 136   const unsigned times_considered          = actor_state.do_consider();
 137   const auto* expected_executed_transition = actor_state.get_transition(times_considered).get();
 138   xbt_assert(expected_executed_transition != nullptr,
 139              "Expected a transition with %u times considered to be noted in actor %ld", times_considered, next);
 140
 141   XBT_DEBUG("Let's run actor %ld (times_considered = %u)", next, times_considered);
 142
 143   // 2. Execute the actor according to the preparation above
 144   Transition::executed_transitions_++;
 145   auto* just_executed = app.handle_simcall(next, times_considered, true);
 146   xbt_assert(just_executed->type_ == expected_executed_transition->type_,
 147              "The transition that was just executed by actor %ld, viz:\n"
 148              "%s\n"
 149              "is not what was purportedly scheduled to execute, which was:\n"
 150              "%s\n",
 151              next, just_executed->to_string().c_str(), expected_executed_transition->to_string().c_str());
 152
 153   // 3. Update the state with the newest information. This means recording
 154   // both
 155   //  1. what action was last taken from this state (viz. `executed_transition`)
 156   //  2. what action actor `next` was able to take given `times_considered`
 157   // The latter update is important as *more* information is potentially available
 158   // about a transition AFTER it has executed.
 159   outgoing_transition_ = std::shared_ptr<Transition>(just_executed);
 160
 161   actor_state.set_transition(outgoing_transition_, times_considered);
 162   app.wait_for_requests();
 163
 164   return outgoing_transition_;
 165 }
 166
 167 std::unordered_set<aid_t> State::get_backtrack_set() const
 168 {
 169   std::unordered_set<aid_t> actors;
 170   for (const auto& [aid, state] : get_actors_list()) {
 171     if (state.is_todo() || state.is_done()) {
 172       actors.insert(aid);
 173     }
 174   }
 175   return actors;
 176 }
 177
 178 std::unordered_set<aid_t> State::get_sleeping_actors() const
 179 {
 180   std::unordered_set<aid_t> actors;
 181   for (const auto& [aid, _] : get_sleep_set()) {
 182     actors.insert(aid);
 183   }
 184   return actors;
 185 }
 186
 187 std::unordered_set<aid_t> State::get_enabled_actors() const
 188 {
 189   std::unordered_set<aid_t> actors;
 190   for (const auto& [aid, state] : get_actors_list()) {
 191     if (state.is_enabled()) {
 192       actors.insert(aid);
 193     }
 194   }
 195   return actors;
 196 }
 197
 198 void State::seed_wakeup_tree_if_needed(const odpor::Execution& prior)
 199 {
 200   // TODO: It would be better not to have such a flag.
 201   if (has_initialized_wakeup_tree) {
 202     XBT_DEBUG("Reached a node with the following initialized WuT:");
 203     XBT_DEBUG("\n%s", wakeup_tree_.string_of_whole_tree().c_str());
 204
 205     return;
 206   }
 207   // TODO: Note that the next action taken by the actor may be updated
 208   // after it executes. But we will have already inserted it into the
 209   // tree and decided upon "happens-before" at that point for different
 210   // executions :(
 211   if (wakeup_tree_.empty()) {
 212     // Find an enabled transition to pick
 213     for (const auto& [_, actor] : get_actors_list()) {
 214       if (actor.is_enabled()) {
 215         // For each variant of the transition, we want
 216         // to insert the action into the tree. This ensures
 217         // that all variants are searched
 218         for (unsigned times = 0; times < actor.get_max_considered(); ++times) {
 219           wakeup_tree_.insert(prior, odpor::PartialExecution{actor.get_transition(times)});
 220         }
 221         break; // Only one actor gets inserted (see pseudocode)
 222       }
 223     }
 224   }
 225   has_initialized_wakeup_tree = true;
 226 }
 227
 228 void State::sprout_tree_from_parent_state()
 229 {
 230
 231     XBT_DEBUG("Initializing Wut with parent one:");
 232     XBT_DEBUG("\n%s", parent_state_->wakeup_tree_.string_of_whole_tree().c_str());
 233
 234
 235   xbt_assert(parent_state_ != nullptr, "Attempting to construct a wakeup tree for the root state "
 236                                        "(or what appears to be, rather for state without a parent defined)");
 237   const auto min_process_node = parent_state_->wakeup_tree_.get_min_single_process_node();
 238   xbt_assert(min_process_node.has_value(), "Attempting to construct a subtree for a substate from a "
 239                                            "parent with an empty wakeup tree. This indicates either that ODPOR "
 240                                            "actor selection in State.cpp is incorrect, or that the code "
 241                                            "deciding when to make subtrees in ODPOR is incorrect");
 242   if (not(get_transition_in()->aid_ == min_process_node.value()->get_actor() &&
 243           get_transition_in()->type_ == min_process_node.value()->get_action()->type_)) {
 244     XBT_ERROR("We tried to make a subtree from a parent state who claimed to have executed `%s` on actor %ld "
 245               "but whose wakeup tree indicates it should have executed `%s` on actor %ld. This indicates "
 246               "that exploration is not following ODPOR. Are you sure you're choosing actors "
 247               "to schedule from the wakeup tree? Trace so far:",
 248               get_transition_in()->to_string(false).c_str(), get_transition_in()->aid_,
 249               min_process_node.value()->get_action()->to_string(false).c_str(), min_process_node.value()->get_actor());
 250     for (auto elm : Exploration::get_instance()->get_textual_trace())
 251       XBT_ERROR("%s", elm.c_str());
 252     xbt_abort();
 253   }
 254   this->wakeup_tree_ = odpor::WakeupTree::make_subtree_rooted_at(min_process_node.value());
 255 }
 256
 257 void State::remove_subtree_using_current_out_transition()
 258 {
 259   if (auto out_transition = get_transition_out(); out_transition != nullptr) {
 260     if (const auto min_process_node = wakeup_tree_.get_min_single_process_node(); min_process_node.has_value()) {
 261       xbt_assert((out_transition->aid_ == min_process_node.value()->get_actor()) &&
 262                      (out_transition->type_ == min_process_node.value()->get_action()->type_),
 263                  "We tried to make a subtree from a parent state who claimed to have executed `%s` "
 264                  "but whose wakeup tree indicates it should have executed `%s`. This indicates "
 265                  "that exploration is not following ODPOR. Are you sure you're choosing actors "
 266                  "to schedule from the wakeup tree?",
 267                  out_transition->to_string(false).c_str(),
 268                  min_process_node.value()->get_action()->to_string(false).c_str());
 269     }
 270   }
 271   wakeup_tree_.remove_min_single_process_subtree();
 272 }
 273
 274 odpor::WakeupTree::InsertionResult State::insert_into_wakeup_tree(const odpor::PartialExecution& pe,
 275                                                                   const odpor::Execution& E)
 276 {
 277   return this->wakeup_tree_.insert(E, pe);
 278 }
 279
 280 void State::do_odpor_unwind()
 281 {
 282   if (auto out_transition = get_transition_out(); out_transition != nullptr) {
 283     remove_subtree_using_current_out_transition();
 284
 285     // Only when we've exhausted all variants of the transition which
 286     // can be chosen from this state do we finally add the actor to the
 287     // sleep set. This ensures that the current logic handling sleep sets
 288     // works with ODPOR in the way we intend it to work. There is not a
 289     // good way to perform transition equality in SimGrid; instead, we
 290     // effectively simply check for the presence of an actor in the sleep set.
 291     if (not get_actors_list().at(out_transition->aid_).has_more_to_consider())
 292       add_sleep_set(std::move(out_transition));
 293   }
 294 }
 295
 296 } // namespace simgrid::mc