X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1d5a3d36e9868cfd03eb3d067a9047c296ce3cb5..934f086b51d328c46cb8fb20db2ad3efd4668ac9:/src/mc/remote/AppSide.cpp?ds=sidebyside

diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp
index 8d908998e1..e56a85476d 100644
--- a/src/mc/remote/AppSide.cpp
+++ b/src/mc/remote/AppSide.cpp
@@ -1,9 +1,10 @@
-/* Copyright (c) 2015-2021. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2015-2022. 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. */
 
 #include "src/mc/remote/AppSide.hpp"
+#include "simgrid/s4u/Host.hpp"
 #include "src/internal_config.h"
 #include "src/kernel/EngineImpl.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
@@ -49,7 +50,7 @@ AppSide* AppSide::initialize()
 
   // Fetch socket from MC_ENV_SOCKET_FD:
   const char* fd_env = std::getenv(MC_ENV_SOCKET_FD);
-  int fd = xbt_str_parse_int(fd_env, "Variable '" MC_ENV_SOCKET_FD "' should contain a number but contains '%s'");
+  int fd             = xbt_str_parse_int(fd_env, "Not a number in variable '" MC_ENV_SOCKET_FD "'");
   XBT_DEBUG("Model-checked application found socket FD %i", fd);
 
   // Check the socket type/validity:
@@ -74,8 +75,8 @@ AppSide* AppSide::initialize()
              strerror(errno));
 
   s_mc_message_initial_addresses_t message{MessageType::INITIAL_ADDRESSES, mmalloc_preinit(),
-                                           kernel::actor::get_maxpid_addr(), simix::simix_global_get_actors_addr(),
-                                           simix::simix_global_get_dead_actors_addr()};
+                                           kernel::actor::get_maxpid_addr(), kernel::get_actors_addr(),
+                                           kernel::get_dead_actors_addr()};
   xbt_assert(instance_->channel_.send(message) == 0, "Could not send the initial message with addresses.");
 
   instance_->handle_messages();
@@ -93,21 +94,43 @@ void AppSide::handle_deadlock_check(const s_mc_message_t*) const
   s_mc_message_int_t answer{MessageType::DEADLOCK_CHECK_REPLY, deadlock};
   xbt_assert(channel_.send(answer) == 0, "Could not send response");
 }
-void AppSide::handle_simcall_execute(const s_mc_message_simcall_handle_t* message) 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_);
   xbt_assert(actor != nullptr, "Invalid pid %ld", message->aid_);
-  if (actor->simcall_.observer_ != nullptr)
-    actor->observer_stack_.push_back(actor->simcall_.observer_->clone());
+
+  // The client may send some messages to the server while processing the transition
   actor->simcall_handle(message->times_considered_);
+  // Say the server that the transition is over and that it should proceed
   xbt_assert(channel_.send(MessageType::WAITING) == 0, "Could not send MESSAGE_WAITING to model-checker");
+
+  // Finish the RPC from the server: return a serialized observer, to build a Transition on Checker side
+  s_mc_message_simcall_execute_answer_t answer;
+  memset(&answer, 0, sizeof(answer));
+  answer.type = MessageType::SIMCALL_EXECUTE_ANSWER;
+  std::stringstream stream;
+  if (actor->simcall_.observer_ != nullptr) {
+    actor->simcall_.observer_->serialize(stream);
+  } else {
+    stream << (short)mc::Transition::Type::UNKNOWN;
+  }
+  std::string str = stream.str();
+  xbt_assert(str.size() + 1 <= answer.buffer.size(),
+             "The serialized simcall is too large for the buffer. Please fix the code.");
+  strncpy(answer.buffer.data(), str.c_str(), answer.buffer.size() - 1);
+  answer.buffer.back() = '\0';
+
+  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));
   s_mc_message_int_t answer{MessageType::ACTOR_ENABLED_REPLY, res};
