#include "simgrid/s4u/Actor.hpp"
#include "simgrid/s4u/Exec.hpp"
#include "src/kernel/activity/ExecImpl.hpp"
+#include "src/kernel/actor/ActorImpl.hpp"
+#include "src/mc/checker/SimcallObserver.hpp"
#include "xbt/log.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_exec, s4u_activity, "S4U asynchronous executions");
if (state_ == State::INITED)
vetoable_start();
- kernel::actor::ActorImpl* issuer = Actor::self()->get_impl();
+ kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
kernel::actor::simcall_blocking<void>([this, issuer, timeout] { this->get_impl()->wait_for(issuer, timeout); });
state_ = State::FINISHED;
on_completion(*this);
std::transform(begin(*execs), end(*execs), begin(rexecs),
[](const ExecPtr& exec) { return static_cast<kernel::activity::ExecImpl*>(exec->pimpl_.get()); });
- int changed_pos = simcall_execution_waitany_for(rexecs.data(), rexecs.size(), timeout);
+ kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+ mc::ExecutionWaitanySimcall observer{issuer, &rexecs, timeout};
+ kernel::actor::simcall_blocking<void>(
+ [&observer] {
+ kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(), observer.get_timeout());
+ },
+ &observer);
+ int changed_pos = observer.get_result();
if (changed_pos != -1) {
on_completion(*(execs->at(changed_pos)));
execs->at(changed_pos)->release_dependencies();
{
kernel::actor::simcall([this] { boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->cancel(); });
state_ = State::CANCELED;
+ on_completion(*this);
return this;
}
return this;
}
-///////////// SEQUENTIAL EXECUTIONS ////////
Exec* Exec::start()
{
if (is_parallel())
} // namespace s4u
} // namespace simgrid
+
/* **************************** Public C interface *************************** */
void sg_exec_set_bound(sg_exec_t exec, double bound)
{
void sg_exec_start(sg_exec_t exec)
{
- exec->start();
+ exec->vetoable_start();
}
void sg_exec_cancel(sg_exec_t exec)