src/mc/mc_api.cpp

   1 #include "mc_api.hpp"
   2
   3 #include "src/mc/Session.hpp"
   4 #include "src/mc/mc_private.hpp"
   5 #include "src/mc/remote/RemoteSimulation.hpp"
   6 #include "src/mc/mc_smx.hpp"
   7
   8 #include <xbt/asserts.h>
   9 #include <xbt/log.h>
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_api, mc, "Logging specific to MC Fasade APIs ");
  12
  13 namespace simgrid {
  14 namespace mc {
  15
  16 void mc_api::initialize(char** argv)
  17 {
  18   simgrid::mc::session = new simgrid::mc::Session([argv] {
  19     int i = 1;
  20     while (argv[i] != nullptr && argv[i][0] == '-')
  21       i++;
  22     xbt_assert(argv[i] != nullptr,
  23                "Unable to find a binary to exec on the command line. Did you only pass config flags?");
  24     execvp(argv[i], argv + i);
  25     xbt_die("The model-checked process failed to exec(): %s", strerror(errno));
  26   });
  27 }
  28
  29 void mc_api::s_initialize() const
  30 {
  31   session->initialize();
  32 }
  33
  34 void mc_api::create_model_checker(std::unique_ptr<RemoteSimulation> remote_simulation, int sockfd)
  35 {
  36
  37 }
  38
  39 ModelChecker* mc_api::get_model_checker() const
  40 {
  41     return mc_model_checker;
  42 }
  43
  44 void mc_api::mc_inc_visited_states() const
  45 {
  46   mc_model_checker->visited_states++;
  47 }
  48
  49 void mc_api::mc_inc_executed_trans() const
  50 {
  51   mc_model_checker->executed_transitions++;
  52 }
  53
  54 unsigned long mc_api::mc_get_visited_states() const
  55 {
  56   return mc_model_checker->visited_states;
  57 }
  58
  59 unsigned long mc_api::mc_get_executed_trans() const
  60 {
  61   return mc_model_checker->executed_transitions;
  62 }
  63
  64 bool mc_api::mc_check_deadlock() const
  65 {
  66   return mc_model_checker->checkDeadlock();
  67 }
  68
  69 void mc_api::mc_show_deadlock() const
  70 {
  71   MC_show_deadlock();
  72 }
  73
  74 smx_actor_t mc_api::mc_smx_simcall_get_issuer(s_smx_simcall const* req) const
  75 {
  76   return MC_smx_simcall_get_issuer(req);
  77 }
  78
  79 std::vector<simgrid::mc::ActorInformation>& mc_api::get_actors() const
  80 {
  81   return mc_model_checker->get_remote_simulation().actors();
  82 }
  83
  84 bool mc_api::actor_is_enabled(aid_t pid) const
  85 {
  86   return session->actor_is_enabled(pid);
  87 }
  88
  89 void mc_api::mc_assert(bool notNull, const char* message) const
  90 {
  91   if (notNull)
  92     xbt_assert(mc_model_checker == nullptr, message);
  93   else
  94     xbt_assert(mc_model_checker != nullptr, message);
  95 }
  96
  97 bool mc_api::mc_is_null() const
  98 {
  99   auto is_null = (mc_model_checker == nullptr) ? true : false;
 100   return is_null;
 101 }
 102
 103 Checker* mc_api::mc_get_checker() const
 104 {
 105   return mc_model_checker->getChecker();
 106 }
 107
 108 RemoteSimulation& mc_api::mc_get_remote_simulation() const
 109 {
 110   return mc_model_checker->get_remote_simulation();
 111 }
 112
 113 void mc_api::handle_simcall(Transition const& transition) const
 114 {
 115   mc_model_checker->handle_simcall(transition);
 116 }
 117
 118 void mc_api::mc_wait_for_requests() const
 119 {
 120   mc_model_checker->wait_for_requests();
 121 }
 122
 123 void mc_api::mc_exit(int status) const
 124 {
 125   mc_model_checker->exit(status);
 126 }
 127
 128 std::string const& mc_api::mc_get_host_name(std::string const& hostname) const
 129 {
 130   return mc_model_checker->get_host_name(hostname);
 131 }
 132
 133 PageStore& mc_api::mc_page_store() const
 134 {
 135   return mc_model_checker->page_store();
 136 }
 137
 138 void mc_api::mc_cleanup()
 139 {
 140 }
 141
 142 bool mc_api::request_depend(smx_simcall_t req1, smx_simcall_t req2) const
 143 {
 144   return simgrid::mc::request_depend(req1, req2);
 145 }
 146
 147 std::string mc_api::request_to_string(smx_simcall_t req, int value, RequestType request_type) const
 148 {
 149   return simgrid::mc::request_to_string(req, value, request_type).c_str();
 150 }
 151
 152 const char * mc_api::simix_simcall_name(e_smx_simcall_t kind) const
 153 {
 154   return SIMIX_simcall_name(kind);
 155 }
 156
 157 void mc_api::s_close() const
 158 {
 159   session->close();
 160 }
 161
 162 void mc_api::s_restore_initial_state() const
 163 {
 164   session->restore_initial_state();
 165 }
 166
 167 void mc_api::execute(Transition const& transition)
 168 {
 169   session->execute(transition);
 170 }
 171
 172 void mc_api::s_log_state() const
 173 {
 174   session->log_state();
 175 }
 176
 177 } // namespace mc
 178 } // namespace simgrid