X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/84402e8e2ee2a2d0bef25fdceb0a263ed8b471f6..813e836067a1aa922c5fb1432300b7e6390ee352:/src/mc/mc_smx.cpp

diff --git a/src/mc/mc_smx.cpp b/src/mc/mc_smx.cpp
index af66ee9db3..6c8e6304b7 100644
--- a/src/mc/mc_smx.cpp
+++ b/src/mc/mc_smx.cpp
@@ -10,7 +10,7 @@
 
 using simgrid::mc::remote;
 
-/** HACK, Statically "upcast" a s_smx_actor_t into a ActorInformation
+/** HACK, Statically "upcast" a s_smx_actor_t into an ActorInformation
  *
  *  This gets 'actorInfo' from '&actorInfo->copy'. It upcasts in the
  *  sense that we could achieve the same thing by having ActorInformation
@@ -21,7 +21,7 @@ static inline simgrid::mc::ActorInformation* actor_info_cast(smx_actor_t actor)
   simgrid::mc::ActorInformation temp;
   std::size_t offset = (char*)temp.copy.get_buffer() - (char*)&temp;
 
-  simgrid::mc::ActorInformation* process_info = (simgrid::mc::ActorInformation*)((char*)actor - offset);
+  auto* process_info = reinterpret_cast<simgrid::mc::ActorInformation*>((char*)actor - offset);
   return process_info;
 }
 
@@ -31,7 +31,7 @@ static inline simgrid::mc::ActorInformation* actor_info_cast(smx_actor_t actor)
  *  @param target       Local vector (to be filled with copies of `s_smx_actor_t`)
  *  @param remote_dynar Address of the process dynar in the remote list
  */
-static void MC_process_refresh_simix_actor_dynar(const simgrid::mc::RemoteClient* process,
+static void MC_process_refresh_simix_actor_dynar(const simgrid::mc::RemoteSimulation* process,
                                                  std::vector<simgrid::mc::ActorInformation>& target,
                                                  simgrid::mc::RemotePtr<s_xbt_dynar_t> remote_dynar)
 {
@@ -40,13 +40,13 @@ static void MC_process_refresh_simix_actor_dynar(const simgrid::mc::RemoteClient
   s_xbt_dynar_t dynar;
   process->read_bytes(&dynar, sizeof(dynar), remote_dynar);
 
-  smx_actor_t* data = static_cast<smx_actor_t*>(::operator new(dynar.elmsize * dynar.used));
+  auto* data = static_cast<smx_actor_t*>(::operator new(dynar.elmsize * dynar.used));
   process->read_bytes(data, dynar.elmsize * dynar.used, simgrid::mc::RemotePtr<void>(dynar.data));
 
   // Load each element of the vector from the MCed process:
   for (unsigned int i = 0; i < dynar.used; ++i) {
-
     simgrid::mc::ActorInformation info;
+
     info.address  = simgrid::mc::RemotePtr<simgrid::kernel::actor::ActorImpl>(data[i]);
     info.hostname = nullptr;
     process->read_bytes(&info.copy, sizeof(info.copy), remote(data[i]));
@@ -57,9 +57,9 @@ static void MC_process_refresh_simix_actor_dynar(const simgrid::mc::RemoteClient
 namespace simgrid {
 namespace mc {
 
-void RemoteClient::refresh_simix()
+void RemoteSimulation::refresh_simix()
 {
-  if (this->cache_flags_ & RemoteClient::cache_simix_processes)
+  if (this->cache_flags_ & RemoteSimulation::cache_simix_processes)
     return;
 
   // TODO, avoid to reload `&simix_global`, `simix_global`, `*simix_global`
@@ -81,7 +81,7 @@ void RemoteClient::refresh_simix()
   MC_process_refresh_simix_actor_dynar(this, this->smx_dead_actors_infos,
                                        remote(simix_global.get_buffer()->dead_actors_vector));
 
-  this->cache_flags_ |= RemoteClient::cache_simix_processes;
+  this->cache_flags_ |= RemoteSimulation::cache_simix_processes;
 }
 
 }
@@ -104,10 +104,10 @@ smx_actor_t MC_smx_simcall_get_issuer(s_smx_simcall const* req)
   auto address = simgrid::mc::remote(req->issuer_);
 
   // Lookup by address:
-  for (auto& actor : mc_model_checker->process().actors())
+  for (auto& actor : mc_model_checker->get_remote_simulation().actors())
     if (actor.address == address)
       return actor.copy.get_buffer();
-  for (auto& actor : mc_model_checker->process().dead_actors())
+  for (auto& actor : mc_model_checker->get_remote_simulation().dead_actors())
     if (actor.address == address)
       return actor.copy.get_buffer();
 
@@ -119,25 +119,27 @@ const char* MC_smx_actor_get_host_name(smx_actor_t actor)
   if (mc_model_checker == nullptr)
     return actor->get_host()->get_cname();
 
-  const simgrid::mc::RemoteClient* process = &mc_model_checker->process();
+  const simgrid::mc::RemoteSimulation* process = &mc_model_checker->get_remote_simulation();
 
   // Read the simgrid::xbt::string in the MCed process:
   simgrid::mc::ActorInformation* info     = actor_info_cast(actor);
   auto remote_string_address =
       remote(reinterpret_cast<const simgrid::xbt::string_data*>(&actor->get_host()->get_name()));
   simgrid::xbt::string_data remote_string = process->read(remote_string_address);
-  char hostname[remote_string.len];
-  process->read_bytes(hostname, remote_string.len + 1, remote(remote_string.data));
-  info->hostname = mc_model_checker->get_host_name(hostname).c_str();
+  std::vector<char> hostname(remote_string.len + 1);
+  // no need to read the terminating null byte, and thus hostname[remote_string.len] is guaranteed to be '\0'
+  process->read_bytes(hostname.data(), remote_string.len, remote(remote_string.data));
+  info->hostname = mc_model_checker->get_host_name(hostname.data()).c_str();
   return info->hostname;
 }
 
 const char* MC_smx_actor_get_name(smx_actor_t actor)
 {
-  const simgrid::mc::RemoteClient* process = &mc_model_checker->process();
   if (mc_model_checker == nullptr)
     return actor->get_cname();
 
+  const simgrid::mc::RemoteSimulation* process = &mc_model_checker->get_remote_simulation();
+
   simgrid::mc::ActorInformation* info = actor_info_cast(actor);
   if (info->name.empty()) {
     simgrid::xbt::string_data string_data = simgrid::xbt::string::to_string_data(actor->name_);
@@ -150,8 +152,8 @@ unsigned long MC_smx_get_maxpid()
 {
   unsigned long maxpid;
   const char* name = "simgrid::kernel::actor::maxpid";
-  if (mc_model_checker->process().find_variable(name) == nullptr)
+  if (mc_model_checker->get_remote_simulation().find_variable(name) == nullptr)
     name = "maxpid"; // We seem to miss the namespaces when compiling with GCC
-  mc_model_checker->process().read_variable(name, &maxpid, sizeof(maxpid));
+  mc_model_checker->get_remote_simulation().read_variable(name, &maxpid, sizeof(maxpid));
   return maxpid;
 }