~Comm() override;
- static xbt::signal<void(Comm const&, Actor const&)> on_sender_start;
- static xbt::signal<void(Comm const&, Actor const&)> on_receiver_start;
- static xbt::signal<void(Comm const&, Actor const&)> on_completion;
+ static xbt::signal<void(Comm const&, bool is_sender)> on_start;
+ static xbt::signal<void(Comm const&)> on_completion;
/*! take a vector s4u::CommPtr and return when one of them is finished.
* The return value is the rank of the first finished CommPtr. */
Exec& operator=(Exec const&) = delete;
#endif
- static xbt::signal<void(Exec const&, Actor const&)> on_start;
- static xbt::signal<void(Exec const&, Actor const&)> on_completion;
+ static xbt::signal<void(Exec const&)> on_start;
+ static xbt::signal<void(Exec const&)> on_completion;
Exec* start() override;
/** @brief On sequential executions, returns the amount of flops that remain to be done; This cannot be used on
~Io() override = default;
#endif
- static xbt::signal<void(Io const&, Actor const&)> on_start;
- static xbt::signal<void(Io const&, Actor const&)> on_completion;
+ static xbt::signal<void(Io const&)> on_start;
+ static xbt::signal<void(Io const&)> on_completion;
Io* start() override;
Io* wait() override;
});
s4u::Actor::on_wake_up.connect(
[](s4u::Actor const& actor) { Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event(); });
- s4u::Exec::on_start.connect([](s4u::Exec const&, simgrid::s4u::Actor const& actor) {
- Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("execute");
+ s4u::Exec::on_start.connect([](s4u::Exec const&) {
+ Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->push_event("execute");
});
- s4u::Exec::on_completion.connect([](s4u::Exec const&, s4u::Actor const& actor) {
- Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
+ s4u::Exec::on_completion.connect([](s4u::Exec const&) {
+ Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->pop_event();
});
- s4u::Comm::on_sender_start.connect([](s4u::Comm const&, s4u::Actor const& actor) {
- Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("send");
+ s4u::Comm::on_start.connect([](s4u::Comm const&, bool is_sender) {
+ Container::by_name(instr_pid(*s4u::Actor::self()))
+ ->get_state("ACTOR_STATE")
+ ->push_event(is_sender ? "send" : "receive");
});
- s4u::Comm::on_receiver_start.connect([](s4u::Comm const&, s4u::Actor const& actor) {
- Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("receive");
- });
- s4u::Comm::on_completion.connect([](s4u::Comm const&, s4u::Actor const& actor) {
- Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
+ s4u::Comm::on_completion.connect([](s4u::Comm const&) {
+ Container::by_name(instr_pid(*s4u::Actor::self()))->get_state("ACTOR_STATE")->pop_event();
});
s4u::Actor::on_host_change.connect(on_actor_host_change);
}
if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing()) {
- s4u::Exec::on_start.connect([](s4u::Exec const& exec, simgrid::s4u::Actor const& actor) {
- Container::by_name(std::string("rank-") + std::to_string(actor.get_pid()))
+ s4u::Exec::on_start.connect([](s4u::Exec const& exec) {
+ Container::by_name(std::string("rank-") + std::to_string(s4u::Actor::self()->get_pid()))
->get_state("MPI_STATE")
->push_event("computing", new CpuTIData("compute", exec.get_cost()));
});
- s4u::Exec::on_completion.connect([](s4u::Exec const&, s4u::Actor const& actor) {
- Container::by_name(std::string("rank-") + std::to_string(actor.get_pid()))->get_state("MPI_STATE")->pop_event();
+ s4u::Exec::on_completion.connect([](s4u::Exec const&) {
+ Container::by_name(std::string("rank-") + std::to_string(s4u::Actor::self()->get_pid()))
+ ->get_state("MPI_STATE")
+ ->pop_event();
});
}
vm.extension_set<simgrid::vm::DirtyPageTrackingExt>(new simgrid::vm::DirtyPageTrackingExt());
}
-static void on_exec_creation(simgrid::s4u::Exec const& e, simgrid::s4u::Actor const&)
+static void on_exec_creation(simgrid::s4u::Exec const& e)
{
auto exec = static_cast<simgrid::kernel::activity::ExecImpl*>(e.get_impl());
const simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec->get_host());
}
}
-static void on_exec_completion(simgrid::s4u::Exec const& e, simgrid::s4u::Actor const&)
+static void on_exec_completion(simgrid::s4u::Exec const& e)
{
auto exec = static_cast<simgrid::kernel::activity::ExecImpl*>(e.get_impl());
const simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec->get_host());
task_id = 0;
}
});
- simgrid::s4u::Exec::on_start.connect([this](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) {
+ simgrid::s4u::Exec::on_start.connect([this](simgrid::s4u::Exec const& activity) {
if (activity.get_host() == get_host())
pre_task();
});
- simgrid::s4u::Exec::on_completion.connect([this](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) {
+ simgrid::s4u::Exec::on_completion.connect([this](simgrid::s4u::Exec const& activity) {
// For more than one host (not yet supported), we can access the host via
// simcalls_.front()->issuer->get_iface()->get_host()
if (activity.get_host() == get_host() && iteration_running) {
// that the next trigger would be the 2nd compute, hence ignoring the idle time
// during the recv call. By updating at the beginning of a compute, we can
// fix that. (If the cpu is not idle, this is not required.)
- simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) {
+ simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Exec const& activity) {
if (activity.get_host_number() == 1) { // We only run on one host
simgrid::s4u::Host* host = activity.get_host();
const simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
host.extension_set(new HostLoad(&host));
});
- simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) {
+ simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Exec const& activity) {
if (activity.get_host_number() == 1) { // We only run on one host
simgrid::s4u::Host* host = activity.get_host();
const simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
XBT_WARN("HostLoad plugin currently does not support executions on several hosts");
}
});
- simgrid::s4u::Exec::on_completion.connect([](simgrid::s4u::Exec const& activity, simgrid::s4u::Actor const&) {
+ simgrid::s4u::Exec::on_completion.connect([](simgrid::s4u::Exec const& activity) {
if (activity.get_host_number() == 1) { // We only run on one host
simgrid::s4u::Host* host = activity.get_host();
const simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
}
}
-static void add_active_exec(s4u::Exec const& task, s4u::Actor const&)
+static void add_active_exec(s4u::Exec const& task)
{
const s4u::VirtualMachine* vm = dynamic_cast<s4u::VirtualMachine*>(task.get_host());
if (vm != nullptr) {
}
}
-static void remove_active_exec(s4u::Exec const& task, s4u::Actor const&)
+static void remove_active_exec(s4u::Exec const& task)
{
const s4u::VirtualMachine* vm = dynamic_cast<s4u::VirtualMachine*>(task.get_host());
if (vm != nullptr) {
namespace simgrid {
namespace s4u {
-xbt::signal<void(Comm const&, Actor const&)> Comm::on_sender_start;
-xbt::signal<void(Comm const&, Actor const&)> Comm::on_receiver_start;
-xbt::signal<void(Comm const&, Actor const&)> Comm::on_completion;
+xbt::signal<void(Comm const&, bool is_sender)> Comm::on_start;
+xbt::signal<void(Comm const&)> Comm::on_completion;
Comm::~Comm()
{
"You cannot use %s() once your communication started (not implemented)", __FUNCTION__);
if (src_buff_ != nullptr) { // Sender side
- on_sender_start(*this, *Actor::self());
+ on_start(*this, true /* is_sender*/);
pimpl_ = simcall_comm_isend(sender_, mailbox_->get_impl(), remains_, rate_, src_buff_, src_buff_size_, match_fun_,
clean_fun_, copy_data_function_, get_user_data(), detached_);
} else if (dst_buff_ != nullptr) { // Receiver side
xbt_assert(not detached_, "Receive cannot be detached");
- on_receiver_start(*this, *Actor::self());
+ on_start(*this, false /*is_sender*/);
pimpl_ = simcall_comm_irecv(receiver_, mailbox_->get_impl(), dst_buff_, &dst_buff_size_, match_fun_,
copy_data_function_, get_user_data(), rate_);
case State::INITED:
case State::STARTING: // It's not started yet. Do it in one simcall
if (src_buff_ != nullptr) {
- on_sender_start(*this, *Actor::self());
+ on_start(*this, true /*is_sender*/);
simcall_comm_send(sender_, mailbox_->get_impl(), remains_, rate_, src_buff_, src_buff_size_, match_fun_,
copy_data_function_, get_user_data(), timeout);
} else { // Receiver
- on_receiver_start(*this, *Actor::self());
+ on_start(*this, false /*is_sender*/);
simcall_comm_recv(receiver_, mailbox_->get_impl(), dst_buff_, &dst_buff_size_, match_fun_, copy_data_function_,
get_user_data(), timeout, rate_);
}
default:
THROW_IMPOSSIBLE;
}
- on_completion(*this, *Actor::self());
+ on_completion(*this);
return this;
}
namespace simgrid {
namespace s4u {
-xbt::signal<void(Exec const&, Actor const&)> Exec::on_start;
-xbt::signal<void(Exec const&, Actor const&)> Exec::on_completion;
+xbt::signal<void(Exec const&)> Exec::on_start;
+xbt::signal<void(Exec const&)> Exec::on_completion;
Exec::Exec()
{
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(*this, *Actor::self());
+ on_completion(*this);
this->release_dependencies();
return this;
}
pimpl_->suspend();
state_ = State::STARTED;
- on_start(*this, *Actor::self());
+ on_start(*this);
return this;
}
namespace simgrid {
namespace s4u {
-xbt::signal<void(Io const&, Actor const&)> Io::on_start;
-xbt::signal<void(Io const&, Actor const&)> Io::on_completion;
+xbt::signal<void(Io const&)> Io::on_start;
+xbt::signal<void(Io const&)> Io::on_completion;
Io::Io(sg_disk_t disk, sg_size_t size, OpType type) : disk_(disk), size_(size), type_(type)
{
pimpl_->suspend();
state_ = State::STARTED;
- on_start(*this, *Actor::self());
+ on_start(*this);
return this;
}
state_ = State::FINISHED;
this->release_dependencies();
- on_completion(*this, *Actor::self());
+ on_completion(*this);
return this;
}