X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8f73f1a6bbb4a6bcc48e8104ba5e4d40007b8be3..7b4766bf670b8042a39700c3f27e61b82db3d6cd:/src/mc/remote/AppSide.cpp

diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp
index 40fc447919..eaf261bacc 100644
--- a/src/mc/remote/AppSide.cpp
+++ b/src/mc/remote/AppSide.cpp
@@ -30,8 +30,7 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_client, mc, "MC client logic");
 
-namespace simgrid {
-namespace mc {
+namespace simgrid::mc {
 
 std::unique_ptr<AppSide> AppSide::instance_;
 
@@ -74,9 +73,8 @@ AppSide* AppSide::initialize()
   xbt_assert(errno == 0 && raise(SIGSTOP) == 0, "Could not wait for the model-checker (errno = %d: %s)", errno,
              strerror(errno));
 
-  s_mc_message_initial_addresses_t message{MessageType::INITIAL_ADDRESSES, mmalloc_preinit(),
-                                           kernel::actor::get_maxpid_addr(), kernel::get_actors_addr(),
-                                           kernel::get_dead_actors_addr()};
+  s_mc_message_initial_addresses_t message{MessageType::INITIAL_ADDRESSES, mmalloc_get_current_heap(),
+                                           kernel::actor::ActorImpl::get_maxpid_addr()};
   xbt_assert(instance_->channel_.send(message) == 0, "Could not send the initial message with addresses.");
 
   instance_->handle_messages();
@@ -96,31 +94,73 @@ 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_);
-  simgrid::kernel::actor::SimcallObserver* observer = nullptr;
-  if (actor->simcall_.observer_ != nullptr) {
-    observer = actor->simcall_.observer_->clone();
-    actor->observer_stack_.push_back(observer);
-  }
-  // Finish the RPC from the server: we need to return a pointer to the observer, saved in a stable storage
-  s_mc_message_simcall_execute_answer_t answer{MessageType::SIMCALL_EXECUTE_ANSWER, observer};
-  XBT_DEBUG("send SIMCALL_EXECUTE_ANSWER(%p)", observer);
-  xbt_assert(channel_.send(answer) == 0, "Could not send response");
 
   // 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
+void AppSide::handle_finalize(const s_mc_message_int_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};
-  XBT_DEBUG("Actor %ld %s enabled", msg->aid, (res ? "IS" : "is NOT"));
-  xbt_assert(channel_.send(answer) == 0, "Could not send ACTOR_ENABLED_REPLY");
+  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 because I'm too lazy to create another message type with no content (FIXME)
+             "Could not answer to FINALIZE");
+  std::fflush(stdout);
+  if (terminate_asap)
+    ::_Exit(0);
+}
+void AppSide::handle_actors_status() const
+{
+  auto const& actor_list = kernel::EngineImpl::get_instance()->get_actor_list();
+  int count              = actor_list.size();
+
+  struct s_mc_message_actors_status_answer_t answer {
+    MessageType::ACTORS_STATUS_REPLY, count
+  };
+  s_mc_message_actors_status_one_t status[count];
+  int i = 0;
+  for (auto const& [aid, actor] : actor_list) {
+    status[i].aid            = aid;
+    status[i].enabled        = mc::actor_is_enabled(actor);
+    status[i].max_considered = actor->simcall_.observer_->get_max_consider();
+    i++;
+  }
+  xbt_assert(channel_.send(answer) == 0, "Could not send ACTORS_STATUS_REPLY msg");
+  xbt_assert(channel_.send(status, sizeof(status)) == 0, "Could not send ACTORS_STATUS_REPLY data");
 }
 
 #define assert_msg_size(_name_, _type_)                                                                                \
@@ -153,106 +193,16 @@ void AppSide::handle_messages() const
         handle_simcall_execute((s_mc_message_simcall_execute_t*)message_buffer.data());
         break;
 
