request_to_string() implementation in mc_api class

diff --git a/src/mc/mc_api.cpp b/src/mc/mc_api.cpp
index 01c594a..1953d6d 100644 (file)
--- a/src/mc/mc_api.cpp
+++ b/src/mc/mc_api.cpp
@@ -1,6 +1,7 @@
 #include "mc_api.hpp"
 
 #include "src/kernel/activity/MailboxImpl.hpp"
+#include "src/kernel/activity/MutexImpl.hpp"
 #include "src/mc/Session.hpp"
 #include "src/mc/mc_comm_pattern.hpp"
 #include "src/mc/mc_private.hpp"
@@ -9,7 +10,6 @@
 #include "src/mc/remote/RemoteSimulation.hpp"
 #include "src/mc/mc_pattern.hpp"
 #include "src/mc/checker/SimcallInspector.hpp"
-
 #include <xbt/asserts.h>
 #include <xbt/log.h>
 
@@ -30,7 +30,23 @@ static inline const char* get_color(int id)
                                                        "magenta", "turquoise4", "gray25", "forestgreen", "hotpink",
                                                        "lightblue", "tan"}};
   return colors[id % colors.size()];
-}  
+}
+
+static char *pointer_to_string(void *pointer)
+{
+  if (XBT_LOG_ISENABLED(mc_api, xbt_log_priority_verbose))
+    return bprintf("%p", pointer);
+
+  return xbt_strdup("(verbose only)");
+}
+
+static char *buff_size_to_string(size_t buff_size)
+{
+  if (XBT_LOG_ISENABLED(mc_api, xbt_log_priority_verbose))
+    return bprintf("%zu", buff_size);
+
+  return xbt_strdup("(verbose only)");
+}
 
 /* Search an enabled transition for the given process.
  *
@@ -451,7 +467,193 @@ bool mc_api::request_depend(smx_simcall_t req1, smx_simcall_t req2) const
 
 std::string mc_api::request_to_string(smx_simcall_t req, int value, RequestType request_type) const
 {
-  return simgrid::mc::request_to_string(req, value, request_type).c_str();
+  xbt_assert(mc_model_checker != nullptr, "Must be called from MCer");
+
+  if (req->inspector_ != nullptr)
+    return req->inspector_->to_string();
+
+  bool use_remote_comm = true;
+  switch(request_type) {
+  case simgrid::mc::RequestType::simix:
+    use_remote_comm = true;
+    break;
+  case simgrid::mc::RequestType::executed:
+  case simgrid::mc::RequestType::internal:
+    use_remote_comm = false;
+    break;
+  default:
+    THROW_IMPOSSIBLE;
+  }
+
+  const char* type = nullptr;
+  char *args = nullptr;
+
+  smx_actor_t issuer = MC_smx_simcall_get_issuer(req);
+
+  switch (req->call_) {
+    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));
+      if (issuer->get_host())
+        args = bprintf("src=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
+                       MC_smx_actor_get_name(issuer), p, bs);
+      else
+        args = bprintf("src=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs);
+      xbt_free(bs);
+      xbt_free(p);
+      break;
+    }
+
+    case Simcall::COMM_IRECV: {
+      size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req);
+      size_t size         = 0;
+      if (remote_size)
+        mc_model_checker->get_remote_simulation().read_bytes(&size, sizeof(size), remote(remote_size));
+
+      type     = "iRecv";
+      char* p  = pointer_to_string(simcall_comm_irecv__get__dst_buff(req));
+      char* bs = buff_size_to_string(size);
+      if (issuer->get_host())
+        args = bprintf("dst=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
+                       MC_smx_actor_get_name(issuer), p, bs);
+      else
+        args = bprintf("dst=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs);
+      xbt_free(bs);
+      xbt_free(p);
+      break;
+    }
+
+    case Simcall::COMM_WAIT: {
+      simgrid::kernel::activity::CommImpl* remote_act = simcall_comm_wait__getraw__comm(req);
+      char* p;
+      if (value == -1) {
+        type = "WaitTimeout";
+        p    = pointer_to_string(remote_act);
+        args = bprintf("comm=%s", p);
+      } else {
+        type = "Wait";
+        p    = pointer_to_string(remote_act);
+
+        simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
+        const simgrid::kernel::activity::CommImpl* act;
+        if (use_remote_comm) {
+          mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act));
+          act = temp_synchro.get_buffer();
+        } else
+          act = remote_act;
+
+        smx_actor_t src_proc =
+            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->src_actor_.get()));
+        smx_actor_t dst_proc =
+            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->dst_actor_.get()));
+        args                 = bprintf("comm=%s [(%ld)%s (%s)-> (%ld)%s (%s)]", p, src_proc ? src_proc->get_pid() : 0,
+                       src_proc ? MC_smx_actor_get_host_name(src_proc) : "",
+                       src_proc ? MC_smx_actor_get_name(src_proc) : "", dst_proc ? dst_proc->get_pid() : 0,
+                       dst_proc ? MC_smx_actor_get_host_name(dst_proc) : "",
+                       dst_proc ? MC_smx_actor_get_name(dst_proc) : "");
+      }
+      xbt_free(p);
+      break;
+    }
+
+    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;
+      if (use_remote_comm) {
+        mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act));
+        act = temp_synchro.get_buffer();
+      } else
+        act = remote_act;
+
+      char* p;
+      if (act->src_actor_.get() == nullptr || act->dst_actor_.get() == nullptr) {
+        type = "Test FALSE";
+        p    = pointer_to_string(remote_act);
+        args = bprintf("comm=%s", p);
+      } else {
+        type = "Test TRUE";
+        p    = pointer_to_string(remote_act);
+
+        smx_actor_t src_proc =
+            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->src_actor_.get()));
+        smx_actor_t dst_proc =
+            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->dst_actor_.get()));
+        args                 = bprintf("comm=%s [(%ld)%s (%s) -> (%ld)%s (%s)]", p, src_proc->get_pid(),
+                       MC_smx_actor_get_name(src_proc), MC_smx_actor_get_host_name(src_proc), dst_proc->get_pid(),
+                       MC_smx_actor_get_name(dst_proc), MC_smx_actor_get_host_name(dst_proc));
+      }
+      xbt_free(p);
+      break;
+    }
+
+    case Simcall::COMM_WAITANY: {
+      type         = "WaitAny";
+      size_t count = simcall_comm_waitany__get__count(req);
+      if (count > 0) {
+        simgrid::kernel::activity::CommImpl* remote_sync;
+        remote_sync =
+            mc_model_checker->get_remote_simulation().read(remote(simcall_comm_waitany__get__comms(req) + value));
+        char* p     = pointer_to_string(remote_sync);
+        args        = bprintf("comm=%s (%d of %zu)", p, value + 1, count);
+        xbt_free(p);
+      } else
+        args = bprintf("comm at idx %d", value);
+      break;
+    }
+
+    case Simcall::COMM_TESTANY:
+      if (value == -1) {
+        type = "TestAny FALSE";
+        args = xbt_strdup("-");
+      } else {
+        type = "TestAny";
+        args = bprintf("(%d of %zu)", value + 1, simcall_comm_testany__get__count(req));
+      }
+      break;
+
+    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
+                                                                      ? 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(),
+                     mutex.get_buffer()->get_owner() != nullptr
+                         ? (int)mc_model_checker->get_remote_simulation()
+                               .resolve_actor(simgrid::mc::remote(mutex.get_buffer()->get_owner()))
+                               ->get_pid()
+                         : -1);
+      break;
+    }
+
+    case Simcall::MC_RANDOM:
+      type = "MC_RANDOM";
+      args = bprintf("%d", value);
+      break;
+
+    default:
+      type = SIMIX_simcall_name(req->call_);
+      args = bprintf("??");
+      break;
+  }
+
+  std::string str;
+  if (args != nullptr)
+    str = simgrid::xbt::string_printf("[(%ld)%s (%s)] %s(%s)", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
+                                      MC_smx_actor_get_name(issuer), type, args);
+  else
+    str = simgrid::xbt::string_printf("[(%ld)%s (%s)] %s ", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
+                                      MC_smx_actor_get_name(issuer), type);
+  xbt_free(args);
+  return str;  
 }
 
 std::string mc_api::request_get_dot_output(smx_simcall_t req, int value) const

diff --git a/src/mc/mc_request.cpp b/src/mc/mc_request.cpp
index 39e7f5b..371ae86 100644 (file)
--- a/src/mc/mc_request.cpp
+++ b/src/mc/mc_request.cpp
@@ -166,198 +166,6 @@ static char *buff_size_to_string(size_t buff_size)
   return xbt_strdup("(verbose only)");
 }
 
-
-std::string simgrid::mc::request_to_string(smx_simcall_t req, int value, simgrid::mc::RequestType request_type)
-{
-  xbt_assert(mc_model_checker != nullptr, "Must be called from MCer");
-
-  if (req->inspector_ != nullptr)
-    return req->inspector_->to_string();
-
-  bool use_remote_comm = true;
-  switch(request_type) {
-  case simgrid::mc::RequestType::simix:
-    use_remote_comm = true;
-    break;
-  case simgrid::mc::RequestType::executed:
-  case simgrid::mc::RequestType::internal:
-    use_remote_comm = false;
-    break;
-  default:
-    THROW_IMPOSSIBLE;
-  }
-
-  const char* type = nullptr;
-  char *args = nullptr;
-
-  smx_actor_t issuer = MC_smx_simcall_get_issuer(req);
-
-  switch (req->call_) {
-    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));
-      if (issuer->get_host())
-        args = bprintf("src=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
-                       MC_smx_actor_get_name(issuer), p, bs);
-      else
-        args = bprintf("src=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs);
-      xbt_free(bs);
-      xbt_free(p);
-      break;
-    }
-
-    case Simcall::COMM_IRECV: {
-      size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req);
-      size_t size         = 0;
-      if (remote_size)
-        mc_model_checker->get_remote_simulation().read_bytes(&size, sizeof(size), remote(remote_size));
-
-      type     = "iRecv";
-      char* p  = pointer_to_string(simcall_comm_irecv__get__dst_buff(req));
-      char* bs = buff_size_to_string(size);
-      if (issuer->get_host())
-        args = bprintf("dst=(%ld)%s (%s), buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
-                       MC_smx_actor_get_name(issuer), p, bs);
-      else
-        args = bprintf("dst=(%ld)%s, buff=%s, size=%s", issuer->get_pid(), MC_smx_actor_get_name(issuer), p, bs);
-      xbt_free(bs);
-      xbt_free(p);
-      break;
-    }
-
-    case Simcall::COMM_WAIT: {
-      simgrid::kernel::activity::CommImpl* remote_act = simcall_comm_wait__getraw__comm(req);
-      char* p;
-      if (value == -1) {
-        type = "WaitTimeout";
-        p    = pointer_to_string(remote_act);
-        args = bprintf("comm=%s", p);
-      } else {
-        type = "Wait";
-        p    = pointer_to_string(remote_act);
-
-        simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
-        const simgrid::kernel::activity::CommImpl* act;
-        if (use_remote_comm) {
-          mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act));
-          act = temp_synchro.get_buffer();
-        } else
-          act = remote_act;
-
-        smx_actor_t src_proc =
-            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->src_actor_.get()));
-        smx_actor_t dst_proc =
-            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->dst_actor_.get()));
-        args                 = bprintf("comm=%s [(%ld)%s (%s)-> (%ld)%s (%s)]", p, src_proc ? src_proc->get_pid() : 0,
-                       src_proc ? MC_smx_actor_get_host_name(src_proc) : "",
-                       src_proc ? MC_smx_actor_get_name(src_proc) : "", dst_proc ? dst_proc->get_pid() : 0,
-                       dst_proc ? MC_smx_actor_get_host_name(dst_proc) : "",
-                       dst_proc ? MC_smx_actor_get_name(dst_proc) : "");
-      }
-      xbt_free(p);
-      break;
-    }
-
-    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;
-      if (use_remote_comm) {
-        mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act));
-        act = temp_synchro.get_buffer();
-      } else
-        act = remote_act;
-
-      char* p;
-      if (act->src_actor_.get() == nullptr || act->dst_actor_.get() == nullptr) {
-        type = "Test FALSE";
-        p    = pointer_to_string(remote_act);
-        args = bprintf("comm=%s", p);
-      } else {
-        type = "Test TRUE";
-        p    = pointer_to_string(remote_act);
-
-        smx_actor_t src_proc =
-            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->src_actor_.get()));
-        smx_actor_t dst_proc =
-            mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->dst_actor_.get()));
-        args                 = bprintf("comm=%s [(%ld)%s (%s) -> (%ld)%s (%s)]", p, src_proc->get_pid(),
-                       MC_smx_actor_get_name(src_proc), MC_smx_actor_get_host_name(src_proc), dst_proc->get_pid(),
-                       MC_smx_actor_get_name(dst_proc), MC_smx_actor_get_host_name(dst_proc));
-      }
-      xbt_free(p);
-      break;
-    }
-
-    case Simcall::COMM_WAITANY: {
-      type         = "WaitAny";
-      size_t count = simcall_comm_waitany__get__count(req);
-      if (count > 0) {
-        simgrid::kernel::activity::CommImpl* remote_sync;
-        remote_sync =
-            mc_model_checker->get_remote_simulation().read(remote(simcall_comm_waitany__get__comms(req) + value));
-        char* p     = pointer_to_string(remote_sync);
-        args        = bprintf("comm=%s (%d of %zu)", p, value + 1, count);
-        xbt_free(p);
-      } else
-        args = bprintf("comm at idx %d", value);
-      break;
-    }
-
-    case Simcall::COMM_TESTANY:
-      if (value == -1) {
-        type = "TestAny FALSE";
-        args = xbt_strdup("-");
-      } else {
-        type = "TestAny";
-        args = bprintf("(%d of %zu)", value + 1, simcall_comm_testany__get__count(req));
-      }
-      break;
-
-    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
-                                                                      ? 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(),
-                     mutex.get_buffer()->get_owner() != nullptr
-                         ? (int)mc_model_checker->get_remote_simulation()
-                               .resolve_actor(simgrid::mc::remote(mutex.get_buffer()->get_owner()))
-                               ->get_pid()
-                         : -1);
-      break;
-    }
-
-    case Simcall::MC_RANDOM:
-      type = "MC_RANDOM";
-      args = bprintf("%d", value);
-      break;
-
-    default:
-      type = SIMIX_simcall_name(req->call_);
-      args = bprintf("??");
-      break;
-  }
-
-  std::string str;
-  if (args != nullptr)
-    str = simgrid::xbt::string_printf("[(%ld)%s (%s)] %s(%s)", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
-                                      MC_smx_actor_get_name(issuer), type, args);
-  else
-    str = simgrid::xbt::string_printf("[(%ld)%s (%s)] %s ", issuer->get_pid(), MC_smx_actor_get_host_name(issuer),
-                                      MC_smx_actor_get_name(issuer), type);
-  xbt_free(args);
-  return str;
-}
-
 namespace simgrid {
 namespace mc {
 

diff --git a/src/mc/mc_request.hpp b/src/mc/mc_request.hpp
index a18e428..f8dbc06 100644 (file)
--- a/src/mc/mc_request.hpp
+++ b/src/mc/mc_request.hpp
@@ -19,8 +19,6 @@ enum class RequestType {
 
 XBT_PRIVATE bool request_depend(smx_simcall_t req1, smx_simcall_t req2);
 
-XBT_PRIVATE std::string request_to_string(smx_simcall_t req, int value, simgrid::mc::RequestType type);
-
 XBT_PRIVATE bool request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx);
 }
 }