SMPI_is_inited() and smpi_enabled() have the same purpose. Keep only the former.

[simgrid.git] / src / mc / remote / AppSide.cpp

diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp
index bf79dfc..2d4dfbe 100644 (file)
--- a/src/mc/remote/AppSide.cpp
+++ b/src/mc/remote/AppSide.cpp
@@ -30,12 +30,11 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_client, mc, "MC client logic");
 
-namespace simgrid {
-namespace mc {
+namespace simgrid::mc {
 
 std::unique_ptr<AppSide> AppSide::instance_;
 
-AppSide* AppSide::initialize()
+AppSide* AppSide::initialize(xbt_dynar_t actors_addr)
 {
   if (not std::getenv(MC_ENV_SOCKET_FD)) // We are not in MC mode: don't initialize the MC world
     return nullptr;
@@ -75,7 +74,7 @@ AppSide* AppSide::initialize()
              strerror(errno));
 
   s_mc_message_initial_addresses_t message{MessageType::INITIAL_ADDRESSES, mmalloc_preinit(),
-                                           kernel::actor::get_maxpid_addr(), kernel::get_actors_addr()};
+                                           kernel::actor::ActorImpl::get_maxpid_addr(), actors_addr};
   xbt_assert(instance_->channel_.send(message) == 0, "Could not send the initial message with addresses.");
 
   instance_->handle_messages();
@@ -95,7 +94,7 @@ void AppSide::handle_deadlock_check(const s_mc_message_t*) const
 }
 void AppSide::handle_simcall_execute(const s_mc_message_simcall_execute_t* message) const
 {
-  kernel::actor::ActorImpl* actor = kernel::actor::ActorImpl::by_pid(message->aid_);
+  kernel::actor::ActorImpl* actor = kernel::EngineImpl::get_instance()->get_actor_by_pid(message->aid_);
   xbt_assert(actor != nullptr, "Invalid pid %ld", message->aid_);
 
   // The client may send some messages to the server while processing the transition
@@ -121,17 +120,36 @@ void AppSide::handle_simcall_execute(const s_mc_message_simcall_execute_t* messa
 
   XBT_DEBUG("send SIMCALL_EXECUTE_ANSWER(%s) ~> '%s'", actor->get_cname(), str.c_str());
   xbt_assert(channel_.send(answer) == 0, "Could not send response");
-
 }
 
 void AppSide::handle_actor_enabled(const s_mc_message_actor_enabled_t* msg) const
 {
-  bool res = mc::actor_is_enabled(kernel::actor::ActorImpl::by_pid(msg->aid));
+  bool res = mc::actor_is_enabled(kernel::EngineImpl::get_instance()->get_actor_by_pid(msg->aid));
   s_mc_message_int_t answer{MessageType::ACTOR_ENABLED_REPLY, res};
-  XBT_DEBUG("Actor %ld %s enabled", msg->aid, (res ? "IS" : "is NOT"));
   xbt_assert(channel_.send(answer) == 0, "Could not send ACTOR_ENABLED_REPLY");
 }
 
+void AppSide::handle_finalize(const s_mc_message_int_t* msg) const
+{
+  bool terminate_asap = msg->value;
+  XBT_DEBUG("Finalize (terminate = %d)", (int)terminate_asap);
+  if (not terminate_asap) {
+    if (XBT_LOG_ISENABLED(mc_client, xbt_log_priority_debug))
+      kernel::EngineImpl::get_instance()->display_all_actor_status();
+#if HAVE_SMPI
+    XBT_DEBUG("Smpi_enabled: %d", SMPI_is_inited());
+    if (SMPI_is_inited())
+      SMPI_finalize();
+#endif
+  }
+  coverage_checkpoint();
+  xbt_assert(channel_.send(MessageType::DEADLOCK_CHECK_REPLY) == 0, // DEADLOCK_CHECK_REPLY, really?
+             "Could not answer to FINALIZE");
+  std::fflush(stdout);
+  if (terminate_asap)
+    ::_Exit(0);
+}
+
 #define assert_msg_size(_name_, _type_)                                                                                \
   xbt_assert(received_size == sizeof(_type_), "Unexpected size for " _name_ " (%zd != %zu)", received_size,            \
              sizeof(_type_))
@@ -167,27 +185,10 @@ void AppSide::handle_messages() const
         handle_actor_enabled((s_mc_message_actor_enabled_t*)message_buffer.data());
         break;
 
-      case MessageType::FINALIZE: {
+      case MessageType::FINALIZE:
         assert_msg_size("FINALIZE", s_mc_message_int_t);
-        bool terminate_asap = ((s_mc_message_int_t*)message_buffer.data())->value;
-        XBT_DEBUG("Finalize (terminate = %d)", (int)terminate_asap);
-        if (not terminate_asap) {
-          if (XBT_LOG_ISENABLED(mc_client, xbt_log_priority_debug))
-            kernel::EngineImpl::get_instance()->display_all_actor_status();
-#if HAVE_SMPI
-          XBT_DEBUG("Smpi_enabled: %d", (int)smpi_enabled());
-          if (smpi_enabled())
-            SMPI_finalize();
-#endif
-        }
-        coverage_checkpoint();
-        xbt_assert(channel_.send(MessageType::DEADLOCK_CHECK_REPLY) == 0, // DEADLOCK_CHECK_REPLY, really?
-                   "Could not answer to FINALIZE");
-        std::fflush(stdout);
-        if (terminate_asap)
-          ::_Exit(0);
+        handle_finalize((s_mc_message_int_t*)message_buffer.data());
         break;
-      }
 
       default:
         xbt_die("Received unexpected message %s (%i)", to_c_str(message->type), static_cast<int>(message->type));
@@ -198,6 +199,10 @@ void AppSide::handle_messages() const
 
 void AppSide::main_loop() const
 {
+  simgrid::mc::processes_time.resize(simgrid::kernel::actor::ActorImpl::get_maxpid());
+  MC_ignore_heap(simgrid::mc::processes_time.data(),
+                 simgrid::mc::processes_time.size() * sizeof(simgrid::mc::processes_time[0]));
+
   coverage_checkpoint();
   while (true) {
     simgrid::mc::execute_actors();
@@ -278,5 +283,4 @@ void AppSide::declare_stack(void* stack, size_t size, ucontext_t* context) const
   message.stack_region = region;
   xbt_assert(channel_.send(message) == 0, "Could not send STACK_REGION to model-checker");
 }
-} // namespace mc
-} // namespace simgrid
+} // namespace simgrid::mc