Move Simcall from namespace simix to kernel::actor.

diff --git a/MANIFEST.in b/MANIFEST.in
index 3825de6..b600a3a 100644 (file)
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -2130,6 +2130,8 @@ include src/kernel/actor/ActorImpl.cpp
 include src/kernel/actor/ActorImpl.hpp
 include src/kernel/actor/CommObserver.cpp
 include src/kernel/actor/CommObserver.hpp
+include src/kernel/actor/Simcall.cpp
+include src/kernel/actor/Simcall.hpp
 include src/kernel/actor/SimcallObserver.cpp
 include src/kernel/actor/SimcallObserver.hpp
 include src/kernel/actor/SynchroObserver.cpp
@@ -2335,8 +2337,6 @@ include src/simgrid/sg_config.cpp
 include src/simgrid/sg_version.cpp
 include src/simgrid/util.hpp
 include src/simix/libsmx.cpp
-include src/simix/simcall.cpp
-include src/simix/simcall.hpp
 include src/simix/smx_context.cpp
 include src/smpi/bindings/smpi_f77.cpp
 include src/smpi/bindings/smpi_f77_coll.cpp

diff --git a/include/simgrid/forward.h b/include/simgrid/forward.h
index 7bfb4f4..c97b3cf 100644 (file)
--- a/include/simgrid/forward.h
+++ b/include/simgrid/forward.h
@@ -115,6 +115,7 @@ using ActorCode = std::function<void()>;
 // Create an ActorCode from the parameters parsed in the XML file (or elsewhere)
 using ActorCodeFactory = std::function<ActorCode(std::vector<std::string> args)>;
 
+class Simcall;
 class SimcallObserver;
 } // namespace actor
 
@@ -205,9 +206,6 @@ class FutureEvtSet;
 class Profile;
 } // namespace profile
 } // namespace kernel
-namespace simix {
-class Simcall;
-}
 namespace mc {
 class State;
 }

diff --git a/src/kernel/EngineImpl.cpp b/src/kernel/EngineImpl.cpp
index 3ef95ec..9af27b7 100644 (file)
--- a/src/kernel/EngineImpl.cpp
+++ b/src/kernel/EngineImpl.cpp
@@ -744,7 +744,7 @@ void EngineImpl::run(double max_date)
        */
 
       for (auto const& actor : actors_that_ran_) {
-        if (actor->simcall_.call_ != simix::Simcall::Type::NONE) {
+        if (actor->simcall_.call_ != actor::Simcall::Type::NONE) {
           actor->simcall_handle(0);
         }
       }

diff --git a/src/kernel/activity/ActivityImpl.cpp b/src/kernel/activity/ActivityImpl.cpp
index 19e9ea8..dbf06bc 100644 (file)
--- a/src/kernel/activity/ActivityImpl.cpp
+++ b/src/kernel/activity/ActivityImpl.cpp
@@ -29,13 +29,13 @@ ActivityImpl::~ActivityImpl()
   XBT_DEBUG("Destroy activity %p", this);
 }
 
-void ActivityImpl::register_simcall(simix::Simcall* simcall)
+void ActivityImpl::register_simcall(actor::Simcall* simcall)
 {
   simcalls_.push_back(simcall);
   simcall->issuer_->waiting_synchro_ = this;
 }
 
-void ActivityImpl::unregister_simcall(simix::Simcall* simcall)
+void ActivityImpl::unregister_simcall(actor::Simcall* simcall)
 {
   // Remove the first occurrence of simcall:
   auto j = boost::range::find(simcalls_, simcall);
@@ -200,7 +200,7 @@ void ActivityImpl::cancel()
   state_ = State::CANCELED;
 }
 
