The creation of the pimpl needs no simcall

[simgrid.git] / src / mc / mc_smx.cpp

diff --git a/src/mc/mc_smx.cpp b/src/mc/mc_smx.cpp
index 8ed0249..60d5ae5 100644 (file)
--- a/src/mc/mc_smx.cpp
+++ b/src/mc/mc_smx.cpp
@@ -1,99 +1,87 @@
-/* Copyright (c) 2015. The SimGrid Team.
- * All rights reserved.                                                     */
+/* Copyright (c) 2015-2019. The SimGrid Team. All rights reserved.          */

 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 

-#include <cassert>
-#include <cstdlib>
+#include "simgrid/s4u/Host.hpp"

 
 

-#include <vector>
-
-#include <xbt/log.h>
-#include <xbt/str.h>
-#include <xbt/swag.h>
-
-#include "src/simix/smx_private.h"
-
-#include "src/mc/mc_smx.h"

 #include "src/mc/ModelChecker.hpp"
 #include "src/mc/ModelChecker.hpp"

+#include "src/mc/mc_smx.hpp"

 
 using simgrid::mc::remote;
 
 
 using simgrid::mc::remote;
 

-/** HACK, Statically "upcast" a s_smx_process_t into a SimixProcessInformation
+/** HACK, Statically "upcast" a s_smx_actor_t into a ActorInformation

  *
  *

- *  This gets 'processInfo' from '&processInfo->copy'. It upcasts in the
- *  sense that we could achieve the same thing by having SimixProcessInformation
- *  inherit from s_smx_process_t but we don't really want to do that.
+ *  This gets 'actorInfo' from '&actorInfo->copy'. It upcasts in the
+ *  sense that we could achieve the same thing by having ActorInformation
+ *  inherit from s_smx_actor_t but we don't really want to do that.

  */
  */

-static inline
-simgrid::mc::SimixProcessInformation* process_info_cast(smx_process_t p)
+static inline simgrid::mc::ActorInformation* actor_info_cast(smx_actor_t actor)

 {
 {

-  simgrid::mc::SimixProcessInformation temp;
+  simgrid::mc::ActorInformation temp;

   std::size_t offset = (char*) temp.copy.getBuffer() - (char*)&temp;
 
   std::size_t offset = (char*) temp.copy.getBuffer() - (char*)&temp;
 

-  simgrid::mc::SimixProcessInformation* process_info =
-    (simgrid::mc::SimixProcessInformation*) ((char*) p - offset);
+  simgrid::mc::ActorInformation* process_info = (simgrid::mc::ActorInformation*)((char*)actor - offset);

   return process_info;
 }
 
   return process_info;
 }
 

