Get rid of simix::(un)marshal.
{
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) {
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_);
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) {
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_) {
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();
});
}
#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");
{
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_);
};
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,
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)
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)
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
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();
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();
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()
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