-void ActivityImpl::handle_activity_waitany(simix::Simcall* simcall)
+void ActivityImpl::handle_activity_waitany(actor::Simcall* simcall)
 {
   /* If a waitany simcall is waiting for this synchro to finish, then remove it from the other synchros in the waitany
    * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the

diff --git a/src/kernel/activity/ActivityImpl.hpp b/src/kernel/activity/ActivityImpl.hpp
index 58b5e10..5edb48e 100644 (file)
--- a/src/kernel/activity/ActivityImpl.hpp
+++ b/src/kernel/activity/ActivityImpl.hpp
@@ -34,7 +34,7 @@ class XBT_PUBLIC ActivityImpl {
 public:
   virtual ~ActivityImpl();
   ActivityImpl() = default;
-  std::list<simix::Simcall*> simcalls_; /* List of simcalls waiting for this activity */
+  std::list<actor::Simcall*> simcalls_; /* List of simcalls waiting for this activity */
   s4u::Activity* piface_         = nullptr;
   resource::Action* surf_action_ = nullptr;
 
@@ -82,9 +82,9 @@ public:
   virtual void finish() = 0; // Unlock all simcalls blocked on that activity, either because it was marked as done by
                              // the model or because it terminated without waiting for the model
 
-  void register_simcall(simix::Simcall* simcall);
-  void unregister_simcall(simix::Simcall* simcall);
-  void handle_activity_waitany(simix::Simcall* simcall);
+  void register_simcall(actor::Simcall* simcall);
+  void unregister_simcall(actor::Simcall* simcall);
+  void handle_activity_waitany(actor::Simcall* simcall);
   void clean_action();
   virtual double get_remaining() const;
   // Support for the boost::intrusive_ptr<ActivityImpl> datatype

diff --git a/src/kernel/activity/BarrierImpl.cpp b/src/kernel/activity/BarrierImpl.cpp
index 529906f..98ccd34 100644 (file)
--- a/src/kernel/activity/BarrierImpl.cpp
+++ b/src/kernel/activity/BarrierImpl.cpp
@@ -33,7 +33,7 @@ void BarrierAcquisitionImpl::wait_for(actor::ActorImpl* issuer, double timeout)
 void BarrierAcquisitionImpl::finish()
 {
   xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size());
-  simix::Simcall* simcall = simcalls_.front();
+  actor::Simcall* simcall = simcalls_.front();
   simcalls_.pop_front();
 
   simcall->issuer_->waiting_synchro_ = nullptr;

diff --git a/src/kernel/activity/CommImpl.cpp b/src/kernel/activity/CommImpl.cpp
index b1e09ce..08f4c31 100644 (file)
--- a/src/kernel/activity/CommImpl.cpp
+++ b/src/kernel/activity/CommImpl.cpp
@@ -539,14 +539,14 @@ void CommImpl::finish()
     copy_data();
 
   while (not simcalls_.empty()) {
-    simix::Simcall* simcall = simcalls_.front();
+    actor::Simcall* simcall = simcalls_.front();
     simcalls_.pop_front();
 
     /* If a waitany simcall is waiting for this synchro to finish, then remove it from the other synchros in the waitany
      * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the
      * simcall */
 
-    if (simcall->call_ == simix::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
+    if (simcall->call_ == actor::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
       continue;                                       // if actor handling comm is killed
 
     handle_activity_waitany(simcall);

diff --git a/src/kernel/activity/ConditionVariableImpl.cpp b/src/kernel/activity/ConditionVariableImpl.cpp
index 8dad63f..e77a86b 100644 (file)
--- a/src/kernel/activity/ConditionVariableImpl.cpp
+++ b/src/kernel/activity/ConditionVariableImpl.cpp
@@ -36,7 +36,7 @@ void ConditionVariableImpl::signal()
     proc.waiting_synchro_ = nullptr;
 
     /* Now transform the cond wait simcall into a mutex lock one */
-    simix::Simcall* simcall = &proc.simcall_;
+    actor::Simcall* simcall = &proc.simcall_;
     const auto* observer  = dynamic_cast<kernel::actor::ConditionWaitSimcall*>(simcall->observer_);
     xbt_assert(observer != nullptr);
     observer->get_mutex()->lock_async(simcall->issuer_)->wait_for(simcall->issuer_, -1);

diff --git a/src/kernel/activity/ExecImpl.cpp b/src/kernel/activity/ExecImpl.cpp
index 66c86ba..360ec95 100644 (file)
--- a/src/kernel/activity/ExecImpl.cpp
+++ b/src/kernel/activity/ExecImpl.cpp
@@ -204,10 +204,10 @@ void ExecImpl::finish()
 {
   XBT_DEBUG("ExecImpl::finish() in state %s", get_state_str());
   while (not simcalls_.empty()) {
-    simix::Simcall* simcall = simcalls_.front();
+    actor::Simcall* simcall = simcalls_.front();
     simcalls_.pop_front();
 
-    if (simcall->call_ == simix::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
+    if (simcall->call_ == actor::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
       continue;                                       // if process handling comm is killed
 
     handle_activity_waitany(simcall);

diff --git a/src/kernel/activity/IoImpl.cpp b/src/kernel/activity/IoImpl.cpp
index d910ac9..07dff0f 100644 (file)
--- a/src/kernel/activity/IoImpl.cpp
+++ b/src/kernel/activity/IoImpl.cpp
@@ -138,14 +138,14 @@ void IoImpl::finish()
 {
   XBT_DEBUG("IoImpl::finish() in state %s", get_state_str());
   while (not simcalls_.empty()) {
-    simix::Simcall* simcall = simcalls_.front();
+    actor::Simcall* simcall = simcalls_.front();
     simcalls_.pop_front();
 
     /* If a waitany simcall is waiting for this synchro to finish, then remove it from the other synchros in the waitany
      * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the
      * simcall */
 
-    if (simcall->call_ == simix::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
+    if (simcall->call_ == actor::Simcall::Type::NONE) // FIXME: maybe a better way to handle this case
       continue;                                       // if process handling comm is killed
 
     handle_activity_waitany(simcall);

diff --git a/src/kernel/activity/MutexImpl.cpp b/src/kernel/activity/MutexImpl.cpp
index 45d0889..ca13b38 100644 (file)
--- a/src/kernel/activity/MutexImpl.cpp
+++ b/src/kernel/activity/MutexImpl.cpp
@@ -35,7 +35,7 @@ void MutexAcquisitionImpl::wait_for(actor::ActorImpl* issuer, double timeout)
 void MutexAcquisitionImpl::finish()
 {
   xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size());
-  simix::Simcall* simcall = simcalls_.front();
+  actor::Simcall* simcall = simcalls_.front();
   simcalls_.pop_front();
 
   simcall->issuer_->waiting_synchro_ = nullptr;

diff --git a/src/kernel/activity/SemaphoreImpl.cpp b/src/kernel/activity/SemaphoreImpl.cpp
index 88b799d..914ef4c 100644 (file)
--- a/src/kernel/activity/SemaphoreImpl.cpp
+++ b/src/kernel/activity/SemaphoreImpl.cpp
@@ -47,7 +47,7 @@ void SemAcquisitionImpl::post()
 void SemAcquisitionImpl::finish()
 {
   xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size());
-  simix::Simcall* simcall = simcalls_.front();
+  actor::Simcall* simcall = simcalls_.front();
   simcalls_.pop_front();
 
   if (surf_action_ != nullptr) { // A timeout was declared

diff --git a/src/kernel/activity/SleepImpl.cpp b/src/kernel/activity/SleepImpl.cpp
index f0f1190..78813f7 100644 (file)
--- a/src/kernel/activity/SleepImpl.cpp
+++ b/src/kernel/activity/SleepImpl.cpp
@@ -58,7 +58,7 @@ void SleepImpl::finish()
 {
   XBT_DEBUG("SleepImpl::finish() in state %s", get_state_str());
   while (not simcalls_.empty()) {
-    const simix::Simcall* simcall = simcalls_.front();
+    const actor::Simcall* simcall = simcalls_.front();
     simcalls_.pop_front();
 
     simcall->issuer_->waiting_synchro_ = nullptr;

diff --git a/src/kernel/activity/Synchro.cpp b/src/kernel/activity/Synchro.cpp
index 27dea4b..c9f5802 100644 (file)
--- a/src/kernel/activity/Synchro.cpp
+++ b/src/kernel/activity/Synchro.cpp
@@ -78,7 +78,7 @@ void SynchroImpl::finish()
 {
   XBT_DEBUG("SynchroImpl::finish() in state %s", get_state_str());
   xbt_assert(simcalls_.size() == 1, "Unexpected number of simcalls waiting: %zu", simcalls_.size());
-  simix::Simcall* simcall = simcalls_.front();
+  actor::Simcall* simcall = simcalls_.front();
   simcalls_.pop_front();
 
   set_exception(simcall->issuer_);

diff --git a/src/kernel/actor/ActorImpl.cpp b/src/kernel/actor/ActorImpl.cpp
index 862475e..213a54d 100644 (file)
--- a/src/kernel/actor/ActorImpl.cpp
+++ b/src/kernel/actor/ActorImpl.cpp
@@ -421,8 +421,8 @@ void ActorImpl::simcall_answer()
   auto* engine = EngineImpl::get_instance();
   if (not this->is_maestro()) {
     XBT_DEBUG("Answer simcall %s issued by %s (%p)", simcall_.get_cname(), get_cname(), this);
-    xbt_assert(simcall_.call_ != simix::Simcall::Type::NONE);
-    simcall_.call_            = simix::Simcall::Type::NONE;
+    xbt_assert(simcall_.call_ != Simcall::Type::NONE);
+    simcall_.call_            = Simcall::Type::NONE;
     const auto& actors_to_run = engine->get_actors_to_run();
     xbt_assert(not XBT_LOG_ISENABLED(ker_actor, xbt_log_priority_debug) ||
                    std::find(begin(actors_to_run), end(actors_to_run), this) == end(actors_to_run),

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index a8f893e..d0a522a 100644 (file)
--- a/src/kernel/actor/ActorImpl.hpp
+++ b/src/kernel/actor/ActorImpl.hpp
@@ -6,9 +6,9 @@
 #ifndef SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
 #define SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
 
+#include "Simcall.hpp"
 #include "simgrid/kernel/Timer.hpp"
 #include "simgrid/s4u/Actor.hpp"
-#include "src/simix/simcall.hpp"
 #include "xbt/PropertyHolder.hpp"
 #include <boost/intrusive/list.hpp>
 #include <functional>
@@ -73,7 +73,7 @@ public:
 
   activity::ActivityImplPtr waiting_synchro_ = nullptr; /* the current blocking synchro if any */
   std::list<activity::ActivityImplPtr> activities_;     /* the current non-blocking synchros */
-  simix::Simcall simcall_;
+  Simcall simcall_;
   /* list of functions executed when the actor dies */
   std::shared_ptr<std::vector<std::function<void(bool)>>> on_exit =
       std::make_shared<std::vector<std::function<void(bool)>>>();

diff --git a/src/simix/simcall.cpp b/src/kernel/actor/Simcall.cpp
similarity index 68%
rename from src/simix/simcall.cpp
rename to src/kernel/actor/Simcall.cpp
index dfa5dd9..4fa6c44 100644 (file)
--- a/src/simix/simcall.cpp
+++ b/src/kernel/actor/Simcall.cpp
@@ -3,20 +3,24 @@
 /* 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/simix/simcall.hpp"
+#include "Simcall.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
 #include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/kernel/context/Context.hpp"
 #include "xbt/log.h"
 
-XBT_LOG_NEW_DEFAULT_CATEGORY(simix, "transmuting from user request into kernel handlers");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_simcall, kernel, "transmuting from user request into kernel handlers");
+
+namespace simgrid {
+namespace kernel {
+namespace actor {
 
 /** @private
  * @brief (in kernel mode) unpack the simcall and activate the handler
  *
  */
-void simgrid::kernel::actor::ActorImpl::simcall_handle(int times_considered)
+void ActorImpl::simcall_handle(int times_considered)
 {
   XBT_DEBUG("Handling simcall %p: %s", &simcall_, simcall_.get_cname());
   if (simcall_.observer_ != nullptr)
@@ -24,16 +28,16 @@ void simgrid::kernel::actor::ActorImpl::simcall_handle(int times_considered)
   if (context_->wannadie())
     return;
 
-  xbt_assert(simcall_.call_ != simgrid::simix::Simcall::Type::NONE, "Asked to do the noop syscall on %s@%s",
-             get_cname(), get_host()->get_cname());
+  xbt_assert(simcall_.call_ != Simcall::Type::NONE, "Asked to do the noop syscall on %s@%s", get_cname(),
+             get_host()->get_cname());
 
   (*simcall_.code_)();
-  if (simcall_.call_ == simgrid::simix::Simcall::Type::RUN_ANSWERED)
+  if (simcall_.call_ == Simcall::Type::RUN_ANSWERED)
     simcall_answer();
 }
 
 /** @brief returns a printable string representing a simcall */
-const char* simgrid::simix::Simcall::get_cname() const
+const char* Simcall::get_cname() const
 {
   if (observer_ != nullptr) {
     static std::string name;
@@ -46,3 +50,7 @@ const char* simgrid::simix::Simcall::get_cname() const
     return to_c_str(call_);
   }
 }
+
+} // namespace actor
+} // namespace kernel
+} // namespace simgrid

diff --git a/src/simix/simcall.hpp b/src/kernel/actor/Simcall.hpp
similarity index 93%
rename from src/simix/simcall.hpp
rename to src/kernel/actor/Simcall.hpp
index 99bf55a..2d561cb 100644 (file)
--- a/src/simix/simcall.hpp
+++ b/src/kernel/actor/Simcall.hpp
@@ -12,7 +12,8 @@
 
 /********************************* Simcalls *********************************/
 namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace actor {
 
 /**
  * @brief Represents a simcall to the kernel.
@@ -33,7 +34,8 @@ public:
   const char* get_cname() const;
 };
 
-} // namespace simix
+} // namespace actor
+} // namespace kernel
 } // namespace simgrid
 
 #endif

diff --git a/src/mc/api.cpp b/src/mc/api.cpp
index 71969e1..96d76b6 100644 (file)
--- a/src/mc/api.cpp
+++ b/src/mc/api.cpp
@@ -28,8 +28,6 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(Api, mc, "Logging specific to MC Facade APIs ");
 XBT_LOG_EXTERNAL_CATEGORY(mc_global);
 
-using Simcall = simgrid::simix::Simcall;
-
 namespace simgrid {
 namespace mc {
 

diff --git a/src/mc/mc_base.cpp b/src/mc/mc_base.cpp
index 5f73da1..3711f92 100644 (file)
--- a/src/mc/mc_base.cpp
+++ b/src/mc/mc_base.cpp
@@ -49,8 +49,8 @@ void execute_actors()
   while (engine->has_actors_to_run()) {
     engine->run_all_actors();
     for (auto const& actor : engine->get_actors_that_ran()) {
-      const simix::Simcall* req = &actor->simcall_;
-      if (req->call_ != simix::Simcall::Type::NONE && not simgrid::mc::request_is_visible(req))
+      const kernel::actor::Simcall* req = &actor->simcall_;
+      if (req->call_ != kernel::actor::Simcall::Type::NONE && not simgrid::mc::request_is_visible(req))
         actor->simcall_handle(0);
     }
   }
@@ -85,12 +85,12 @@ bool actor_is_enabled(smx_actor_t actor)
 #endif
 
   // Now, we are in the client app, no need for remote memory reading.
-  simix::Simcall* req = &actor->simcall_;
+  kernel::actor::Simcall* req = &actor->simcall_;
 
   if (req->observer_ != nullptr)
     return req->observer_->is_enabled();
 
-  if (req->call_ == simix::Simcall::Type::NONE)
+  if (req->call_ == kernel::actor::Simcall::Type::NONE)
     return false;
   else
     /* The rest of the requests are always enabled */
@@ -100,7 +100,7 @@ bool actor_is_enabled(smx_actor_t actor)
 /* This is the list of requests that are visible from the checker algorithm.
  * Any other requests are handled right away on the application side.
  */
-bool request_is_visible(const simix::Simcall* req)
+bool request_is_visible(const kernel::actor::Simcall* req)
 {
 #if SIMGRID_HAVE_MC
   xbt_assert(mc_model_checker == nullptr, "This should be called from the client side");

diff --git a/src/mc/mc_base.hpp b/src/mc/mc_base.hpp
index e20148d..69fc226 100644 (file)
--- a/src/mc/mc_base.hpp
+++ b/src/mc/mc_base.hpp
@@ -23,7 +23,7 @@ XBT_PRIVATE void execute_actors();
 XBT_PRIVATE extern std::vector<double> processes_time;
 
 /** Execute a given simcall */
-XBT_PRIVATE void handle_simcall(simix::Simcall* req, int req_num);
+XBT_PRIVATE void handle_simcall(kernel::actor::Simcall* req, int req_num);
 
 /** Is the process ready to execute its simcall?
  *
@@ -37,7 +37,7 @@ XBT_PRIVATE void handle_simcall(simix::Simcall* req, int req_num);
 XBT_PRIVATE bool actor_is_enabled(smx_actor_t process);
 
 /** Check if the given simcall is visible */
-XBT_PRIVATE bool request_is_visible(const simix::Simcall* req);
+XBT_PRIVATE bool request_is_visible(const kernel::actor::Simcall* req);
 } // namespace mc
 } // namespace simgrid
 

diff --git a/src/mc/mc_record.cpp b/src/mc/mc_record.cpp
index f5237d1..6e566b3 100644 (file)
--- a/src/mc/mc_record.cpp
+++ b/src/mc/mc_record.cpp
@@ -31,8 +31,8 @@ void RecordTrace::replay() const
     // Choose a request:
     kernel::actor::ActorImpl* actor = kernel::actor::ActorImpl::by_pid(transition->aid_);
     xbt_assert(actor != nullptr, "Unexpected actor (id:%ld).", transition->aid_);
-    const simix::Simcall* simcall = &(actor->simcall_);
-    xbt_assert(simcall->call_ != simix::Simcall::Type::NONE, "No simcall for process %ld.", transition->aid_);
+    const kernel::actor::Simcall* simcall = &(actor->simcall_);
+    xbt_assert(simcall->call_ != kernel::actor::Simcall::Type::NONE, "No simcall for process %ld.", transition->aid_);
     xbt_assert(simgrid::mc::request_is_visible(simcall) && simgrid::mc::actor_is_enabled(actor), "Unexpected simcall.");
 
     // Execute the request:

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index ee39fa5..402d188 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -18,7 +18,7 @@
 #define SIMIX_H_NO_DEPRECATED_WARNING // avoid deprecation warning on include (remove with XBT_ATTRIB_DEPRECATED_v335)
 #include <simgrid/simix.h>
 
-XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix);
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(ker_simcall);
 
 /**
  * @ingroup simix_comm_management
@@ -156,7 +156,7 @@ bool simcall_comm_test(simgrid::kernel::activity::ActivityImpl* comm) // XBT_ATT
   return false;
 }
 
-static void simcall(simgrid::simix::Simcall::Type call, std::function<void()> const& code)
+static void simcall(simgrid::kernel::actor::Simcall::Type call, std::function<void()> const& code)
 {
   auto self = simgrid::kernel::actor::ActorImpl::self();
   self->simcall_.call_ = call;
@@ -174,7 +174,7 @@ void simcall_run_answered(std::function<void()> const& code, simgrid::kernel::ac
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
   // The function `code` is called in kernel mode (either because we are already in maestor or after a context switch)
   // and simcall_answer() is called
-  simcall(simgrid::simix::Simcall::Type::RUN_ANSWERED, code);
+  simcall(simgrid::kernel::actor::Simcall::Type::RUN_ANSWERED, code);
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 }
 
@@ -183,6 +183,6 @@ void simcall_run_blocking(std::function<void()> const& code, simgrid::kernel::ac
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
   // The function `code` is called in kernel mode (either because we are already in maestor or after a context switch)
   // BUT simcall_answer IS NOT CALLED
-  simcall(simgrid::simix::Simcall::Type::RUN_BLOCKING, code);
+  simcall(simgrid::kernel::actor::Simcall::Type::RUN_BLOCKING, code);
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 }

diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake
index d53b27b..d5f6a10 100644 (file)
--- a/tools/cmake/DefinePackages.cmake
+++ b/tools/cmake/DefinePackages.cmake
@@ -12,6 +12,7 @@ set(EXTRA_DIST
   src/include/xbt/xbt_modinter.h
   src/include/catch.hpp
   src/include/xxhash.hpp
+  src/kernel/actor/Simcall.hpp
   src/kernel/resource/LinkImpl.hpp
   src/kernel/resource/SplitDuplexLinkImpl.hpp
   src/kernel/resource/StandardLinkImpl.hpp
@@ -22,7 +23,6 @@ set(EXTRA_DIST
   src/dag/dax.dtd
   src/dag/dax_dtd.c
   src/dag/dax_dtd.h
-  src/simix/simcall.hpp
   src/smpi/colls/coll_tuned_topo.hpp
   src/smpi/colls/colls_private.hpp
   src/smpi/colls/smpi_mvapich2_selector_stampede.hpp
@@ -409,12 +409,12 @@ set(SIMIX_SRC
   src/kernel/actor/ActorImpl.hpp
   src/kernel/actor/CommObserver.cpp
   src/kernel/actor/CommObserver.hpp
+  src/kernel/actor/Simcall.cpp
   src/kernel/actor/SimcallObserver.cpp
   src/kernel/actor/SimcallObserver.hpp
   src/kernel/actor/SynchroObserver.cpp
   src/kernel/actor/SynchroObserver.hpp
   src/simix/libsmx.cpp
-  src/simix/simcall.cpp
   src/simix/smx_context.cpp
   )
 

diff --git a/tools/cmake/Flags.cmake b/tools/cmake/Flags.cmake
index cc89ebc..7e98b43 100644 (file)
--- a/tools/cmake/Flags.cmake
+++ b/tools/cmake/Flags.cmake
@@ -181,7 +181,7 @@ if(enable_model-checking AND enable_compile_optimizations)
   list(REMOVE_ITEM src_list ${SIMIX_SRC} ${S4U_SRC})
   # but...
   list(APPEND src_list
-    src/simix/simcall.cpp)
+    src/kernel/actor/Simcall.cpp)
   foreach(src ${src_list})
       set (mcCFLAGS "-O3 -funroll-loops -fno-strict-aliasing")
       if(CMAKE_COMPILER_IS_GNUCC)