-/** Load the remote swag of processes into a vector
+/** Load the remote list of processes into a vector

  *
  *

- *  @param process     MCed process
- *  @param target      Local vector (to be filled with copies of `s_smx_process_t`)
- *  @param remote_swag Address of the process SWAG in the remote list
+ *  @param process      MCed process
+ *  @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_process_list(
-  simgrid::mc::Process* process,
-  std::vector<simgrid::mc::SimixProcessInformation>& target, xbt_swag_t remote_swag)
+static void MC_process_refresh_simix_actor_dynar(simgrid::mc::RemoteClient* process,
+                                                 std::vector<simgrid::mc::ActorInformation>& target,
+                                                 simgrid::mc::RemotePtr<s_xbt_dynar_t> remote_dynar)

 {
   target.clear();
 
 {
   target.clear();
 

-  // swag = REMOTE(*simix_global->process_list)
-  s_xbt_swag_t swag;
-  process->read_bytes(&swag, sizeof(swag), remote(remote_swag));
+  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));
+  process->read_bytes(data, dynar.elmsize * dynar.used, simgrid::mc::RemotePtr<void>(dynar.data));

 
   // Load each element of the vector from the MCed process:
 
   // Load each element of the vector from the MCed process:

-  int i = 0;
-  for (smx_process_t p = (smx_process_t) swag.head; p; ++i) {
+  for (unsigned int i = 0; i < dynar.used; ++i) {

 
 

-    simgrid::mc::SimixProcessInformation info;
-    info.address = p;
+    simgrid::mc::ActorInformation info;
+    info.address  = simgrid::mc::RemotePtr<simgrid::kernel::actor::ActorImpl>(data[i]);

     info.hostname = nullptr;
     info.hostname = nullptr;

-    process->read_bytes(&info.copy, sizeof(info.copy), remote(p));
+    process->read_bytes(&info.copy, sizeof(info.copy), remote(data[i]));

     target.push_back(std::move(info));
     target.push_back(std::move(info));

-
-    // Lookup next process address:
-    p = (smx_process_t) xbt_swag_getNext(&info.copy, swag.offset);

   }
   }

-  assert(i == swag.count);
+  ::operator delete(data);

 }
 }

-

 namespace simgrid {
 namespace mc {
 
 namespace simgrid {
 namespace mc {
 

-void Process::refresh_simix()
+void RemoteClient::refresh_simix()

 {
 {

-  if (this->cache_flags_ & Process::cache_simix_processes)
+  if (this->cache_flags_ & RemoteClient::cache_simix_processes)

     return;
 
   // TODO, avoid to reload `&simix_global`, `simix_global`, `*simix_global`
 
     return;
 
   // TODO, avoid to reload `&simix_global`, `simix_global`, `*simix_global`
 

-  // simix_global_p = REMOTE(simix_global);
-  smx_global_t simix_global_p;
-  this->read_variable("simix_global", &simix_global_p, sizeof(simix_global_p));
+  static_assert(std::is_same<
+      std::unique_ptr<simgrid::simix::Global>,
+      decltype(simix_global)
+    >::value, "Unexpected type for simix_global");
+  static_assert(sizeof(simix_global) == sizeof(simgrid::simix::Global*),
+    "Bad size for simix_global");
+
+  RemotePtr<simgrid::simix::Global> simix_global_p{this->read_variable<simgrid::simix::Global*>("simix_global")};

 
   // simix_global = REMOTE(*simix_global)
 
   // simix_global = REMOTE(*simix_global)

-  s_smx_global_t simix_global;
-  this->read_bytes(&simix_global, sizeof(simix_global),
-    remote(simix_global_p));
+  Remote<simgrid::simix::Global> simix_global =
+    this->read<simgrid::simix::Global>(simix_global_p);

 
 

-  MC_process_refresh_simix_process_list(
-    this, this->smx_process_infos, simix_global.process_list);
-  MC_process_refresh_simix_process_list(
-    this, this->smx_old_process_infos, simix_global.process_to_destroy);
+  MC_process_refresh_simix_actor_dynar(this, this->smx_actors_infos, remote(simix_global.getBuffer()->actors_vector));
+  MC_process_refresh_simix_actor_dynar(this, this->smx_dead_actors_infos,
+                                       remote(simix_global.getBuffer()->dead_actors_vector));

 
 

-  this->cache_flags_ |= Process::cache_simix_processes;
+  this->cache_flags_ |= RemoteClient::cache_simix_processes;

 }
 
 }
 }
 
 }


@@ -102,41 +90,41 @@ void Process::refresh_simix()
 /** Get the issuer of a simcall (`req->issuer`)
  *
  *  In split-process mode, it does the black magic necessary to get an address
 /** Get the issuer of a simcall (`req->issuer`)
  *
  *  In split-process mode, it does the black magic necessary to get an address

- *  of a (shallow) copy of the data structure the issuer SIMIX process in the local
+ *  of a (shallow) copy of the data structure the issuer SIMIX actor in the local

  *  address space.
  *
  *  @param process the MCed process
  *  @param req     the simcall (copied in the local process)
  */
  *  address space.
  *
  *  @param process the MCed process
  *  @param req     the simcall (copied in the local process)
  */

-smx_process_t MC_smx_simcall_get_issuer(s_smx_simcall_t const* req)
+smx_actor_t MC_smx_simcall_get_issuer(s_smx_simcall const* req)

 {
   xbt_assert(mc_model_checker != nullptr);
 
 {
   xbt_assert(mc_model_checker != nullptr);
 

-  // This is the address of the smx_process in the MCed process:
+  // This is the address of the smx_actor in the MCed process:

   auto address = simgrid::mc::remote(req->issuer);
 
   // Lookup by address:
   auto address = simgrid::mc::remote(req->issuer);
 
   // Lookup by address:

-  for (auto& p : mc_model_checker->process().simix_processes())
-    if (p.address == address)
-      return p.copy.getBuffer();
-  for (auto& p : mc_model_checker->process().old_simix_processes())
-    if (p.address == address)
-      return p.copy.getBuffer();
+  for (auto& actor : mc_model_checker->process().actors())
+    if (actor.address == address)
+      return actor.copy.getBuffer();
+  for (auto& actor : mc_model_checker->process().dead_actors())
+    if (actor.address == address)
+      return actor.copy.getBuffer();

 
   xbt_die("Issuer not found");
 }
 
 
   xbt_die("Issuer not found");
 }
 

