Move SimcallObserver from simgrid::mc to simgrid::kernel::actor

diff --git a/MANIFEST.in b/MANIFEST.in
index 231c235..bb5203c 100644 (file)
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -2162,6 +2162,8 @@ include src/kernel/activity/SynchroRaw.cpp
 include src/kernel/activity/SynchroRaw.hpp
 include src/kernel/actor/ActorImpl.cpp
 include src/kernel/actor/ActorImpl.hpp
+include src/kernel/actor/SimcallObserver.cpp
+include src/kernel/actor/SimcallObserver.hpp
 include src/kernel/context/Context.cpp
 include src/kernel/context/Context.hpp
 include src/kernel/context/ContextBoost.cpp
@@ -2223,8 +2225,6 @@ include src/mc/checker/LivenessChecker.cpp
 include src/mc/checker/LivenessChecker.hpp
 include src/mc/checker/SafetyChecker.cpp
 include src/mc/checker/SafetyChecker.hpp
-include src/mc/checker/SimcallObserver.cpp
-include src/mc/checker/SimcallObserver.hpp
 include src/mc/checker/UdporChecker.cpp
 include src/mc/checker/UdporChecker.hpp
 include src/mc/checker/simgrid_mc.cpp

diff --git a/include/simgrid/forward.h b/include/simgrid/forward.h
index 3701f07..4e0437b 100644 (file)
--- a/include/simgrid/forward.h
+++ b/include/simgrid/forward.h
@@ -106,6 +106,8 @@ using ActorImplPtr = boost::intrusive_ptr<ActorImpl>;
 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 SimcallObserver;
 } // namespace actor
 
 namespace activity {
@@ -187,7 +189,6 @@ namespace surf {
 }
 namespace mc {
 class CommunicationDeterminismChecker;
-class SimcallObserver;
 }
 namespace vm {
 class VMModel;

diff --git a/include/simgrid/simix.hpp b/include/simgrid/simix.hpp
index 3e9f2cd..2039dbf 100644 (file)
--- a/include/simgrid/simix.hpp
+++ b/include/simgrid/simix.hpp
@@ -17,8 +17,10 @@
 #include <string>
 #include <unordered_map>
 
-XBT_PUBLIC void simcall_run_kernel(std::function<void()> const& code, simgrid::mc::SimcallObserver* observer);
-XBT_PUBLIC void simcall_run_blocking(std::function<void()> const& code, simgrid::mc::SimcallObserver* observer);
+XBT_PUBLIC void simcall_run_kernel(std::function<void()> const& code,
+                                   simgrid::kernel::actor::SimcallObserver* observer);
+XBT_PUBLIC void simcall_run_blocking(std::function<void()> const& code,
+                                     simgrid::kernel::actor::SimcallObserver* observer);
 
 namespace simgrid {
 namespace kernel {
@@ -43,7 +45,7 @@ namespace actor {
  * you may need to wait for that mutex to be unlocked by its current owner.
  * Potentially blocking simcall must be issued using simcall_blocking(), right below in this file.
  */
-template <class F> typename std::result_of_t<F()> simcall(F&& code, mc::SimcallObserver* observer = nullptr)
+template <class F> typename std::result_of_t<F()> simcall(F&& code, SimcallObserver* observer = nullptr)
 {
   // If we are in the maestro, we take the fast path and execute the
   // code directly without simcall marshalling/unmarshalling/dispatch:
@@ -75,7 +77,7 @@ template <class F> typename std::result_of_t<F()> simcall(F&& code, mc::SimcallO
  *
  * The return value is obtained from observer->get_result() if it exists. Otherwise void is returned.
  */
-template <class F> void simcall_blocking(F&& code, mc::SimcallObserver* observer = nullptr)
+template <class F> void simcall_blocking(F&& code, SimcallObserver* observer = nullptr)
 {
   xbt_assert(not SIMIX_is_maestro(), "Cannot execute blocking call in kernel mode");
 
@@ -89,7 +91,7 @@ template <class F> void simcall_blocking(F&& code, mc::SimcallObserver* observer
 template <class F, class Observer>
 auto simcall_blocking(F&& code, Observer* observer) -> decltype(observer->get_result())
 {
-  simcall_blocking(std::forward<F>(code), static_cast<mc::SimcallObserver*>(observer));
+  simcall_blocking(std::forward<F>(code), static_cast<SimcallObserver*>(observer));
   return observer->get_result();
 }
 } // namespace actor

diff --git a/src/kernel/activity/ConditionVariableImpl.cpp b/src/kernel/activity/ConditionVariableImpl.cpp
index 6f95c23..4473de6 100644 (file)
--- a/src/kernel/activity/ConditionVariableImpl.cpp
+++ b/src/kernel/activity/ConditionVariableImpl.cpp
@@ -7,7 +7,7 @@
 #include "simgrid/Exception.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
 #include "src/kernel/activity/SynchroRaw.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include <cmath> // std::isfinite
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_condition, simix_synchro, "Condition variables");
@@ -39,7 +39,7 @@ void ConditionVariableImpl::signal()
 
     /* Now transform the cond wait simcall into a mutex lock one */
     smx_simcall_t simcall = &proc.simcall_;
-    const auto* observer = dynamic_cast<mc::ConditionWaitSimcall*>(simcall->observer_);
+    const auto* observer  = dynamic_cast<kernel::actor::ConditionWaitSimcall*>(simcall->observer_);
     xbt_assert(observer != nullptr);
     observer->get_mutex()->lock(simcall->issuer_);
   }
@@ -77,7 +77,7 @@ void ConditionVariableImpl::wait(smx_mutex_t mutex, double timeout, actor::Actor
 
   RawImplPtr synchro(new RawImpl([this, issuer]() {
     this->remove_sleeping_actor(*issuer);
-    auto* observer = dynamic_cast<mc::ConditionWaitSimcall*>(issuer->simcall_.observer_);
+    auto* observer = dynamic_cast<kernel::actor::ConditionWaitSimcall*>(issuer->simcall_.observer_);
     xbt_assert(observer != nullptr);
     observer->set_result(true);
   }));

diff --git a/src/kernel/activity/ExecImpl.cpp b/src/kernel/activity/ExecImpl.cpp
index 460edbc..319d8b0 100644 (file)
--- a/src/kernel/activity/ExecImpl.cpp
+++ b/src/kernel/activity/ExecImpl.cpp
@@ -8,7 +8,7 @@
 #include "simgrid/kernel/routing/NetPoint.hpp"
 #include "simgrid/modelchecker.h"
 #include "simgrid/s4u/Exec.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/mc_replay.hpp"
 #include "src/surf/HostImpl.hpp"
 #include "src/surf/cpu_interface.hpp"
@@ -165,7 +165,8 @@ void ExecImpl::finish()
 
     if (simcall->call_ == simix::Simcall::NONE) // FIXME: maybe a better way to handle this case
       continue;                                 // if process handling comm is killed
-    if (auto* observer = dynamic_cast<mc::ExecutionWaitanySimcall*>(simcall->observer_)) { // simcall is a wait_any?
+    if (auto* observer =
+            dynamic_cast<kernel::actor::ExecutionWaitanySimcall*>(simcall->observer_)) { // simcall is a wait_any?
       const auto* execs = observer->get_execs();
 
       for (auto* exec : *execs) {

diff --git a/src/kernel/activity/SemaphoreImpl.cpp b/src/kernel/activity/SemaphoreImpl.cpp
index 5621cd1..fb13608 100644 (file)
--- a/src/kernel/activity/SemaphoreImpl.cpp
+++ b/src/kernel/activity/SemaphoreImpl.cpp
@@ -5,7 +5,7 @@
 
 #include "src/kernel/activity/SemaphoreImpl.hpp"
 #include "src/kernel/activity/SynchroRaw.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include <cmath> // std::isfinite
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_semaphore, simix_synchro, "Semaphore kernel-space implementation");
@@ -22,7 +22,7 @@ void SemaphoreImpl::acquire(actor::ActorImpl* issuer, double timeout)
   if (value_ <= 0) {
     RawImplPtr synchro(new RawImpl([this, issuer]() {
       this->remove_sleeping_actor(*issuer);
-      auto* observer = dynamic_cast<mc::SemAcquireSimcall*>(issuer->simcall_.observer_);
+      auto* observer = dynamic_cast<kernel::actor::SemAcquireSimcall*>(issuer->simcall_.observer_);
       xbt_assert(observer != nullptr);
       observer->set_result(true);
     }));

diff --git a/src/mc/checker/SimcallObserver.cpp b/src/kernel/actor/SimcallObserver.cpp
similarity index 96%
rename from src/mc/checker/SimcallObserver.cpp
rename to src/kernel/actor/SimcallObserver.cpp
index 8252905..94e8a31 100644 (file)
--- a/src/mc/checker/SimcallObserver.cpp
+++ b/src/kernel/actor/SimcallObserver.cpp
@@ -3,7 +3,7 @@
 /* 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/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
@@ -11,7 +11,8 @@
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_observer, mc, "Logging specific to MC simcall observation");
 
 namespace simgrid {
-namespace mc {
+namespace kernel {
+namespace actor {
 
 std::string SimcallObserver::to_string(int /*time_considered*/) const
 {
@@ -131,5 +132,6 @@ std::string ExecutionWaitanySimcall::dot_label() const
 {
   return SimcallObserver::dot_label() + "Execution WAITANY";
 }
-} // namespace mc
+} // namespace actor
+} // namespace kernel
 } // namespace simgrid

diff --git a/src/mc/checker/SimcallObserver.hpp b/src/kernel/actor/SimcallObserver.hpp
similarity index 97%
rename from src/mc/checker/SimcallObserver.hpp
rename to src/kernel/actor/SimcallObserver.hpp
index 3291d95..0aea316 100644 (file)
--- a/src/mc/checker/SimcallObserver.hpp
+++ b/src/kernel/actor/SimcallObserver.hpp
@@ -11,7 +11,8 @@
 #include <string>
 
 namespace simgrid {
-namespace mc {
+namespace kernel {
+namespace actor {
 
 class SimcallObserver {
   kernel::actor::ActorImpl* const issuer_;
@@ -43,7 +44,9 @@ public:
    *
    * The first time a simcall is considered, times_considered is 0, not 1.
    */
-  virtual void prepare(int times_considered) { /* Nothing to do by default */}
+  virtual void prepare(int times_considered)
+  { /* Nothing to do by default */
+  }
 
   /** Some simcalls may only be observable under some circumstances.
    * Most simcalls are not visible from the MC because they don't have an observer at all. */
@@ -162,7 +165,8 @@ public:
 
   int get_result() const { return result_; }
 };
-} // namespace mc
+} // namespace actor
+} // namespace kernel
 } // namespace simgrid
 
 #endif

diff --git a/src/mc/api.cpp b/src/mc/api.cpp
index d5ef4b6..b6a1df4 100644 (file)
--- a/src/mc/api.cpp
+++ b/src/mc/api.cpp
@@ -2,9 +2,9 @@
 
 #include "src/kernel/activity/MailboxImpl.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/Session.hpp"
 #include "src/mc/checker/Checker.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
 #include "src/mc/mc_comm_pattern.hpp"
 #include "src/mc/mc_exit.hpp"
 #include "src/mc/mc_pattern.hpp"

diff --git a/src/mc/mc_base.cpp b/src/mc/mc_base.cpp
index 1ed05dc..a2aee1d 100644 (file)
--- a/src/mc/mc_base.cpp
+++ b/src/mc/mc_base.cpp
@@ -7,7 +7,7 @@
 #include "mc/mc.h"
 #include "src/kernel/activity/CommImpl.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/mc_config.hpp"
 #include "src/mc/mc_replay.hpp"
 #include "src/simix/smx_private.hpp"
@@ -33,7 +33,7 @@ int MC_random(int min, int max)
     static simgrid::xbt::random::XbtRandom prng;
     return prng.uniform_int(min, max);
   }
-  simgrid::mc::RandomSimcall observer{SIMIX_process_self(), min, max};
+  simgrid::kernel::actor::RandomSimcall observer{SIMIX_process_self(), min, max};
   return simgrid::kernel::actor::simcall([&observer] { return observer.get_value(); }, &observer);
 }
 

diff --git a/src/mc/remote/AppSide.cpp b/src/mc/remote/AppSide.cpp
index aaad666..ad2b462 100644 (file)
--- a/src/mc/remote/AppSide.cpp
+++ b/src/mc/remote/AppSide.cpp
@@ -6,7 +6,7 @@
 #include "src/mc/remote/AppSide.hpp"
 #include "src/internal_config.h"
 #include "src/kernel/actor/ActorImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/remote/RemoteProcess.hpp"
 #include "src/xbt_modinter.h" /* mmalloc_preinit to get the default mmalloc arena address */
 #include <simgrid/modelchecker.h>

diff --git a/src/s4u/s4u_ConditionVariable.cpp b/src/s4u/s4u_ConditionVariable.cpp
index 877bfdd..7244cf8 100644 (file)
--- a/src/s4u/s4u_ConditionVariable.cpp
+++ b/src/s4u/s4u_ConditionVariable.cpp
@@ -9,7 +9,7 @@
 #include "simgrid/simix.h"
 #include "src/kernel/activity/ConditionVariableImpl.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "xbt/log.hpp"
 
 #include <exception>
@@ -31,7 +31,7 @@ ConditionVariablePtr ConditionVariable::create()
 void ConditionVariable::wait(MutexPtr lock)
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::ConditionWaitSimcall observer{issuer, pimpl_, lock->pimpl_};
+  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock->pimpl_};
   kernel::actor::simcall_blocking(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
 }
@@ -39,7 +39,7 @@ void ConditionVariable::wait(MutexPtr lock)
 void ConditionVariable::wait(const std::unique_lock<Mutex>& lock)
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_};
+  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_};
   kernel::actor::simcall_blocking(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
 }
@@ -51,7 +51,7 @@ std::cv_status s4u::ConditionVariable::wait_for(const std::unique_lock<Mutex>& l
     timeout = 0.0;
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
+  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
   bool timed_out = kernel::actor::simcall_blocking(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), observer.get_timeout(), observer.get_issuer()); },
       &observer);

diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp
index e0b9e3d..51c7408 100644 (file)
--- a/src/s4u/s4u_Exec.cpp
+++ b/src/s4u/s4u_Exec.cpp
@@ -9,7 +9,7 @@
 #include "simgrid/s4u/Exec.hpp"
 #include "src/kernel/activity/ExecImpl.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "xbt/log.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_exec, s4u_activity, "S4U asynchronous executions");
@@ -55,7 +55,7 @@ int Exec::wait_any_for(std::vector<ExecPtr>* execs, double timeout)
                  [](const ExecPtr& exec) { return static_cast<kernel::activity::ExecImpl*>(exec->pimpl_.get()); });
 
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::ExecutionWaitanySimcall observer{issuer, &rexecs, timeout};
+  kernel::actor::ExecutionWaitanySimcall observer{issuer, &rexecs, timeout};
   int changed_pos = kernel::actor::simcall_blocking(
       [&observer] {
         kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(), observer.get_timeout());

diff --git a/src/s4u/s4u_Mutex.cpp b/src/s4u/s4u_Mutex.cpp
index 184033d..832c8fb 100644 (file)
--- a/src/s4u/s4u_Mutex.cpp
+++ b/src/s4u/s4u_Mutex.cpp
@@ -7,7 +7,7 @@
 #include "simgrid/mutex.h"
 #include "simgrid/s4u/Mutex.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 
 namespace simgrid {
 namespace s4u {
@@ -16,7 +16,7 @@ namespace s4u {
 void Mutex::lock()
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::MutexLockSimcall observer{issuer, pimpl_};
+  kernel::actor::MutexLockSimcall observer{issuer, pimpl_};
   kernel::actor::simcall_blocking([&observer] { observer.get_mutex()->lock(observer.get_issuer()); }, &observer);
 }
 
@@ -27,7 +27,7 @@ void Mutex::lock()
 void Mutex::unlock()
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::MutexUnlockSimcall observer{issuer};
+  kernel::actor::MutexUnlockSimcall observer{issuer};
   kernel::actor::simcall([this, issuer] { this->pimpl_->unlock(issuer); }, &observer);
 }
 
@@ -35,7 +35,7 @@ void Mutex::unlock()
 bool Mutex::try_lock()
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::MutexLockSimcall observer{issuer, pimpl_, false};
+  kernel::actor::MutexLockSimcall observer{issuer, pimpl_, false};
   return kernel::actor::simcall([&observer] { return observer.get_mutex()->try_lock(observer.get_issuer()); },
                                 &observer);
 }

diff --git a/src/s4u/s4u_Semaphore.cpp b/src/s4u/s4u_Semaphore.cpp
index 7d42c3a..56a3bf1 100644 (file)
--- a/src/s4u/s4u_Semaphore.cpp
+++ b/src/s4u/s4u_Semaphore.cpp
@@ -9,7 +9,7 @@
 #include "simgrid/forward.h"
 #include "simgrid/s4u/Semaphore.hpp"
 #include "src/kernel/activity/SemaphoreImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 
 namespace simgrid {
 namespace s4u {
@@ -23,14 +23,14 @@ SemaphorePtr Semaphore::create(unsigned int initial_capacity)
 void Semaphore::acquire()
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::SemAcquireSimcall observer{issuer, pimpl_};
+  kernel::actor::SemAcquireSimcall observer{issuer, pimpl_};
   kernel::actor::simcall_blocking([&observer] { observer.get_sem()->acquire(observer.get_issuer(), -1.0); }, &observer);
 }
 
 bool Semaphore::acquire_timeout(double timeout)
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  mc::SemAcquireSimcall observer{issuer, pimpl_, timeout};
+  kernel::actor::SemAcquireSimcall observer{issuer, pimpl_, timeout};
   return kernel::actor::simcall_blocking(
       [&observer] { observer.get_sem()->acquire(observer.get_issuer(), observer.get_timeout()); }, &observer);
 }

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index 41bb5b9..c329085 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -18,7 +18,7 @@
 #include "src/kernel/activity/MailboxImpl.hpp"
 #include "src/kernel/activity/MutexImpl.hpp"
 #include "src/kernel/activity/SemaphoreImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/mc_replay.hpp"
 #include "src/plugins/vm/VirtualMachineImpl.hpp"
 #include "xbt/random.hpp"
@@ -62,7 +62,7 @@ unsigned int simcall_execution_waitany_for(simgrid::kernel::activity::ExecImpl*
 {
   std::vector<simgrid::kernel::activity::ExecImpl*> execsv(execs, execs + count);
   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
-  simgrid::mc::ExecutionWaitanySimcall observer{issuer, &execsv, timeout};
+  simgrid::kernel::actor::ExecutionWaitanySimcall observer{issuer, &execsv, timeout};
   return simgrid::kernel::actor::simcall_blocking(
       [&observer] {
         simgrid::kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(),
@@ -357,14 +357,14 @@ bool simcall_io_test(const simgrid::kernel::activity::ActivityImplPtr& io) // XB
   return simgrid::kernel::actor::simcall([io] { return io->test(); });
 }
 
-void simcall_run_kernel(std::function<void()> const& code, simgrid::mc::SimcallObserver* observer)
+void simcall_run_kernel(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 {
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
   simcall_BODY_run_kernel(&code);
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 }
 
-void simcall_run_blocking(std::function<void()> const& code, simgrid::mc::SimcallObserver* observer)
+void simcall_run_blocking(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 {
   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
   simcall_BODY_run_blocking(&code);

diff --git a/src/simix/popping_generated.cpp b/src/simix/popping_generated.cpp
index 5648fbe..fc87f65 100644 (file)
--- a/src/simix/popping_generated.cpp
+++ b/src/simix/popping_generated.cpp
@@ -21,7 +21,7 @@
 #include "src/mc/mc_forward.hpp"
 #endif
 #include "src/kernel/activity/ConditionVariableImpl.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_popping);
 

diff --git a/src/simix/popping_private.hpp b/src/simix/popping_private.hpp
index a0f1add..8b54a2c 100644 (file)
--- a/src/simix/popping_private.hpp
+++ b/src/simix/popping_private.hpp
@@ -47,7 +47,7 @@ struct s_smx_simcall {
   simgrid::simix::Simcall call_           = simgrid::simix::Simcall::NONE;
   smx_actor_t issuer_                     = nullptr;
   smx_timer_t timeout_cb_                 = nullptr; // Callback to timeouts
-  simgrid::mc::SimcallObserver* observer_ = nullptr; // makes that simcall observable by the MC
+  simgrid::kernel::actor::SimcallObserver* observer_ = nullptr; // makes that simcall observable by the MC
   unsigned int mc_max_consider_ = 0; // How many times this simcall should be used. If >1, this will be a fork.
   int mc_value_                           = 0;
   std::array<u_smx_scalar, 11> args_      = {};

diff --git a/src/simix/simcalls.py b/src/simix/simcalls.py
index f2696f7..9872c19 100755 (executable)
--- a/src/simix/simcalls.py
+++ b/src/simix/simcalls.py
@@ -314,7 +314,7 @@ if __name__ == '__main__':
     fd.write('#include "src/mc/mc_forward.hpp"\n')
     fd.write('#endif\n')
     fd.write('#include "src/kernel/activity/ConditionVariableImpl.hpp"\n')
-    fd.write('#include "src/mc/checker/SimcallObserver.hpp"\n')
+    fd.write('#include "src/kernel/actor/SimcallObserver.hpp"\n')
 
     fd.write('\n')
     fd.write('XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_popping);\n\n')

diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake
index 560ef21..50b965c 100644 (file)
--- a/tools/cmake/DefinePackages.cmake
+++ b/tools/cmake/DefinePackages.cmake
@@ -416,6 +416,8 @@ set(SIMIX_SRC
   src/kernel/activity/SynchroRaw.hpp
   src/kernel/actor/ActorImpl.cpp
   src/kernel/actor/ActorImpl.hpp
+  src/kernel/actor/SimcallObserver.cpp
+  src/kernel/actor/SimcallObserver.hpp
 
   ${SIMIX_GENERATED_SRC}
   )
@@ -579,8 +581,6 @@ set(MC_SRC_BASE
   src/mc/mc_config.cpp
   src/mc/mc_config.hpp
   src/mc/mc_global.cpp
-  src/mc/checker/SimcallObserver.cpp
-  src/mc/checker/SimcallObserver.hpp
   )
 
 set(MC_SRC