-      case MessageType::SIMCALL_IS_VISIBLE: {
-        assert_msg_size("SIMCALL_IS_VISIBLE", s_mc_message_simcall_is_visible_t);
-        auto msg_simcall                = (s_mc_message_simcall_is_visible_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());
-        bool value = actor->simcall_.observer_->is_visible();
-
-        // Send result:
-        s_mc_message_simcall_is_visible_answer_t answer{MessageType::SIMCALL_IS_VISIBLE_ANSWER, value};
-        xbt_assert(channel_.send(answer) == 0, "Could not send response");
-        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 = "";
-        if (actor->simcall_.observer_ != nullptr)
-          value = actor->simcall_.observer_->to_string(msg_simcall->time_considered);
-        else
-          value = "[(" + std::to_string(actor->get_pid()) + ")" + actor->get_host()->get_cname() + " (" +
-                  actor->get_cname() + ")] " + SIMIX_simcall_name(actor->simcall_) + "(unknown?)";
-
-        // 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);
-        std::string value = "";
-        if (actor->simcall_.observer_ != nullptr)
-          value = actor->simcall_.observer_->dot_label(msg_simcall->time_considered);
-        else
-          value = "UNIMPLEMENTED";
-
-        // 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::SIMCALLS_DEPENDENT: {
-        assert_msg_size("SIMCALLS_DEPENDENT", s_mc_message_simcalls_dependent_t);
-        auto msg_simcalls = (s_mc_message_simcalls_dependent_t*)message_buffer.data();
-        auto* obs1        = msg_simcalls->obs1;
-        auto* obs2        = msg_simcalls->obs2;
-        bool res          = true;
-
-        if (obs1 != nullptr && obs2 != nullptr) {
-          res = obs1->depends(obs2);
-
-          XBT_DEBUG("return SIMCALLS_DEPENDENT(%s, %s) = %s", obs1->to_string(0).c_str(), obs2->to_string(0).c_str(),
-                    (res ? "true" : "false"));
-        }
-
-        // Send result:
-        s_mc_message_simcalls_dependent_answer_t answer{MessageType::SIMCALLS_DEPENDENT_ANSWER, 0};
-        answer.value = res;
-        xbt_assert(channel_.send(answer) == 0, "Could not send response");
+      case MessageType::FINALIZE:
+        assert_msg_size("FINALIZE", s_mc_message_int_t);
+        handle_finalize((s_mc_message_int_t*)message_buffer.data());
         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());
+      case MessageType::ACTORS_STATUS:
+        assert_msg_size("ACTORS_STATUS", s_mc_message_t);
+        handle_actors_status();
         break;
 
-      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);
-        break;
-      }
-
       default:
         xbt_die("Received unexpected message %s (%i)", to_c_str(message->type), static_cast<int>(message->type));
         break;
@@ -262,6 +212,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,6 +232,9 @@ void AppSide::report_assertion_failure() const
 
 void AppSide::ignore_memory(void* addr, std::size_t size) const
 {
+  if (not MC_is_active())
+    return;
+
   s_mc_message_ignore_memory_t message;
   message.type = MessageType::IGNORE_MEMORY;
   message.addr = (std::uintptr_t)addr;
@@ -287,6 +244,9 @@ void AppSide::ignore_memory(void* addr, std::size_t size) const
 
 void AppSide::ignore_heap(void* address, std::size_t size) const
 {
+  if (not MC_is_active())
+    return;
+
   const s_xbt_mheap_t* heap = mmalloc_get_current_heap();
 
   s_mc_message_ignore_heap_t message;
@@ -307,6 +267,9 @@ void AppSide::ignore_heap(void* address, std::size_t size) const
 
 void AppSide::unignore_heap(void* address, std::size_t size) const
 {
+  if (not MC_is_active())
+    return;
+
   s_mc_message_ignore_memory_t message;
   message.type = MessageType::UNIGNORE_HEAP;
   message.addr = (std::uintptr_t)address;
@@ -326,8 +289,17 @@ void AppSide::declare_symbol(const char* name, int* value) const
   xbt_assert(channel_.send(message) == 0, "Could send REGISTER_SYMBOL message to model-checker");
 }
 
+/** Register a stack in the model checker
+ *
+ *  The stacks are allocated in the heap. The MC handle them specifically
+ *  when we analyze/compare the content of the heap so it must be told where
+ *  they are with this function.
+ */
 void AppSide::declare_stack(void* stack, size_t size, ucontext_t* context) const
 {
+  if (not MC_is_active())
+    return;
+
   const s_xbt_mheap_t* heap = mmalloc_get_current_heap();
 
   s_stack_region_t region;
@@ -342,5 +314,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