-const char* MC_smx_process_get_host_name(smx_process_t p)
+const char* MC_smx_actor_get_host_name(smx_actor_t actor)

 {
   if (mc_model_checker == nullptr)
 {
   if (mc_model_checker == nullptr)

-    return sg_host_get_name(p->host);
+    return actor->get_host()->get_cname();

 
 

-  simgrid::mc::Process* process = &mc_model_checker->process();
+  simgrid::mc::RemoteClient* process = &mc_model_checker->process();

 
   /* HACK, Horrible hack to find the offset of the id in the simgrid::s4u::Host.
 
      Offsetof is not supported for non-POD types but this should
 
   /* HACK, Horrible hack to find the offset of the id in the simgrid::s4u::Host.
 
      Offsetof is not supported for non-POD types but this should

-     work in pratice for the targets currently supported by the MC
+     work in practice for the targets currently supported by the MC

      as long as we do not add funny features to the Host class
      (such as virtual base).
 
      as long as we do not add funny features to the Host class
      (such as virtual base).
 


@@ -145,39 +133,38 @@ const char* MC_smx_process_get_host_name(smx_process_t p)
   */
   union fake_host {
     simgrid::s4u::Host host;
   */
   union fake_host {
     simgrid::s4u::Host host;

-    fake_host() {}
-    ~fake_host() {}
+    fake_host() { /* Nothing to do*/}
+    ~fake_host() { /* Nothing to do*/}

   };
   fake_host foo;
   };
   fake_host foo;

-  const size_t offset = (char*) &foo.host.name() - (char*) &foo.host;
+  const size_t offset = (char*)&foo.host.get_name() - (char*)&foo.host;

 
   // Read the simgrid::xbt::string in the MCed process:
 
   // Read the simgrid::xbt::string in the MCed process:

-  simgrid::mc::SimixProcessInformation* info = process_info_cast(p);
-  auto remote_string_address = remote(
-    (simgrid::xbt::string_data*) ((char*) p->host + offset));
+  simgrid::mc::ActorInformation* info     = actor_info_cast(actor);
+  auto remote_string_address              = remote((simgrid::xbt::string_data*)((char*)actor->get_host() + offset));

   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));
   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);
+  info->hostname = mc_model_checker->get_host_name(hostname).c_str();

   return info->hostname;
 }
 
   return info->hostname;
 }
 

-const char* MC_smx_process_get_name(smx_process_t p)
+const char* MC_smx_actor_get_name(smx_actor_t actor)

 {
 {

-  simgrid::mc::Process* process = &mc_model_checker->process();
+  simgrid::mc::RemoteClient* process = &mc_model_checker->process();

   if (mc_model_checker == nullptr)
   if (mc_model_checker == nullptr)

-    return p->name.c_str();
+    return actor->get_cname();

 
 

-  simgrid::mc::SimixProcessInformation* info = process_info_cast(p);
+  simgrid::mc::ActorInformation* info = actor_info_cast(actor);

   if (info->name.empty()) {
   if (info->name.empty()) {

-    simgrid::xbt::string_data string_data = (simgrid::xbt::string_data&)p->name;
+    simgrid::xbt::string_data string_data = simgrid::xbt::string::to_string_data(actor->name_);

     info->name = process->read_string(remote(string_data.data), string_data.len);
   }
   return info->name.c_str();
 }
 
 #if HAVE_SMPI
     info->name = process->read_string(remote(string_data.data), string_data.len);
   }
   return info->name.c_str();
 }
 
 #if HAVE_SMPI

-int MC_smpi_process_count(void)
+int MC_smpi_process_count()

 {
   if (mc_model_checker == nullptr)
     return smpi_process_count();
 {
   if (mc_model_checker == nullptr)
     return smpi_process_count();


@@ -188,7 +175,7 @@ int MC_smpi_process_count(void)
 }
 #endif
 
 }
 #endif
 

-unsigned long MC_smx_get_maxpid(void)
+unsigned long MC_smx_get_maxpid()

 {
   unsigned long maxpid;
   mc_model_checker->process().read_variable("simix_process_maxpid",
 {
   unsigned long maxpid;
   mc_model_checker->process().read_variable("simix_process_maxpid",