> [Tremblay:monitor 1:(2) 10.000000] [s4u_test/INFO] activity remaining duration: 2.3704e+08 (24%)
> [Fafard:executor:(1) 13.106847] [s4u_test/INFO] The monitored task is over. Let's start 3 of them now.
> [Jupiter:monitor 2:(3) 13.106847] [s4u_test/INFO] activity remaining duration: 1e+09 (100%)
-> [Fafard:executor:(1) 13.106847] [s4u_test/INFO] All activities are started; finish now
> [Ginette:monitor 3:(4) 13.106847] [s4u_test/INFO] activity remaining duration: 1e+09 (100%)
+> [Fafard:executor:(1) 13.106847] [s4u_test/INFO] All activities are started; finish now
> [Bourassa:monitor 4:(5) 13.106847] [s4u_test/INFO] activity remaining duration: 1e+09 (100%)
> [Tremblay:monitor 1:(2) 15.000000] [s4u_test/INFO] My task is over.
> [Bourassa:monitor 4:(5) 18.106847] [s4u_test/INFO] activity remaining duration: 8.7284e+08 (87%)
*/
class XBT_PUBLIC Exec : public Activity {
- Exec() : Activity() {}
+ explicit Exec(sg_host_t host, double flops_amount);
+
public:
friend XBT_PUBLIC void intrusive_ptr_release(simgrid::s4u::Exec * e);
friend XBT_PUBLIC void intrusive_ptr_add_ref(simgrid::s4u::Exec * e);
public:
ActivityImpl() = default;
explicit ActivityImpl(std::string name) : name_(name) {}
- explicit ActivityImpl(std::string name, resource::Action* surf_action) : name_(name), surf_action_(surf_action) {}
virtual ~ActivityImpl() = default;
e_smx_state_t state_ = SIMIX_WAITING; /* State of the activity */
std::string name_; /* Activity name if any */
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_process);
-simgrid::kernel::activity::ExecImpl::ExecImpl(std::string name, resource::Action* surf_action,
+simgrid::kernel::activity::ExecImpl::ExecImpl(std::string name, std::string tracing_category,
resource::Action* timeout_detector, s4u::Host* host)
- : ActivityImpl(name, surf_action), host_(host), timeout_detector_(timeout_detector)
+ : ActivityImpl(name), host_(host), timeout_detector_(timeout_detector)
{
this->state_ = SIMIX_RUNNING;
+ this->set_category(tracing_category);
- surf_action_->set_data(this);
if (timeout_detector != nullptr)
- timeout_detector->set_data(this);
+ timeout_detector_->set_data(this);
XBT_DEBUG("Create exec %p", this);
}
XBT_DEBUG("Destroy exec %p", this);
}
+void simgrid::kernel::activity::ExecImpl::start(double flops_amount, double priority, double bound)
+{
+ if (not MC_is_active() && not MC_record_replay_is_active()) {
+ surf_action_ = host_->pimpl_cpu->execution_start(flops_amount);
+ surf_action_->set_data(this);
+ surf_action_->set_priority(priority);
+ if (bound > 0)
+ surf_action_->set_bound(bound);
+ }
+
+ XBT_DEBUG("Create execute synchro %p: %s", this, name_.c_str());
+ simgrid::kernel::activity::ExecImpl::on_creation(this);
+}
+
void simgrid::kernel::activity::ExecImpl::suspend()
{
XBT_VERB("This exec is suspended (remain: %f)", surf_action_->get_remains());
~ExecImpl() override;
public:
- explicit ExecImpl(std::string name, resource::Action* surf_action, resource::Action* timeout_detector,
+ explicit ExecImpl(std::string name, std::string tracing_category, resource::Action* timeout_detector,
s4u::Host* host);
+ void start(double flops_amount, double priority, double bound);
void suspend() override;
void resume() override;
void cancel();
ExecPtr exec_init(double flops_amount)
{
- ExecPtr res = ExecPtr(new Exec());
- res->host_ = get_host();
- res->flops_amount_ = flops_amount;
- res->set_remaining(flops_amount);
- return res;
+ return ExecPtr(new Exec(get_host(), flops_amount));
}
ExecPtr exec_async(double flops)
simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_start;
simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> s4u::Exec::on_completion;
+Exec::Exec(sg_host_t host, double flops_amount) : Activity(), host_(host), flops_amount_(flops_amount)
+{
+ Activity::set_remaining(flops_amount_);
+ pimpl_ = simix::simcall([this] {
+ return kernel::activity::ExecImplPtr(new kernel::activity::ExecImpl(name_, tracing_category_,
+ /*timeout_detector*/ nullptr, host_));
+ });
+}
+
Exec* Exec::start()
{
- pimpl_ = simcall_execution_start(name_, tracing_category_, flops_amount_, 1. / priority_, bound_, host_);
+ simix::simcall([this] {
+ dynamic_cast<kernel::activity::ExecImpl*>(pimpl_.get())->start(flops_amount_, 1. / priority_, bound_);
+ });
state_ = State::STARTED;
on_start(Actor::self());
return this;
if (state_ == State::STARTED)
boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->migrate(host);
host_ = host;
+ boost::static_pointer_cast<simgrid::kernel::activity::ExecImpl>(pimpl_)->host_ = host;
return this;
}
{
execute(flops, 1.0 /* priority */);
}
+
void Host::execute(double flops, double priority)
{
this_actor::exec_init(flops)->set_host(this)->set_priority(1 / priority)->start()->wait();
IoPtr Storage::io_init(sg_size_t size, Io::OpType type)
{
- IoPtr res = IoPtr(new Io(this, size, type));
- return res;
+ return IoPtr(new Io(this, size, type));
}
IoPtr Storage::read_async(sg_size_t size)
}
simgrid::kernel::activity::ExecImplPtr exec = simgrid::kernel::activity::ExecImplPtr(
- new simgrid::kernel::activity::ExecImpl(name, surf_action, /*timeout_detector*/ nullptr, host));
+ new simgrid::kernel::activity::ExecImpl(name, category, /*timeout_detector*/ nullptr, host));
+
+ exec->surf_action_ = surf_action;
+ exec->surf_action_->set_data(exec.get());
- exec->set_category(category);
XBT_DEBUG("Create execute synchro %p: %s", exec.get(), exec->name_.c_str());
simgrid::kernel::activity::ExecImpl::on_creation(exec);
}
simgrid::kernel::activity::ExecImplPtr exec = simgrid::kernel::activity::ExecImplPtr(
- new simgrid::kernel::activity::ExecImpl(name, surf_action, timeout_detector, nullptr));
+ new simgrid::kernel::activity::ExecImpl(name, "", timeout_detector, nullptr));
+ exec->surf_action_ = surf_action;
+ exec->surf_action_->set_data(exec.get());
XBT_DEBUG("Create parallel execute synchro %p", exec.get());