-/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2010-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 "smx_private.hpp"
-#include "xbt/xbt_os_thread.h"
+#include "simgrid/s4u/Host.hpp"
+#include "src/kernel/actor/ActorImpl.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
+#include "src/kernel/context/Context.hpp"
+#include "src/simix/popping_private.hpp"
+#include "xbt/log.h"
+
#if SIMGRID_HAVE_MC
-#include "src/mc/mc_private.hpp"
+#include "src/mc/mc_forward.hpp"
#endif
-#include "src/kernel/activity/CommImpl.hpp"
-#include "src/kernel/activity/ExecImpl.hpp"
-#include "src/kernel/activity/SleepImpl.hpp"
-#include "src/kernel/activity/SynchroIo.hpp"
-#include "src/kernel/activity/SynchroRaw.hpp"
+XBT_LOG_NEW_DEFAULT_CATEGORY(simix, "transmuting from user request into kernel handlers");
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_popping, simix,
- "Popping part of SIMIX (transmuting from user request into kernel handlers)");
+constexpr std::array<const char*, simgrid::simix::NUM_SIMCALLS> simcall_names{{
+ "Simcall::NONE",
+ "Simcall::RUN_KERNEL",
+ "Simcall::RUN_BLOCKING",
+}};
-void SIMIX_simcall_answer(smx_simcall_t simcall)
+/** @private
+ * @brief (in kernel mode) unpack the simcall and activate the handler
+ *
+ */
+void simgrid::kernel::actor::ActorImpl::simcall_handle(int times_considered)
{
- if (simcall->issuer != simix_global->maestro_process){
- XBT_DEBUG("Answer simcall %s (%d) issued by %s (%p)", SIMIX_simcall_name(simcall->call), (int)simcall->call,
- simcall->issuer->name.c_str(), simcall->issuer);
- simcall->issuer->simcall.call = SIMCALL_NONE;
-#if 0
- /* This check should be useless and slows everyone. Reactivate if you see something weird in process scheduling. */
- if (std::find(begin(simix_global->process_to_run), end(simix_global->process_to_run), simcall->issuer) !=
- end(simix_global->process_to_run))
- DIE_IMPOSSIBLE;
-#endif
- simix_global->process_to_run.push_back(simcall->issuer);
- }
-}
+ XBT_DEBUG("Handling simcall %p: %s", &simcall_, SIMIX_simcall_name(simcall_));
+ if (simcall_.observer_ != nullptr)
+ simcall_.observer_->prepare(times_considered);
+ if (context_->wannadie())
+ return;
+ switch (simcall_.call_) {
+ case simgrid::simix::Simcall::RUN_KERNEL:
+ (*simcall_.code_)();
+ simcall_answer();
+ break;
-void SIMIX_simcall_exit(smx_activity_t synchro)
-{
- synchro->post();
-}
+ case simgrid::simix::Simcall::RUN_BLOCKING:
+ (*simcall_.code_)();
+ break;
-void SIMIX_run_kernel(std::function<void()> const* code)
-{
- (*code)();
+ case simgrid::simix::Simcall::NONE:
+ throw std::invalid_argument(
+ simgrid::xbt::string_printf("Asked to do the noop syscall on %s@%s", get_cname(), get_host()->get_cname()));
+ default:
+ THROW_IMPOSSIBLE;
+ }
}
-/** Kernel code for run_blocking
- *
- * The implementtion looks a lot like SIMIX_run_kernel ^^
- *
- * However, this `run_blocking` is blocking so the process will not be woken
- * up until `SIMIX_simcall_answer(simcall)`` is called by the kernel.
- * This means that `code` is responsible for doing this.
- */
-void SIMIX_run_blocking(std::function<void()> const* code)
+/** @brief returns a printable string representing a simcall */
+const char* SIMIX_simcall_name(const s_smx_simcall& simcall)
{
- (*code)();
+ if (simcall.observer_ != nullptr) {
+#if SIMGRID_HAVE_MC
+ if (mc_model_checker != nullptr) // Do not try to use the observer from the MCer
+ return "(remotely observed)";
+#endif
+
+ static std::string name;
+ name = boost::core::demangle(typeid(*simcall.observer_).name());
+ const char* cname = name.c_str();
+ if (name.rfind("simgrid::kernel::", 0) == 0)
+ cname += 17; // strip prefix "simgrid::kernel::"
+ return cname;
+ } else {
+ return simcall_names.at(static_cast<int>(simcall.call_));
+ }
}
