X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8bc85164acb335cf909052b966b2ee4932e06cd7..6025ab6e5b3640ed67a44cc1792725cfbb98936f:/src/mc/mc_request.cpp

diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp
index 53428fdc89..71dc00b20e 100644
--- a/src/mc/mc_request.cpp
+++ b/src/mc/mc_request.cpp
@@ -10,8 +10,10 @@
 #include "src/mc/ModelChecker.hpp"
 #include "src/mc/checker/SimcallInspector.hpp"
 #include "src/mc/mc_smx.hpp"
+#include <array>
 
 using simgrid::mc::remote;
+using simgrid::simix::Simcall;
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_request, mc, "Logging specific to MC (request)");
 
@@ -21,9 +23,9 @@ static char *buff_size_to_string(size_t size);
 static inline simgrid::kernel::activity::CommImpl* MC_get_comm(smx_simcall_t r)
 {
   switch (r->call_) {
-    case SIMCALL_COMM_WAIT:
+    case Simcall::COMM_WAIT:
       return simcall_comm_wait__getraw__comm(r);
-    case SIMCALL_COMM_TEST:
+    case Simcall::COMM_TEST:
       return simcall_comm_test__getraw__comm(r);
     default:
       return nullptr;
@@ -34,9 +36,9 @@ static inline
 smx_mailbox_t MC_get_mbox(smx_simcall_t r)
 {
   switch (r->call_) {
-    case SIMCALL_COMM_ISEND:
+    case Simcall::COMM_ISEND:
       return simcall_comm_isend__get__mbox(r);
-    case SIMCALL_COMM_IRECV:
+    case Simcall::COMM_IRECV:
       return simcall_comm_irecv__get__mbox(r);
     default:
       return nullptr;
@@ -50,17 +52,17 @@ namespace mc {
 static inline
 bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2)
 {
-  if (r1->call_ == SIMCALL_COMM_ISEND && r2->call_ == SIMCALL_COMM_IRECV)
+  if (r1->call_ == Simcall::COMM_ISEND && r2->call_ == Simcall::COMM_IRECV)
     return false;
 
-  if (r1->call_ == SIMCALL_COMM_IRECV && r2->call_ == SIMCALL_COMM_ISEND)
+  if (r1->call_ == Simcall::COMM_IRECV && r2->call_ == Simcall::COMM_ISEND)
     return false;
 
   // Those are internal requests, we do not need indirection because those objects are copies:
   const kernel::activity::CommImpl* synchro1 = MC_get_comm(r1);
   const kernel::activity::CommImpl* synchro2 = MC_get_comm(r2);
 
-  if ((r1->call_ == SIMCALL_COMM_ISEND || r1->call_ == SIMCALL_COMM_IRECV) && r2->call_ == SIMCALL_COMM_WAIT) {
+  if ((r1->call_ == Simcall::COMM_ISEND || r1->call_ == Simcall::COMM_IRECV) && r2->call_ == Simcall::COMM_WAIT) {
     const kernel::activity::MailboxImpl* mbox = MC_get_mbox(r1);
 
     if (mbox != synchro2->mbox_cpy
@@ -71,11 +73,11 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2)
         simcall_comm_wait__get__timeout(r2) <= 0)
       return false;
 
-    if ((r1->call_ == SIMCALL_COMM_ISEND) && (synchro2->type_ == kernel::activity::CommImpl::Type::SEND) &&
+    if ((r1->call_ == Simcall::COMM_ISEND) && (synchro2->type_ == kernel::activity::CommImpl::Type::SEND) &&
         (synchro2->src_buff_ != simcall_comm_isend__get__src_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0)
       return false;
 
-    if ((r1->call_ == SIMCALL_COMM_IRECV) && (synchro2->type_ == kernel::activity::CommImpl::Type::RECEIVE) &&
+    if ((r1->call_ == Simcall::COMM_IRECV) && (synchro2->type_ == kernel::activity::CommImpl::Type::RECEIVE) &&
         (synchro2->dst_buff_ != simcall_comm_irecv__get__dst_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0)
       return false;
   }
@@ -83,24 +85,24 @@ bool request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2)
   /* FIXME: the following rule assumes that the result of the isend/irecv call is not stored in a buffer used in the
    * test call. */
 #if 0
-  if((r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV)
-      &&  r2->call == SIMCALL_COMM_TEST)
+  if((r1->call == Simcall::COMM_ISEND || r1->call == Simcall::COMM_IRECV)
+      &&  r2->call == Simcall::COMM_TEST)
     return false;
 #endif
 
-  if (r1->call_ == SIMCALL_COMM_WAIT && (r2->call_ == SIMCALL_COMM_WAIT || r2->call_ == SIMCALL_COMM_TEST) &&
+  if (r1->call_ == Simcall::COMM_WAIT && (r2->call_ == Simcall::COMM_WAIT || r2->call_ == Simcall::COMM_TEST) &&
       (synchro1->src_actor_.get() == nullptr || synchro1->dst_actor_.get() == nullptr))
     return false;
 
-  if (r1->call_ == SIMCALL_COMM_TEST &&
+  if (r1->call_ == Simcall::COMM_TEST &&
       (simcall_comm_test__get__comm(r1) == nullptr || synchro1->src_buff_ == nullptr || synchro1->dst_buff_ == nullptr))
     return false;
 
-  if (r1->call_ == SIMCALL_COMM_TEST && r2->call_ == SIMCALL_COMM_WAIT && synchro1->src_buff_ == synchro2->src_buff_ &&
-      synchro1->dst_buff_ == synchro2->dst_buff_)
+  if (r1->call_ == Simcall::COMM_TEST && r2->call_ == Simcall::COMM_WAIT &&
+      synchro1->src_buff_ == synchro2->src_buff_ && synchro1->dst_buff_ == synchro2->dst_buff_)
     return false;
 
-  if (r1->call_ == SIMCALL_COMM_WAIT && r2->call_ == SIMCALL_COMM_TEST && synchro1->src_buff_ != nullptr &&
+  if (r1->call_ == Simcall::COMM_WAIT && r2->call_ == Simcall::COMM_TEST && synchro1->src_buff_ != nullptr &&
       synchro1->dst_buff_ != nullptr && synchro2->src_buff_ != nullptr && synchro2->dst_buff_ != nullptr &&
       synchro1->dst_buff_ != synchro2->src_buff_ && synchro1->dst_buff_ != synchro2->dst_buff_ &&
       synchro2->dst_buff_ != synchro1->src_buff_)
@@ -116,8 +118,8 @@ bool request_depend(smx_simcall_t req1, smx_simcall_t req2)
     return false;
 
   /* Wait with timeout transitions are not considered by the independence theorem, thus we consider them as dependent with all other transitions */
-  if ((req1->call_ == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req1) > 0) ||
-      (req2->call_ == SIMCALL_COMM_WAIT && simcall_comm_wait__get__timeout(req2) > 0))
+  if ((req1->call_ == Simcall::COMM_WAIT && simcall_comm_wait__get__timeout(req1) > 0) ||
+      (req2->call_ == Simcall::COMM_WAIT && simcall_comm_wait__get__timeout(req2) > 0))
     return true;
 
   if (req1->call_ != req2->call_)
@@ -128,11 +130,11 @@ bool request_depend(smx_simcall_t req1, smx_simcall_t req2)
   const kernel::activity::CommImpl* synchro2 = MC_get_comm(req2);
 
   switch (req1->call_) {
-    case SIMCALL_COMM_ISEND:
+    case Simcall::COMM_ISEND:
       return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2);
-    case SIMCALL_COMM_IRECV:
+    case Simcall::COMM_IRECV:
       return simcall_comm_irecv__get__mbox(req1) == simcall_comm_irecv__get__mbox(req2);
-    case SIMCALL_COMM_WAIT:
+    case Simcall::COMM_WAIT:
       if (synchro1->src_buff_ == synchro2->src_buff_ && synchro1->dst_buff_ == synchro2->dst_buff_)
         return false;
       if (synchro1->src_buff_ != nullptr && synchro1->dst_buff_ != nullptr && synchro2->src_buff_ != nullptr &&
@@ -191,7 +193,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
   smx_actor_t issuer = MC_smx_simcall_get_issuer(req);
 
   switch (req->call_) {
-    case SIMCALL_COMM_ISEND: {
+    case Simcall::COMM_ISEND: {
       type     = "iSend";
       char* p  = pointer_to_string(simcall_comm_isend__get__src_buff(req));
       char* bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req));
@@ -205,7 +207,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_COMM_IRECV: {
+    case Simcall::COMM_IRECV: {
       size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req);
       size_t size         = 0;
       if (remote_size)
@@ -224,7 +226,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_COMM_WAIT: {
+    case Simcall::COMM_WAIT: {
       simgrid::kernel::activity::CommImpl* remote_act = simcall_comm_wait__getraw__comm(req);
       char* p;
       if (value == -1) {
@@ -257,7 +259,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_COMM_TEST: {
+    case Simcall::COMM_TEST: {
       simgrid::kernel::activity::CommImpl* remote_act = simcall_comm_test__getraw__comm(req);
       simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
       const simgrid::kernel::activity::CommImpl* act;
@@ -288,7 +290,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_COMM_WAITANY: {
+    case Simcall::COMM_WAITANY: {
       type         = "WaitAny";
       size_t count = simcall_comm_waitany__get__count(req);
       if (count > 0) {
@@ -303,7 +305,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_COMM_TESTANY:
+    case Simcall::COMM_TESTANY:
       if (value == -1) {
         type = "TestAny FALSE";
         args = xbt_strdup("-");
@@ -313,16 +315,16 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       }
       break;
 
-    case SIMCALL_MUTEX_TRYLOCK:
-    case SIMCALL_MUTEX_LOCK: {
-      if (req->call_ == SIMCALL_MUTEX_LOCK)
+    case Simcall::MUTEX_TRYLOCK:
+    case Simcall::MUTEX_LOCK: {
+      if (req->call_ == Simcall::MUTEX_LOCK)
         type = "Mutex LOCK";
       else
         type = "Mutex TRYLOCK";
 
       simgrid::mc::Remote<simgrid::kernel::activity::MutexImpl> mutex;
       mc_model_checker->get_remote_simulation().read_bytes(mutex.get_buffer(), sizeof(mutex),
-                                                           remote(req->call_ == SIMCALL_MUTEX_LOCK
+                                                           remote(req->call_ == Simcall::MUTEX_LOCK
                                                                       ? simcall_mutex_lock__get__mutex(req)
                                                                       : simcall_mutex_trylock__get__mutex(req)));
       args = bprintf("locked = %d, owner = %d, sleeping = n/a", mutex.get_buffer()->is_locked(),
@@ -334,7 +336,7 @@ std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid
       break;
     }
 
-    case SIMCALL_MC_RANDOM:
+    case Simcall::MC_RANDOM:
       type = "MC_RANDOM";
       args = bprintf("%d", value);
       break;
@@ -363,16 +365,16 @@ bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
 {
   kernel::activity::CommImpl* remote_act = nullptr;
   switch (req->call_) {
-    case SIMCALL_COMM_WAIT:
+    case Simcall::COMM_WAIT:
       /* FIXME: check also that src and dst processes are not suspended */
       remote_act = simcall_comm_wait__getraw__comm(req);
       break;
 
-    case SIMCALL_COMM_WAITANY:
-      remote_act = mc_model_checker->get_remote_simulation().read(remote(simcall_comm_testany__get__comms(req) + idx));
+    case Simcall::COMM_WAITANY:
+      remote_act = mc_model_checker->get_remote_simulation().read(remote(simcall_comm_waitany__get__comms(req) + idx));
       break;
 
-    case SIMCALL_COMM_TESTANY:
+    case Simcall::COMM_TESTANY:
       remote_act = mc_model_checker->get_remote_simulation().read(remote(simcall_comm_testany__get__comms(req) + idx));
       break;
 
@@ -386,14 +388,12 @@ bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx)
   return comm->src_actor_.get() && comm->dst_actor_.get();
 }
 
-static const char* colors[] = {
-    "blue",       "red",    "green3",      "goldenrod", "brown",     "purple", "magenta",
-    "turquoise4", "gray25", "forestgreen", "hotpink",   "lightblue", "tan",
-};
-
 static inline const char* get_color(int id)
 {
-  return colors[id % (sizeof(colors) / sizeof(colors[0])) ];
+  static constexpr std::array<const char*, 13> colors{{"blue", "red", "green3", "goldenrod", "brown", "purple",
+                                                       "magenta", "turquoise4", "gray25", "forestgreen", "hotpink",
+                                                       "lightblue", "tan"}};
+  return colors[id % colors.size()];
 }
 
 std::string request_get_dot_output(smx_simcall_t req, int value)
@@ -408,21 +408,21 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
   std::string label;
 
   switch (req->call_) {
-    case SIMCALL_COMM_ISEND:
+    case Simcall::COMM_ISEND:
       if (issuer->get_host())
         label = xbt::string_printf("[(%ld)%s] iSend", issuer->get_pid(), MC_smx_actor_get_host_name(issuer));
       else
         label = bprintf("[(%ld)] iSend", issuer->get_pid());
       break;
 
-    case SIMCALL_COMM_IRECV:
+    case Simcall::COMM_IRECV:
       if (issuer->get_host())
         label = xbt::string_printf("[(%ld)%s] iRecv", issuer->get_pid(), MC_smx_actor_get_host_name(issuer));
       else
         label = xbt::string_printf("[(%ld)] iRecv", issuer->get_pid());
       break;
 
-    case SIMCALL_COMM_WAIT:
+    case Simcall::COMM_WAIT:
       if (value == -1) {
         if (issuer->get_host())
           label = xbt::string_printf("[(%ld)%s] WaitTimeout", issuer->get_pid(), MC_smx_actor_get_host_name(issuer));
@@ -449,7 +449,7 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
       }
       break;
 
-    case SIMCALL_COMM_TEST: {
+    case Simcall::COMM_TEST: {
       kernel::activity::ActivityImpl* remote_act = simcall_comm_test__getraw__comm(req);
       Remote<simgrid::kernel::activity::CommImpl> temp_comm;
       mc_model_checker->get_remote_simulation().read(temp_comm,
@@ -469,7 +469,7 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
       break;
     }
 
-    case SIMCALL_COMM_WAITANY: {
+    case Simcall::COMM_WAITANY: {
       size_t comms_size = simcall_comm_waitany__get__count(req);
       if (issuer->get_host())
         label = xbt::string_printf("[(%ld)%s] WaitAny [%d of %zu]", issuer->get_pid(),
@@ -479,7 +479,7 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
       break;
     }
 
-    case SIMCALL_COMM_TESTANY:
+    case Simcall::COMM_TESTANY:
       if (value == -1) {
         if (issuer->get_host())
           label = xbt::string_printf("[(%ld)%s] TestAny FALSE", issuer->get_pid(), MC_smx_actor_get_host_name(issuer));
@@ -496,15 +496,15 @@ std::string request_get_dot_output(smx_simcall_t req, int value)
       }
       break;
 
-    case SIMCALL_MUTEX_TRYLOCK:
+    case Simcall::MUTEX_TRYLOCK:
       label = xbt::string_printf("[(%ld)] Mutex TRYLOCK", issuer->get_pid());
       break;
 
-    case SIMCALL_MUTEX_LOCK:
+    case Simcall::MUTEX_LOCK:
       label = xbt::string_printf("[(%ld)] Mutex LOCK", issuer->get_pid());
       break;
 
-    case SIMCALL_MC_RANDOM:
+    case Simcall::MC_RANDOM:
       if (issuer->get_host())
         label = xbt::string_printf("[(%ld)%s] MC_RANDOM (%d)", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
                                    value);