-  channel_.send(answer);
+  XBT_DEBUG("Actor %ld %s enabled", msg->aid, (res ? "IS" : "is NOT"));
+  xbt_assert(channel_.send(answer) == 0, "Could not send ACTOR_ENABLED_REPLY");
 }
 
 #define assert_msg_size(_name_, _type_)                                                                                \
@@ -135,9 +158,9 @@ void AppSide::handle_messages() const
         assert_msg_size("MESSAGE_CONTINUE", s_mc_message_t);
         return;
 
-      case MessageType::SIMCALL_HANDLE:
-        assert_msg_size("SIMCALL_HANDLE", s_mc_message_simcall_handle_t);
-        handle_simcall_execute((s_mc_message_simcall_handle_t*)message_buffer.data());
+      case MessageType::SIMCALL_EXECUTE:
+        assert_msg_size("SIMCALL_EXECUTE", s_mc_message_simcall_execute_t);
+        handle_simcall_execute((s_mc_message_simcall_execute_t*)message_buffer.data());
         break;
 
       case MessageType::SIMCALL_IS_VISIBLE: {
@@ -154,36 +177,6 @@ void AppSide::handle_messages() const
         break;
       }
 
-      case MessageType::SIMCALL_TO_STRING: {
-        assert_msg_size("SIMCALL_TO_STRING", s_mc_message_simcall_to_string_t);
-        auto msg_simcall                = (s_mc_message_simcall_to_string_t*)message_buffer.data();
-        const kernel::actor::ActorImpl* actor = kernel::actor::ActorImpl::by_pid(msg_simcall->aid);
-        xbt_assert(actor != nullptr, "Invalid pid %ld", msg_simcall->aid);
-        xbt_assert(actor->simcall_.observer_, "The transition of %s has no observer", actor->get_cname());
-        std::string value = actor->simcall_.observer_->to_string(msg_simcall->time_considered);
-
-        // Send result:
-        s_mc_message_simcall_to_string_answer_t answer{MessageType::SIMCALL_TO_STRING_ANSWER, {0}};
-        value.copy(answer.value, (sizeof answer.value) - 1); // last byte was set to '\0' by initialization above
-        xbt_assert(channel_.send(answer) == 0, "Could not send response");
-        break;
-      }
-
-      case MessageType::SIMCALL_DOT_LABEL: {
-        assert_msg_size("SIMCALL_DOT_LABEL", s_mc_message_simcall_to_string_t);
-        auto msg_simcall                = (s_mc_message_simcall_to_string_t*)message_buffer.data();
-        const kernel::actor::ActorImpl* actor = kernel::actor::ActorImpl::by_pid(msg_simcall->aid);
-        xbt_assert(actor != nullptr, "Invalid pid %ld", msg_simcall->aid);
-        xbt_assert(actor->simcall_.observer_, "The transition of %s has no observer", actor->get_cname());
-        std::string value = actor->simcall_.observer_->dot_label();
-
-        // Send result:
-        s_mc_message_simcall_to_string_answer_t answer{MessageType::SIMCALL_TO_STRING_ANSWER, {0}};
-        value.copy(answer.value, (sizeof answer.value) - 1); // last byte was set to '\0' by initialization above
-        xbt_assert(channel_.send(answer) == 0, "Could not send response");
-        break;
-      }
-
       case MessageType::ACTOR_ENABLED:
         assert_msg_size("ACTOR_ENABLED", s_mc_message_actor_enabled_t);
         handle_actor_enabled((s_mc_message_actor_enabled_t*)message_buffer.data());
@@ -275,6 +268,7 @@ void AppSide::unignore_heap(void* address, std::size_t size) const
 void AppSide::declare_symbol(const char* name, int* value) const
 {
   s_mc_message_register_symbol_t message;
+  memset(&message, 0, sizeof(message));
   message.type = MessageType::REGISTER_SYMBOL;
   xbt_assert(strlen(name) + 1 <= message.name.size(), "Symbol is too long");
   strncpy(message.name.data(), name, message.name.size());