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