-/* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2020. The SimGrid Team. All rights reserved. */
/* 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. */
pimpl_ = kernel::activity::ExecImplPtr(new kernel::activity::ExecImpl());
}
-bool Exec::test()
+Exec* Exec::wait()
{
- xbt_assert(state_ == State::INITED || state_ == State::STARTED || state_ == State::FINISHED);
-
- if (state_ == State::FINISHED)
- return true;
-
- if (state_ == State::INITED)
- this->start();
-
- if (simcall_execution_test(pimpl_)) {
- state_ = State::FINISHED;
- return true;
- }
-
- return false;
+ return this->wait_for(-1);
}
-Exec* Exec::wait()
+Exec* Exec::wait_for(double timeout)
{
if (state_ == State::INITED)
- start();
- simcall_execution_wait(pimpl_);
+ vetoable_start();
+
+ kernel::actor::ActorImpl* issuer = Actor::self()->get_impl();
+ kernel::actor::simcall_blocking<void>([this, issuer, timeout] { this->get_impl()->wait_for(issuer, timeout); });
state_ = State::FINISHED;
on_completion(*Actor::self(), *this);
+ this->release_dependencies();
return this;
}
-Exec* Exec::wait_for(double)
-{
- THROW_UNIMPLEMENTED;
-}
-
int Exec::wait_any_for(std::vector<ExecPtr>* execs, double timeout)
{
std::unique_ptr<kernel::activity::ExecImpl* []> rexecs(new kernel::activity::ExecImpl*[execs->size()]);
std::transform(begin(*execs), end(*execs), rexecs.get(),
[](const ExecPtr& exec) { return static_cast<kernel::activity::ExecImpl*>(exec->pimpl_.get()); });
- return simcall_execution_waitany_for(rexecs.get(), execs->size(), timeout);
+
+ int changed_pos = simcall_execution_waitany_for(rexecs.get(), execs->size(), timeout);
+ if (changed_pos != -1)
+ execs->at(changed_pos)->release_dependencies();
+ return changed_pos;
}
Exec* Exec::cancel()
return this;
}
-void intrusive_ptr_release(simgrid::s4u::Exec* e)
-{
- if (e->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
- std::atomic_thread_fence(std::memory_order_acquire);
- delete e;
- }
-}
-
-void intrusive_ptr_add_ref(simgrid::s4u::Exec* e)
-{
- e->refcount_.fetch_add(1, std::memory_order_relaxed);
-}
-
/** @brief change the execution bound
* This means changing the maximal amount of flops per second that it may consume, regardless of what the host may
* deliver. Currently, this cannot be changed once the exec started.
bound_ = bound;
return this;
}
-ExecPtr Exec::set_timeout(double timeout)
+ExecPtr Exec::set_timeout(double timeout) // XBT_ATTRIB_DEPRECATED_v329
{
xbt_assert(state_ == State::INITED, "Cannot change the bound of an exec after its start");
timeout_ = timeout;
return this;
}
-ExecPtr Exec::set_name(const std::string& name)
-{
- xbt_assert(state_ == State::INITED, "Cannot change the name of an exec after its start");
- name_ = name;
- return this;
-}
-
/** @brief Retrieve the host on which this activity takes place.
* If it runs on more than one host, only the first host is returned.
*/
return this;
}
-ExecPtr Exec::set_tracing_category(const std::string& category)
-{
- xbt_assert(state_ == State::INITED, "Cannot change the tracing category of an exec after its start");
- tracing_category_ = category;
- return this;
-}
-
///////////// SEQUENTIAL EXECUTIONS ////////
ExecSeq::ExecSeq(sg_host_t host, double flops_amount) : Exec(), flops_amount_(flops_amount)
{
Activity::set_remaining(flops_amount_);
- boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->set_host(host);
+ boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->set_host(host);
}
Exec* ExecSeq::start()
{
kernel::actor::simcall([this] {
(*boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_))
- .set_name(name_)
- .set_tracing_category(tracing_category_)
+ .set_name(get_name())
+ .set_tracing_category(get_tracing_category())
.set_sharing_penalty(1. / priority_)
.set_bound(bound_)
.set_flops_amount(flops_amount_)
xbt_assert(state_ == State::INITED || state_ == State::STARTED,
"Cannot change the host of an exec once it's done (state: %d)", (int)state_);
if (state_ == State::STARTED)
- boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->migrate(host);
- boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->set_host(host);
+ boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->migrate(host);
+ boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->set_host(host);
return this;
}
-/** @brief Returns the amount of flops that remain to be done */
-double ExecSeq::get_remaining()
+double ExecSeq::get_remaining() const
{
- return simgrid::kernel::actor::simcall(
- [this]() { return boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->get_remaining(); });
+ return kernel::actor::simcall(
+ [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_remaining(); });
}
/** @brief Returns the ratio of elements that are still to do
*
* The returned value is between 0 (completely done) and 1 (nothing done yet).
*/
-double ExecSeq::get_remaining_ratio()
+double ExecSeq::get_remaining_ratio() const
{
- return simgrid::kernel::actor::simcall([this]() {
- return boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->get_seq_remaining_ratio();
- });
+ return kernel::actor::simcall(
+ [this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_seq_remaining_ratio(); });
}
///////////// PARALLEL EXECUTIONS ////////
return this;
}
-double ExecPar::get_remaining_ratio()
+double ExecPar::get_remaining_ratio() const
{
return kernel::actor::simcall(
[this]() { return boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->get_par_remaining_ratio(); });
}
-double ExecPar::get_remaining()
+double ExecPar::get_remaining() const
{
XBT_WARN("Calling get_remaining() on a parallel execution is not allowed. Call get_remaining_ratio() instead.");
return get_remaining_ratio();
