+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::FINALIZE_REPLY) == 0, "Could not answer to FINALIZE");
+ std::fflush(stdout);
+ if (terminate_asap)
+ ::_Exit(0);
+}
+void AppSide::handle_fork(const s_mc_message_int_t* msg)
+{
+ int pid = fork();
+ xbt_assert(pid >= 0, "Could not fork application sub-process: %s.", strerror(errno));
+
+ if (pid == 0) { // Child
+ int sock = socket(AF_LOCAL, SOCK_SEQPACKET | SOCK_CLOEXEC, 0);
+
+ struct sockaddr_un addr = {};
+ addr.sun_family = AF_LOCAL;
+ snprintf(addr.sun_path, 64, "/tmp/simgrid-mc-%lu", msg->value);
+ auto addr_size = offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path);
+
+ xbt_assert(connect(sock, (struct sockaddr*)&addr, addr_size) >= 0,
+ "Cannot connect to Checker on /tmp/simgrid-mc-%lu: %s.", msg->value, strerror(errno));
+
+ channel_.reset_socket(sock);
+
+ s_mc_message_int_t answer = {};
+ answer.type = MessageType::FORK_REPLY;
+ answer.value = getpid();
+ xbt_assert(channel_.send(answer) == 0, "Could not send response to WAIT_CHILD_REPLY: %s", strerror(errno));
+ }
+}
+void AppSide::handle_wait_child(const s_mc_message_int_t* msg)
+{
+ int status;
+ errno = 0;
+ waitpid(msg->value, &status, 0);
+ xbt_assert(errno == 0, "Cannot wait on behalf of the checker: %s.", strerror(errno));
+
+ s_mc_message_int_t answer = {};
+ answer.type = MessageType::WAIT_CHILD_REPLY;
+ answer.value = status;
+ xbt_assert(channel_.send(answer) == 0, "Could not send response to WAIT_CHILD: %s", strerror(errno));
+}
+void AppSide::handle_need_meminfo()
+{
+ this->need_memory_info_ = true;
+ s_mc_message_need_meminfo_reply_t answer = {};
+ answer.type = MessageType::NEED_MEMINFO_REPLY;
+ answer.mmalloc_default_mdp = mmalloc_get_current_heap();
+ xbt_assert(channel_.send(answer) == 0, "Could not send response to the request for meminfo.");
+}
+void AppSide::handle_actors_status() const
+{
+ auto const& actor_list = kernel::EngineImpl::get_instance()->get_actor_list();
+ XBT_DEBUG("Serialize the actors to answer ACTORS_STATUS from the checker. %zu actors to go.", actor_list.size());
+
+ std::vector<s_mc_message_actors_status_one_t> status;
+ for (auto const& [aid, actor] : actor_list) {
+ s_mc_message_actors_status_one_t one = {};
+ one.type = MessageType::ACTORS_STATUS_REPLY_TRANSITION;
+ one.aid = aid;
+ one.enabled = mc::actor_is_enabled(actor);
+ one.max_considered = actor->simcall_.observer_->get_max_consider();
+ status.push_back(one);
+ }
+
+ struct s_mc_message_actors_status_answer_t answer = {};
+ answer.type = MessageType::ACTORS_STATUS_REPLY_COUNT;
+ answer.count = static_cast<int>(status.size());
+
+ xbt_assert(channel_.send(answer) == 0, "Could not send ACTORS_STATUS_REPLY msg");
+ if (answer.count > 0) {
+ size_t size = status.size() * sizeof(s_mc_message_actors_status_one_t);
+ xbt_assert(channel_.send(status.data(), size) == 0, "Could not send ACTORS_STATUS_REPLY data");
+ }
+
+ // Serialize each transition to describe what each actor is doing
+ XBT_DEBUG("Deliver ACTOR_TRANSITION_PROBE payload");
+ for (const auto& actor_status : status) {
+ if (not actor_status.enabled)
+ continue;
+
+ const auto& actor = actor_list.at(actor_status.aid);
+ const int max_considered = actor_status.max_considered;
+
+ for (int times_considered = 0; times_considered < max_considered; times_considered++) {
+ std::stringstream stream;
+ s_mc_message_simcall_probe_one_t probe;
+ probe.type = MessageType::ACTORS_STATUS_REPLY_SIMCALL;
+
+ if (actor->simcall_.observer_ != nullptr) {
+ actor->simcall_.observer_->prepare(times_considered);
+ actor->simcall_.observer_->serialize(stream);
+ } else {
+ stream << (short)mc::Transition::Type::UNKNOWN;
+ }
+
+ std::string str = stream.str();
+ xbt_assert(str.size() + 1 <= probe.buffer.size(),
+ "The serialized transition is too large for the buffer. Please fix the code.");
+ strncpy(probe.buffer.data(), str.c_str(), probe.buffer.size() - 1);
+ probe.buffer.back() = '\0';
+
+ xbt_assert(channel_.send(probe) == 0, "Could not send ACTOR_TRANSITION_PROBE payload");
+ }
+ // NOTE: We do NOT need to reset `times_considered` for each actor's
+ // simcall observer here to the "original" value (i.e. the value BEFORE
+ // multiple prepare() calls were made for serialization purposes) since
+ // each SIMCALL_EXECUTE provides a `times_considered` to be used to prepare
+ // the transition before execution.
+ }
+}
+void AppSide::handle_actors_maxpid() const