From: Arnaud Giersch <arnaud.giersch@univ-fcomte.fr>
Date: Mon, 22 Mar 2021 12:29:48 +0000 (+0100)
Subject: Handle simcall result through mc::SimcallObserver.
X-Git-Tag: v3.27~68
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/64a60fa58ca5dc30df8b2780c4901773f219d8ea

Handle simcall result through mc::SimcallObserver.

Get rid of simix::(un)marshal.
---

diff --git a/src/kernel/activity/ConditionVariableImpl.cpp b/src/kernel/activity/ConditionVariableImpl.cpp
index 418325608a..8b5d7846df 100644
--- a/src/kernel/activity/ConditionVariableImpl.cpp
+++ b/src/kernel/activity/ConditionVariableImpl.cpp
@@ -66,7 +66,6 @@ void ConditionVariableImpl::wait(smx_mutex_t mutex, double timeout, actor::Actor
 {
   XBT_DEBUG("Wait condition %p", this);
   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
-  simix::marshal<bool>(issuer->simcall_.result_, false); // default result, will be set to 'true' on timeout
 
   /* If there is a mutex unlock it */
   if (mutex != nullptr) {
@@ -79,7 +78,9 @@ void ConditionVariableImpl::wait(smx_mutex_t mutex, double timeout, actor::Actor
 
   RawImplPtr synchro(new RawImpl([this, issuer]() {
     this->remove_sleeping_actor(*issuer);
-    simix::marshal<bool>(issuer->simcall_.result_, true);
+    auto* observer = dynamic_cast<mc::ConditionWaitSimcall*>(issuer->simcall_.observer_);
+    xbt_assert(observer != nullptr);
+    observer->set_result(true);
   }));
   synchro->set_host(issuer->get_host()).set_timeout(timeout).start();
   synchro->register_simcall(&issuer->simcall_);
diff --git a/src/kernel/activity/ExecImpl.cpp b/src/kernel/activity/ExecImpl.cpp
index 2b7a046a9c..460edbc072 100644
--- a/src/kernel/activity/ExecImpl.cpp
+++ b/src/kernel/activity/ExecImpl.cpp
@@ -165,7 +165,7 @@ 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 (const auto* observer = dynamic_cast<mc::ExecutionWaitanySimcall*>(simcall->observer_)) {
+    if (auto* observer = dynamic_cast<mc::ExecutionWaitanySimcall*>(simcall->observer_)) { // simcall is a wait_any?
       const auto* execs = observer->get_execs();
 
       for (auto* exec : *execs) {
@@ -180,7 +180,7 @@ void ExecImpl::finish()
       if (not MC_is_active() && not MC_record_replay_is_active()) {
         auto element = std::find(execs->begin(), execs->end(), this);
         int rank     = element != execs->end() ? static_cast<int>(std::distance(execs->begin(), element)) : -1;
-        simix::marshal<int>(simcall->result_, rank);
+        observer->set_result(rank);
       }
     }
     switch (state_) {
@@ -251,7 +251,7 @@ void ExecImpl::wait_any_for(actor::ActorImpl* issuer, const std::vector<ExecImpl
       issuer->simcall_.timeout_cb_ = nullptr;
       for (auto* exec : *execs)
         exec->unregister_simcall(&issuer->simcall_);
-      simix::marshal<int>(issuer->simcall_.result_, -1);
+      // default result (-1) is set in mc::ExecutionWaitanySimcall
       issuer->simcall_answer();
     });
   }
diff --git a/src/kernel/activity/SemaphoreImpl.cpp b/src/kernel/activity/SemaphoreImpl.cpp
index eb3c0f81f8..5621cd1b64 100644
--- a/src/kernel/activity/SemaphoreImpl.cpp
+++ b/src/kernel/activity/SemaphoreImpl.cpp
@@ -5,6 +5,7 @@
 
 #include "src/kernel/activity/SemaphoreImpl.hpp"
 #include "src/kernel/activity/SynchroRaw.hpp"
+#include "src/mc/checker/SimcallObserver.hpp"
 #include <cmath> // std::isfinite
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_semaphore, simix_synchro, "Semaphore kernel-space implementation");
@@ -17,12 +18,13 @@ void SemaphoreImpl::acquire(actor::ActorImpl* issuer, double timeout)
 {
   XBT_DEBUG("Wait semaphore %p (timeout:%f)", this, timeout);
   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
-  simix::marshal<bool>(issuer->simcall_.result_, false); // default result, will be set to 'true' on timeout
 
   if (value_ <= 0) {
     RawImplPtr synchro(new RawImpl([this, issuer]() {
       this->remove_sleeping_actor(*issuer);
-      simix::marshal<bool>(issuer->simcall_.result_, true);
+      auto* observer = dynamic_cast<mc::SemAcquireSimcall*>(issuer->simcall_.observer_);
+      xbt_assert(observer != nullptr);
+      observer->set_result(true);
     }));
     synchro->set_host(issuer->get_host()).set_timeout(timeout).start();
     synchro->register_simcall(&issuer->simcall_);
diff --git a/src/mc/checker/SimcallObserver.hpp b/src/mc/checker/SimcallObserver.hpp
index bc1f0bfaed..8323a0fa76 100644
--- a/src/mc/checker/SimcallObserver.hpp
+++ b/src/mc/checker/SimcallObserver.hpp
@@ -90,9 +90,13 @@ public:
 };
 
 class ConditionWaitSimcall : public SimcallObserver {
+  friend kernel::activity::ConditionVariableImpl;
   kernel::activity::ConditionVariableImpl* const cond_;
   kernel::activity::MutexImpl* const mutex_;
   const double timeout_;
+  bool result_ = false; // default result for simcall, will be set to 'true' on timeout
+
+  void set_result(bool res) { result_ = res; }
 
 public:
   ConditionWaitSimcall(smx_actor_t actor, kernel::activity::ConditionVariableImpl* cond,
@@ -107,11 +111,18 @@ public:
   kernel::activity::ConditionVariableImpl* get_cond() const { return cond_; }
   kernel::activity::MutexImpl* get_mutex() const { return mutex_; }
   double get_timeout() const { return timeout_; }
+
+  bool get_result() const { return result_; }
 };
 
 class SemAcquireSimcall : public SimcallObserver {
+  friend kernel::activity::SemaphoreImpl;
+
   kernel::activity::SemaphoreImpl* const sem_;
   const double timeout_;
+  bool result_ = false; // default result for simcall, will be set to 'true' on timeout
+
+  void set_result(bool res) { result_ = res; }
 
 public:
   SemAcquireSimcall(smx_actor_t actor, kernel::activity::SemaphoreImpl* sem, double timeout = -1.0)
@@ -124,11 +135,18 @@ public:
   std::string dot_label() const override;
   kernel::activity::SemaphoreImpl* get_sem() const { return sem_; }
   double get_timeout() const { return timeout_; }
+
+  bool get_result() const { return result_; }
 };
 
 class ExecutionWaitanySimcall : public SimcallObserver {
+  friend kernel::activity::ExecImpl;
+
   const std::vector<kernel::activity::ExecImpl*>* const execs_;
   const double timeout_;
+  int result_ = -1; // default result for simcall
+
+  void set_result(int res) { result_ = res; }
 
 public:
   ExecutionWaitanySimcall(smx_actor_t actor, const std::vector<kernel::activity::ExecImpl*>* execs, double timeout)
@@ -140,6 +158,8 @@ public:
   std::string dot_label() const override;
   const std::vector<kernel::activity::ExecImpl*>* get_execs() const { return execs_; }
   double get_timeout() const { return timeout_; }
+
+  int get_result() const { return result_; }
 };
 } // namespace mc
 } // namespace simgrid
diff --git a/src/s4u/s4u_ConditionVariable.cpp b/src/s4u/s4u_ConditionVariable.cpp
index cb316eadc2..a59726f988 100644
--- a/src/s4u/s4u_ConditionVariable.cpp
+++ b/src/s4u/s4u_ConditionVariable.cpp
@@ -55,7 +55,7 @@ std::cv_status s4u::ConditionVariable::wait_for(const std::unique_lock<Mutex>& l
   kernel::actor::simcall_blocking<void>(
       [&observer] { observer.get_cond()->wait(observer.get_mutex(), observer.get_timeout(), observer.get_issuer()); },
       &observer);
-  bool timed_out = simgrid::simix::unmarshal<bool>(issuer->simcall_.result_);
+  bool timed_out = observer.get_result();
   if (timed_out) {
     // If we reached the timeout, we have to take the lock again:
     lock.mutex()->lock();
diff --git a/src/s4u/s4u_Exec.cpp b/src/s4u/s4u_Exec.cpp
index 8b94719d6d..9d1a552226 100644
--- a/src/s4u/s4u_Exec.cpp
+++ b/src/s4u/s4u_Exec.cpp
@@ -61,7 +61,7 @@ int Exec::wait_any_for(std::vector<ExecPtr>* execs, double timeout)
         kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(), observer.get_timeout());
       },
       &observer);
-  int changed_pos = simgrid::simix::unmarshal<int>(issuer->simcall_.result_);
+  int changed_pos = observer.get_result();
   if (changed_pos != -1) {
     on_completion(*(execs->at(changed_pos)));
     execs->at(changed_pos)->release_dependencies();
diff --git a/src/s4u/s4u_Semaphore.cpp b/src/s4u/s4u_Semaphore.cpp
index 0ef2dbc085..90aaedfe7f 100644
--- a/src/s4u/s4u_Semaphore.cpp
+++ b/src/s4u/s4u_Semaphore.cpp
@@ -34,7 +34,7 @@ bool Semaphore::acquire_timeout(double timeout)
   mc::SemAcquireSimcall observer{issuer, pimpl_, timeout};
   kernel::actor::simcall_blocking<void>(
       [&observer] { observer.get_sem()->acquire(observer.get_issuer(), observer.get_timeout()); }, &observer);
-  return simgrid::simix::unmarshal<bool>(issuer->simcall_.result_);
+  return observer.get_result();
 }
 
 void Semaphore::release()
diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index 31541edf04..98ec1f5116 100644
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -72,7 +72,7 @@ unsigned int simcall_execution_waitany_for(simgrid::kernel::activity::ExecImpl*
                                                           observer.get_timeout());
       },
       &observer);
-  return simgrid::simix::unmarshal<int>(issuer->simcall_.result_);
+  return observer.get_result();
 }
 
 void simcall_process_join(smx_actor_t process, double timeout) // XBT_ATTRIB_DEPRECATED_v328