X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d13b1659a0c2551ee41b287a269e391bb2d7bc8a..f1b22d20918d4ccd703690a19e476429cfa124f3:/src/mc/mc_smx.cpp

diff --git a/src/mc/mc_smx.cpp b/src/mc/mc_smx.cpp
index 12d9216155..7b760772c2 100644
--- a/src/mc/mc_smx.cpp
+++ b/src/mc/mc_smx.cpp
@@ -13,17 +13,15 @@
 #include "mc_smx.h"
 #include "ModelChecker.hpp"
 
+using simgrid::mc::remote;
+
 extern "C" {
 
 static
 void MC_smx_process_info_clear(mc_smx_process_info_t p)
 {
   p->hostname = NULL;
-
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
   free(p->name);
-  mmalloc_set_current_heap(heap);
-
   p->name = NULL;
 }
 
@@ -59,13 +57,12 @@ mc_smx_process_info_t MC_smx_process_get_info(smx_process_t p)
  *  @param remote_swag Address of the process SWAG in the remote list
  */
 static void MC_process_refresh_simix_process_list(
-  mc_process_t process,
+  simgrid::mc::Process* process,
   xbt_dynar_t target, xbt_swag_t remote_swag)
 {
   // swag = REMOTE(*simix_global->process_list)
   s_xbt_swag_t swag;
-  MC_process_read(process, MC_PROCESS_NO_FLAG, &swag, remote_swag, sizeof(swag),
-    MC_PROCESS_INDEX_ANY);
+  process->read_bytes(&swag, sizeof(swag), remote(remote_swag));
 
   smx_process_t p;
   xbt_dynar_reset(target);
@@ -78,8 +75,7 @@ static void MC_process_refresh_simix_process_list(
     info.address = p;
     info.name = NULL;
     info.hostname = NULL;
-    MC_process_read(process, MC_PROCESS_NO_FLAG,
-      &info.copy, p, sizeof(info.copy), MC_PROCESS_INDEX_ANY);
+    process->read_bytes(&info.copy, sizeof(info.copy), remote(p));
     xbt_dynar_push(target, &info);
 
     // Lookup next process address:
@@ -88,23 +84,23 @@ static void MC_process_refresh_simix_process_list(
   assert(i == swag.count);
 }
 
-void MC_process_smx_refresh(mc_process_t process)
+void MC_process_smx_refresh(simgrid::mc::Process* process)
 {
+  xbt_assert(mc_mode == MC_MODE_SERVER);
+  xbt_assert(!process->is_self());
   if (process->cache_flags & MC_PROCESS_CACHE_FLAG_SIMIX_PROCESSES)
     return;
 
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   // TODO, avoid to reload `&simix_global`, `simix_global`, `*simix_global`
 
   // simix_global_p = REMOTE(simix_global);
   smx_global_t simix_global_p;
-  MC_process_read_variable(process, "simix_global", &simix_global_p, sizeof(simix_global_p));
+  process->read_variable("simix_global", &simix_global_p, sizeof(simix_global_p));
 
   // simix_global = REMOTE(*simix_global)
   s_smx_global_t simix_global;
-  MC_process_read(process, MC_PROCESS_NO_FLAG, &simix_global, simix_global_p, sizeof(simix_global),
-    MC_PROCESS_INDEX_ANY);
+  process->read_bytes(&simix_global, sizeof(simix_global),
+    remote(simix_global_p));
 
   MC_process_refresh_simix_process_list(
     process, process->smx_process_infos, simix_global.process_list);
@@ -112,7 +108,6 @@ void MC_process_smx_refresh(mc_process_t process)
     process, process->smx_old_process_infos, simix_global.process_to_destroy);
 
   process->cache_flags |= MC_PROCESS_CACHE_FLAG_SIMIX_PROCESSES;
-  mmalloc_set_current_heap(heap);
 }
 
 /** Get the issuer of a simcall (`req->issuer`)
@@ -126,7 +121,7 @@ void MC_process_smx_refresh(mc_process_t process)
  */
 smx_process_t MC_smx_simcall_get_issuer(smx_simcall_t req)
 {
-  if (MC_process_is_self(&mc_model_checker->process()))
+  if (mc_mode == MC_MODE_CLIENT)
     return req->issuer;
 
   MC_process_smx_refresh(&mc_model_checker->process());
@@ -152,7 +147,7 @@ smx_process_t MC_smx_resolve_process(smx_process_t process_remote_address)
 {
   if (!process_remote_address)
     return NULL;
-  if (MC_process_is_self(&mc_model_checker->process()))
+  if (mc_mode == MC_MODE_CLIENT)
     return process_remote_address;
 
   mc_smx_process_info_t process_info = MC_smx_resolve_process_info(process_remote_address);
@@ -164,7 +159,7 @@ smx_process_t MC_smx_resolve_process(smx_process_t process_remote_address)
 
 mc_smx_process_info_t MC_smx_resolve_process_info(smx_process_t process_remote_address)
 {
-  if (MC_process_is_self(&mc_model_checker->process()))
+  if (mc_mode == MC_MODE_CLIENT)
     xbt_die("No process_info for local process is not enabled.");
 
   unsigned index;
@@ -180,10 +175,10 @@ mc_smx_process_info_t MC_smx_resolve_process_info(smx_process_t process_remote_a
 
 const char* MC_smx_process_get_host_name(smx_process_t p)
 {
-  if (MC_process_is_self(&mc_model_checker->process()))
-    return SIMIX_host_get_name(p->smx_host);
+  if (mc_mode == MC_MODE_CLIENT)
+    return SIMIX_host_get_name(p->host);
 
-  mc_process_t process = &mc_model_checker->process();
+  simgrid::mc::Process* process = &mc_model_checker->process();
 
   // Currently, smx_host_t = xbt_dictelm_t.
   // TODO, add an static_assert on this if switching to C++
@@ -193,10 +188,10 @@ const char* MC_smx_process_get_host_name(smx_process_t p)
   if (!info->hostname) {
 
     // Read the hostname from the MCed process:
-    MC_process_read_simple(process, &host_copy, p->smx_host, sizeof(host_copy));
+    process->read_bytes(&host_copy, sizeof(host_copy), remote(p->host));
     int len = host_copy.key_len + 1;
     char hostname[len];
-    MC_process_read_simple(process, hostname, host_copy.key, len);
+    process->read_bytes(hostname, len, remote(host_copy.key));
     info->hostname = mc_model_checker->get_host_name(hostname);
   }
   return info->hostname;
@@ -204,37 +199,37 @@ const char* MC_smx_process_get_host_name(smx_process_t p)
 
 const char* MC_smx_process_get_name(smx_process_t p)
 {
-  mc_process_t process = &mc_model_checker->process();
-  if (MC_process_is_self(process))
+  simgrid::mc::Process* process = &mc_model_checker->process();
+  if (mc_mode == MC_MODE_CLIENT)
     return p->name;
   if (!p->name)
     return NULL;
 
   mc_smx_process_info_t info = MC_smx_process_get_info(p);
   if (!info->name) {
-    xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-    info->name = MC_process_read_string(process, p->name);
-    mmalloc_set_current_heap(heap);
+    info->name = process->read_string(p->name);
   }
   return info->name;
 }
 
+#ifdef HAVE_SMPI
 int MC_smpi_process_count(void)
 {
-  if (MC_process_is_self(&mc_model_checker->process()))
+  if (mc_mode == MC_MODE_CLIENT)
     return smpi_process_count();
   else {
     int res;
-    MC_process_read_variable(&mc_model_checker->process(), "process_count",
+    mc_model_checker->process().read_variable("process_count",
       &res, sizeof(res));
     return res;
   }
 }
+#endif
 
 unsigned long MC_smx_get_maxpid(void)
 {
   unsigned long maxpid;
-  MC_process_read_variable(&mc_model_checker->process(), "simix_process_maxpid",
+  mc_model_checker->process().read_variable("simix_process_maxpid",
     &maxpid, sizeof(maxpid));
   return maxpid;
 }