Rename the CondVar observer as it should

diff --git a/include/simgrid/forward.h b/include/simgrid/forward.h
index ec54ec4..3edfa80 100644 (file)
--- a/include/simgrid/forward.h
+++ b/include/simgrid/forward.h
@@ -132,6 +132,7 @@ using ActorCodeFactory = std::function<ActorCode(std::vector<std::string> args)>
 class Simcall;
 class SimcallObserver;
 class MutexObserver;
+class ConditionVariableObserver;
 class ObjectAccessSimcallObserver;
 class ObjectAccessSimcallItem;
 } // namespace actor

diff --git a/src/kernel/activity/ConditionVariableImpl.cpp b/src/kernel/activity/ConditionVariableImpl.cpp
index 59a681e..fdc23b4 100644 (file)
--- a/src/kernel/activity/ConditionVariableImpl.cpp
+++ b/src/kernel/activity/ConditionVariableImpl.cpp
@@ -35,7 +35,7 @@ void ConditionVariableImpl::signal()
 
     /* Now transform the cond wait simcall into a mutex lock one */
     actor::Simcall* simcall = &proc.simcall_;
-    const auto* observer  = dynamic_cast<kernel::actor::ConditionWaitSimcall*>(simcall->observer_);
+    const auto* observer    = dynamic_cast<kernel::actor::ConditionVariableObserver*>(simcall->observer_);
     xbt_assert(observer != nullptr);
     observer->get_mutex()->lock_async(simcall->issuer_)->wait_for(simcall->issuer_, -1);
   }
@@ -64,16 +64,18 @@ void ConditionVariableImpl::wait(MutexImpl* mutex, double timeout, actor::ActorI
 
   /* If there is a mutex unlock it */
   if (mutex != nullptr) {
-    xbt_assert(mutex->get_owner() == issuer,
-               "Actor %s cannot wait on ConditionVariable %p since it does not own the provided mutex %p",
-               issuer->get_cname(), this, mutex);
+    auto* owner = mutex->get_owner();
+    xbt_assert(owner == issuer,
+               "Actor %s cannot wait on ConditionVariable %p since it does not own the provided mutex %p (which is "
+               "owned by %s).",
+               issuer->get_cname(), this, mutex, (owner == nullptr ? "nobody" : owner->get_cname()));
     mutex_ = mutex;
     mutex->unlock(issuer);
   }
 
   SynchroImplPtr synchro(new SynchroImpl([this, issuer]() {
     this->remove_sleeping_actor(*issuer);
-    auto* observer = dynamic_cast<kernel::actor::ConditionWaitSimcall*>(issuer->simcall_.observer_);
+    auto* observer = dynamic_cast<kernel::actor::ConditionVariableObserver*>(issuer->simcall_.observer_);
     xbt_assert(observer != nullptr);
     observer->set_result(true);
   }));

diff --git a/src/kernel/activity/ConditionVariableImpl.hpp b/src/kernel/activity/ConditionVariableImpl.hpp
index 834b9e3..a142e90 100644 (file)
--- a/src/kernel/activity/ConditionVariableImpl.hpp
+++ b/src/kernel/activity/ConditionVariableImpl.hpp
@@ -7,7 +7,9 @@
 #define SIMGRID_KERNEL_ACTIVITY_CONDITIONVARIABLE_HPP
 
 #include "simgrid/s4u/ConditionVariable.hpp"
+#include "src/kernel/activity/ActivityImpl.hpp"
 #include "src/kernel/actor/ActorImpl.hpp"
+
 #include <boost/intrusive/list.hpp>
 
 namespace simgrid::kernel::activity {

diff --git a/src/kernel/actor/SynchroObserver.cpp b/src/kernel/actor/SynchroObserver.cpp
index 1dff82a..50a4ce3 100644 (file)
--- a/src/kernel/actor/SynchroObserver.cpp
+++ b/src/kernel/actor/SynchroObserver.cpp
@@ -106,7 +106,7 @@ bool BarrierObserver::is_enabled()
          (type_ == mc::Transition::Type::BARRIER_WAIT && acquisition_ != nullptr && acquisition_->granted_);
 }
 
-bool ConditionWaitSimcall::is_enabled()
+bool ConditionVariableObserver::is_enabled()
 {
   if (static bool warned = false; not warned) {
     XBT_INFO("Using condition variables in model-checked code is still experimental. Use at your own risk");
@@ -114,11 +114,11 @@ bool ConditionWaitSimcall::is_enabled()
   }
   return true;
 }
-void ConditionWaitSimcall::serialize(std::stringstream& stream) const
+void ConditionVariableObserver::serialize(std::stringstream& stream) const
 {
   THROW_UNIMPLEMENTED;
 }
-std::string ConditionWaitSimcall::to_string() const
+std::string ConditionVariableObserver::to_string() const
 {
   return "ConditionWait(cond_id:" + ptr_to_id<activity::ConditionVariableImpl const>(get_cond()) +
          " mutex_id:" + std::to_string(get_mutex()->get_id()) + ")";

diff --git a/src/kernel/actor/SynchroObserver.hpp b/src/kernel/actor/SynchroObserver.hpp
index 7c5ddc0..dc10e63 100644 (file)
--- a/src/kernel/actor/SynchroObserver.hpp
+++ b/src/kernel/actor/SynchroObserver.hpp
@@ -81,15 +81,15 @@ public:
   double get_timeout() const { return timeout_; }
 };
 
-class ConditionWaitSimcall final : public ResultingSimcall<bool> {
+class ConditionVariableObserver final : public ResultingSimcall<bool> {
   mc::Transition::Type type_;
   activity::ConditionVariableImpl* const cond_;
   activity::MutexImpl* const mutex_;
   const double timeout_;
 
 public:
-  ConditionWaitSimcall(ActorImpl* actor, activity::ConditionVariableImpl* cond, activity::MutexImpl* mutex,
-                       double timeout = -1.0)
+  ConditionVariableObserver(ActorImpl* actor, activity::ConditionVariableImpl* cond, activity::MutexImpl* mutex,
+                            double timeout = -1.0)
       : ResultingSimcall(actor, false), cond_(cond), mutex_(mutex), timeout_(timeout)
   {
   }

diff --git a/src/s4u/s4u_ConditionVariable.cpp b/src/s4u/s4u_ConditionVariable.cpp
index 5355b1a..74ae59b 100644 (file)
--- a/src/s4u/s4u_ConditionVariable.cpp
+++ b/src/s4u/s4u_ConditionVariable.cpp
@@ -28,7 +28,7 @@ ConditionVariablePtr ConditionVariable::create()
 void ConditionVariable::wait(MutexPtr lock)
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock->pimpl_};
+  kernel::actor::ConditionVariableObserver observer{issuer, pimpl_, lock->pimpl_};
   kernel::actor::simcall_blocking(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
 }
@@ -36,7 +36,7 @@ void ConditionVariable::wait(MutexPtr lock)
 void ConditionVariable::wait(const std::unique_lock<Mutex>& lock)
 {
   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
-  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_};
+  kernel::actor::ConditionVariableObserver observer{issuer, pimpl_, lock.mutex()->pimpl_};
   kernel::actor::simcall_blocking(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
 }
@@ -48,7 +48,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();
-  kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
+  kernel::actor::ConditionVariableObserver 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);