/* Register a callback in the Actor::on_destruction signal. It will be called for every terminated actors */
simgrid::s4u::Actor::on_destruction.connect(
- [](simgrid::s4u::ActorPtr actor) { XBT_INFO("Actor %s stops now", actor->get_cname()); });
+ [](simgrid::s4u::Actor const& actor) { XBT_INFO("Actor %s stops now", actor.get_cname()); });
/* Create some actors */
simgrid::s4u::Actor::create("A", simgrid::s4u::Host::by_name("Tremblay"), actor_a);
bool is_host() const { return component_type_ == Type::Host; }
bool is_router() const { return component_type_ == Type::Router; }
- static simgrid::xbt::signal<void(NetPoint*)> on_creation;
+ static simgrid::xbt::signal<void(NetPoint&)> on_creation;
bool operator<(const NetPoint& rhs) const { return name_ < rhs.name_; }
static ActorPtr self();
/** Signal to others that a new actor has been created **/
- static xbt::signal<void(ActorPtr)> on_creation;
+ static xbt::signal<void(Actor&)> on_creation;
/** Signal to others that an actor has been suspended**/
- static xbt::signal<void(ActorPtr)> on_suspend;
+ static xbt::signal<void(Actor const&)> on_suspend;
/** Signal to others that an actor has been resumed **/
- static xbt::signal<void(ActorPtr)> on_resume;
+ static xbt::signal<void(Actor const&)> on_resume;
/** Signal to others that an actor is sleeping **/
- static xbt::signal<void(ActorPtr)> on_sleep;
+ static xbt::signal<void(Actor const&)> on_sleep;
/** Signal to others that an actor wakes up for a sleep **/
- static xbt::signal<void(ActorPtr)> on_wake_up;
+ static xbt::signal<void(Actor const&)> on_wake_up;
/** Signal to others that an actor is going to migrated to another host**/
- static xbt::signal<void(ActorPtr)> on_migration_start;
+ static xbt::signal<void(Actor const&)> on_migration_start;
/** Signal to others that an actor is has been migrated to another host **/
- static xbt::signal<void(ActorPtr)> on_migration_end;
+ static xbt::signal<void(Actor const&)> on_migration_end;
/** Signal indicating that an actor is about to disappear.
* This signal is fired for any dying actor, which is mostly useful when designing plugins and extensions. If you
* want to register to the termination of a given actor, use this_actor::on_exit() instead.*/
- static xbt::signal<void(ActorPtr)> on_destruction;
+ static xbt::signal<void(Actor const&)> on_destruction;
/** Create an actor from a std::function<void()>
*
virtual ~Comm();
- static xbt::signal<void(ActorPtr)> on_sender_start;
- static xbt::signal<void(ActorPtr)> on_receiver_start;
- static xbt::signal<void(ActorPtr)> on_completion;
+ static xbt::signal<void(Actor const&)> on_sender_start;
+ static xbt::signal<void(Actor const&)> on_receiver_start;
+ static xbt::signal<void(Actor 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. */
friend ExecPar;
friend XBT_PUBLIC void intrusive_ptr_release(Exec* e);
friend XBT_PUBLIC void intrusive_ptr_add_ref(Exec* e);
- static xbt::signal<void(ActorPtr)> on_start;
- static xbt::signal<void(ActorPtr)> on_completion;
+ static xbt::signal<void(Actor const&)> on_start;
+ static xbt::signal<void(Actor const&)> on_completion;
virtual Exec* start() override = 0;
virtual double get_remaining_ratio() = 0;
/*** Called on each newly created host */
static xbt::signal<void(Host&)> on_creation;
/*** Called just before destructing a host */
- static xbt::signal<void(Host&)> on_destruction;
+ static xbt::signal<void(Host const&)> on_destruction;
/*** Called when the machine is turned on or off (called AFTER the change) */
- static xbt::signal<void(Host&)> on_state_change;
+ static xbt::signal<void(Host const&)> on_state_change;
/*** Called when the speed of the machine is changed (called AFTER the change)
* (either because of a pstate switch or because of an external load event coming from the profile) */
- static xbt::signal<void(Host&)> on_speed_change;
+ static xbt::signal<void(Host const&)> on_speed_change;
virtual void destroy();
// No copy/move
static xbt::signal<void(Link&)> on_creation;
/** @brief Callback signal fired when a Link is destroyed */
- static xbt::signal<void(Link&)> on_destruction;
+ static xbt::signal<void(Link const&)> on_destruction;
/** @brief Callback signal fired when the state of a Link changes (when it is turned on or off) */
- static xbt::signal<void(Link&)> on_state_change;
+ static xbt::signal<void(Link const&)> on_state_change;
/** @brief Callback signal fired when the bandwidth of a Link changes */
- static xbt::signal<void(Link&)> on_bandwidth_change;
+ static xbt::signal<void(Link const&)> on_bandwidth_change;
/** @brief Callback signal fired when a communication starts */
- static xbt::signal<void(kernel::resource::NetworkAction*, Host* src, Host* dst)> on_communicate;
+ static xbt::signal<void(kernel::resource::NetworkAction&, Host* src, Host* dst)> on_communicate;
/** @brief Callback signal fired when a communication changes it state (ready/done/cancel) */
- static xbt::signal<void(kernel::resource::NetworkAction*, kernel::resource::Action::State)>
+ static xbt::signal<void(kernel::resource::NetworkAction&, kernel::resource::Action::State)>
on_communication_state_change;
#ifndef DOXYGEN
/*** Called on each newly created regular route (not on bypass routes) */
static xbt::signal<void(bool symmetrical, kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst,
kernel::routing::NetPoint* gw_src, kernel::routing::NetPoint* gw_dst,
- std::vector<kernel::resource::LinkImpl*>& link_list)>
+ std::vector<kernel::resource::LinkImpl*> const& link_list)>
on_route_creation;
- static xbt::signal<void(NetZone&)> on_creation;
- static xbt::signal<void(NetZone&)> on_seal;
+ static xbt::signal<void(NetZone const&)> on_creation;
+ static xbt::signal<void(NetZone const&)> on_seal;
#ifndef DOXYGEN
// Deprecation wrappers
/** @brief Callback signal fired when a new Storage is created */
static xbt::signal<void(Storage&)> on_creation;
/** @brief Callback signal fired when a Storage is destroyed */
- static xbt::signal<void(Storage&)> on_destruction;
+ static xbt::signal<void(Storage const&)> on_destruction;
/** @brief Callback signal fired when a Storage's state changes */
- static xbt::signal<void(Storage&)> on_state_change;
+ static xbt::signal<void(Storage const&)> on_state_change;
/** Retrieve a Storage by its name. It must exist in the platform file */
static Storage* by_name(const std::string& name);
void set_bound(double bound);
VirtualMachine::state get_state();
- static xbt::signal<void(VirtualMachine&)> on_start;
- static xbt::signal<void(VirtualMachine&)> on_started;
- static xbt::signal<void(VirtualMachine&)> on_shutdown;
- static xbt::signal<void(VirtualMachine&)> on_suspend;
- static xbt::signal<void(VirtualMachine&)> on_resume;
- static xbt::signal<void(VirtualMachine&)> on_migration_start;
- static xbt::signal<void(VirtualMachine&)> on_migration_end;
+ static xbt::signal<void(VirtualMachine const&)> on_start;
+ static xbt::signal<void(VirtualMachine const&)> on_started;
+ static xbt::signal<void(VirtualMachine const&)> on_shutdown;
+ static xbt::signal<void(VirtualMachine const&)> on_suspend;
+ static xbt::signal<void(VirtualMachine const&)> on_resume;
+ static xbt::signal<void(VirtualMachine const&)> on_migration_start;
+ static xbt::signal<void(VirtualMachine const&)> on_migration_end;
#ifndef DOXYGEN
// Deprecated methods
/*
* Callbacks
*/
-static void instr_netzone_on_creation(simgrid::s4u::NetZone& netzone)
+static void instr_netzone_on_creation(simgrid::s4u::NetZone const& netzone)
{
std::string id = netzone.get_name();
if (simgrid::instr::Container::get_root() == nullptr) {
}
}
-static void instr_link_on_creation(simgrid::s4u::Link& link)
+static void instr_link_on_creation(simgrid::s4u::Link const& link)
{
if (currentContainer.empty()) // No ongoing parsing. Are you creating the loopback?
return;
}
}
-static void instr_host_on_creation(simgrid::s4u::Host& host)
+static void instr_host_on_creation(simgrid::s4u::Host const& host)
{
container_t container = new simgrid::instr::HostContainer(host, currentContainer.back());
container_t root = simgrid::instr::Container::get_root();
}
}
-static void instr_host_on_speed_change(simgrid::s4u::Host& host)
+static void instr_host_on_speed_change(simgrid::s4u::Host const& host)
{
simgrid::instr::Container::by_name(host.get_name())
->get_variable("speed")
->set_event(surf_get_clock(), host.get_core_count() * host.get_available_speed());
}
-static void instr_action_on_state_change(simgrid::kernel::resource::Action* action,
+static void instr_action_on_state_change(simgrid::kernel::resource::Action const& action,
simgrid::kernel::resource::Action::State /* previous */)
{
- int n = action->get_variable()->get_number_of_constraint();
+ int n = action.get_variable()->get_number_of_constraint();
for (int i = 0; i < n; i++) {
- double value = action->get_variable()->get_value() * action->get_variable()->get_constraint_weight(i);
+ double value = action.get_variable()->get_value() * action.get_variable()->get_constraint_weight(i);
/* Beware of composite actions: ptasks put links and cpus together. Extra pb: we cannot dynamic_cast from void* */
simgrid::kernel::resource::Resource* resource =
- static_cast<simgrid::kernel::resource::Resource*>(action->get_variable()->get_constraint(i)->get_id());
+ static_cast<simgrid::kernel::resource::Resource*>(action.get_variable()->get_constraint(i)->get_id());
simgrid::surf::Cpu* cpu = dynamic_cast<simgrid::surf::Cpu*>(resource);
if (cpu != nullptr)
- TRACE_surf_resource_set_utilization("HOST", "speed_used", cpu->get_cname(), action->get_category(), value,
- action->get_last_update(), SIMIX_get_clock() - action->get_last_update());
+ TRACE_surf_resource_set_utilization("HOST", "speed_used", cpu->get_cname(), action.get_category(), value,
+ action.get_last_update(), SIMIX_get_clock() - action.get_last_update());
simgrid::kernel::resource::LinkImpl* link = dynamic_cast<simgrid::kernel::resource::LinkImpl*>(resource);
if (link != nullptr)
- TRACE_surf_resource_set_utilization("LINK", "bandwidth_used", link->get_cname(), action->get_category(), value,
- action->get_last_update(), SIMIX_get_clock() - action->get_last_update());
+ TRACE_surf_resource_set_utilization("LINK", "bandwidth_used", link->get_cname(), action.get_category(), value,
+ action.get_last_update(), SIMIX_get_clock() - action.get_last_update());
}
}
-static void instr_link_on_bandwidth_change(simgrid::s4u::Link& link)
+static void instr_link_on_bandwidth_change(simgrid::s4u::Link const& link)
{
simgrid::instr::Container::by_name(link.get_name())
->get_variable("bandwidth")
->set_event(surf_get_clock(), sg_bandwidth_factor * link.get_bandwidth());
}
-static void instr_netpoint_on_creation(simgrid::kernel::routing::NetPoint* netpoint)
+static void instr_netpoint_on_creation(simgrid::kernel::routing::NetPoint const& netpoint)
{
- if (netpoint->is_router())
- new simgrid::instr::RouterContainer(netpoint->get_name(), currentContainer.back());
+ if (netpoint.is_router())
+ new simgrid::instr::RouterContainer(netpoint.get_name(), currentContainer.back());
}
static void instr_on_platform_created()
TRACE_paje_dump_buffer(true);
}
-static void instr_actor_on_creation(simgrid::s4u::ActorPtr actor)
+static void instr_actor_on_creation(simgrid::s4u::Actor const& actor)
{
container_t root = simgrid::instr::Container::get_root();
- container_t container = simgrid::instr::Container::by_name(actor->get_host()->get_name());
+ container_t container = simgrid::instr::Container::by_name(actor.get_host()->get_name());
- container->create_child(instr_pid(actor.get()), "ACTOR");
+ container->create_child(instr_pid(actor), "ACTOR");
simgrid::instr::ContainerType* actor_type =
container->type_->by_name_or_create<simgrid::instr::ContainerType>("ACTOR");
simgrid::instr::StateType* state = actor_type->by_name_or_create<simgrid::instr::StateType>("ACTOR_STATE");
root->type_->by_name_or_create("ACTOR_LINK", actor_type, actor_type);
root->type_->by_name_or_create("ACTOR_TASK_LINK", actor_type, actor_type);
- std::string container_name = instr_pid(actor.get());
- actor->on_exit([container_name](bool failed) {
+ std::string container_name = instr_pid(actor);
+ actor.on_exit([container_name](bool failed) {
if (failed)
// kill means that this actor no longer exists, let's destroy it
simgrid::instr::Container::by_name(container_name)->remove_from_parent();
static long long int counter = 0;
-static void instr_actor_on_migration_start(simgrid::s4u::ActorPtr actor)
+static void instr_actor_on_migration_start(simgrid::s4u::Actor const& actor)
{
// start link
- container_t container = simgrid::instr::Container::by_name(instr_pid(actor.get()));
+ container_t container = simgrid::instr::Container::by_name(instr_pid(actor));
simgrid::instr::Container::get_root()->get_link("ACTOR_LINK")->start_event(container, "M", std::to_string(counter));
// destroy existing container of this process
container->remove_from_parent();
}
-static void instr_actor_on_migration_end(simgrid::s4u::ActorPtr actor)
+static void instr_actor_on_migration_end(simgrid::s4u::Actor const& actor)
{
// create new container on the new_host location
- simgrid::instr::Container::by_name(actor->get_host()->get_name())->create_child(instr_pid(actor.get()), "ACTOR");
+ simgrid::instr::Container::by_name(actor.get_host()->get_name())->create_child(instr_pid(actor), "ACTOR");
// end link
simgrid::instr::Container::get_root()
->get_link("ACTOR_LINK")
- ->end_event(simgrid::instr::Container::by_name(instr_pid(actor.get())), "M", std::to_string(counter));
+ ->end_event(simgrid::instr::Container::by_name(instr_pid(actor)), "M", std::to_string(counter));
counter++;
}
-static void instr_vm_on_creation(simgrid::s4u::Host& host)
+static void instr_vm_on_creation(simgrid::s4u::Host const& host)
{
container_t container = new simgrid::instr::HostContainer(host, currentContainer.back());
container_t root = simgrid::instr::Container::get_root();
simgrid::s4u::Host::on_speed_change.connect(instr_host_on_speed_change);
simgrid::s4u::Link::on_creation.connect(instr_link_on_creation);
simgrid::s4u::Link::on_bandwidth_change.connect(instr_link_on_bandwidth_change);
- simgrid::s4u::NetZone::on_seal.connect([](simgrid::s4u::NetZone& /*netzone*/) { currentContainer.pop_back(); });
+ simgrid::s4u::NetZone::on_seal.connect(
+ [](simgrid::s4u::NetZone const& /*netzone*/) { currentContainer.pop_back(); });
simgrid::kernel::routing::NetPoint::on_creation.connect(instr_netpoint_on_creation);
}
simgrid::s4u::NetZone::on_creation.connect(instr_netzone_on_creation);
if (TRACE_actor_is_enabled()) {
simgrid::s4u::Actor::on_creation.connect(instr_actor_on_creation);
- simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::ActorPtr actor) {
- auto container = simgrid::instr::Container::by_name_or_null(instr_pid(actor.get()));
+ simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::Actor const& actor) {
+ auto container = simgrid::instr::Container::by_name_or_null(instr_pid(actor));
if (container != nullptr)
container->remove_from_parent();
});
- simgrid::s4u::Actor::on_suspend.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("suspend");
+ simgrid::s4u::Actor::on_suspend.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("suspend");
});
- simgrid::s4u::Actor::on_resume.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->pop_event();
+ simgrid::s4u::Actor::on_resume.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
});
- simgrid::s4u::Actor::on_sleep.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("sleep");
+ simgrid::s4u::Actor::on_sleep.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("sleep");
});
- simgrid::s4u::Actor::on_wake_up.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->pop_event();
+ simgrid::s4u::Actor::on_wake_up.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
});
- simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("execute");
+ simgrid::s4u::Exec::on_start.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("execute");
});
- simgrid::s4u::Exec::on_completion.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->pop_event();
+ simgrid::s4u::Exec::on_completion.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
});
- simgrid::s4u::Comm::on_sender_start.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("send");
+ simgrid::s4u::Comm::on_sender_start.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("send");
});
- simgrid::s4u::Comm::on_receiver_start.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("receive");
+ simgrid::s4u::Comm::on_receiver_start.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->push_event("receive");
});
- simgrid::s4u::Comm::on_completion.connect([](simgrid::s4u::ActorPtr actor) {
- simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->pop_event();
+ simgrid::s4u::Comm::on_completion.connect([](simgrid::s4u::Actor const& actor) {
+ simgrid::instr::Container::by_name(instr_pid(actor))->get_state("ACTOR_STATE")->pop_event();
});
simgrid::s4u::Actor::on_migration_start.connect(instr_actor_on_migration_start);
simgrid::s4u::Actor::on_migration_end.connect(instr_actor_on_migration_end);
if (TRACE_vm_is_enabled()) {
simgrid::s4u::Host::on_creation.connect(instr_vm_on_creation);
- simgrid::s4u::VirtualMachine::on_start.connect([](simgrid::s4u::VirtualMachine& vm) {
+ simgrid::s4u::VirtualMachine::on_start.connect([](simgrid::s4u::VirtualMachine const& vm) {
simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->push_event("start");
});
- simgrid::s4u::VirtualMachine::on_started.connect([](simgrid::s4u::VirtualMachine& vm) {
+ simgrid::s4u::VirtualMachine::on_started.connect([](simgrid::s4u::VirtualMachine const& vm) {
simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->pop_event();
});
- simgrid::s4u::VirtualMachine::on_suspend.connect([](simgrid::s4u::VirtualMachine& vm) {
+ simgrid::s4u::VirtualMachine::on_suspend.connect([](simgrid::s4u::VirtualMachine const& vm) {
simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->push_event("suspend");
});
- simgrid::s4u::VirtualMachine::on_resume.connect([](simgrid::s4u::VirtualMachine& vm) {
+ simgrid::s4u::VirtualMachine::on_resume.connect([](simgrid::s4u::VirtualMachine const& vm) {
simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->pop_event();
});
- simgrid::s4u::Host::on_destruction.connect(
- [](simgrid::s4u::Host& host) { simgrid::instr::Container::by_name(host.get_name())->remove_from_parent(); });
+ simgrid::s4u::Host::on_destruction.connect([](simgrid::s4u::Host const& host) {
+ simgrid::instr::Container::by_name(host.get_name())->remove_from_parent();
+ });
}
}
/*
}
}
-XBT_PRIVATE std::string instr_pid(s4u_Actor* proc);
+XBT_PRIVATE std::string instr_pid(simgrid::s4u::Actor const& proc);
extern XBT_PRIVATE std::set<std::string> created_categories;
extern XBT_PRIVATE std::set<std::string> declared_marks;
return;
XBT_VERB("This activity is suspended (remain: %f)", surf_action_->get_remains());
surf_action_->suspend();
- on_suspended(this);
+ on_suspended(*this);
}
void ActivityImpl::resume()
return;
XBT_VERB("This activity is resumed (remain: %f)", surf_action_->get_remains());
surf_action_->resume();
- on_resumed(this);
+ on_resumed(*this);
}
void ActivityImpl::set_category(const std::string& category)
delete activity;
}
}
-xbt::signal<void(ActivityImplPtr)> ActivityImpl::on_resumed;
-xbt::signal<void(ActivityImplPtr)> ActivityImpl::on_suspended;
+xbt::signal<void(ActivityImpl const&)> ActivityImpl::on_resumed;
+xbt::signal<void(ActivityImpl const&)> ActivityImpl::on_suspended;
}
}
} // namespace simgrid::kernel::activity::
std::string name_; /* Activity name if any */
public:
- static xbt::signal<void(ActivityImplPtr)> on_suspended;
- static xbt::signal<void(ActivityImplPtr)> on_resumed;
+ static xbt::signal<void(ActivityImpl const&)> on_suspended;
+ static xbt::signal<void(ActivityImpl const&)> on_resumed;
};
} // namespace activity
} // namespace kernel
}
XBT_DEBUG("Create execute synchro %p: %s", this, get_cname());
- ExecImpl::on_creation(this);
+ ExecImpl::on_creation(*this);
return this;
}
}
}
XBT_DEBUG("Create parallel execute synchro %p", this);
- ExecImpl::on_creation(this);
+ ExecImpl::on_creation(*this);
return this;
}
void ExecImpl::cancel()
state_ = SIMIX_DONE;
}
- on_completion(this);
+ on_completion(*this);
if (surf_action_) {
surf_action_->unref();
this->surf_action_ = new_action;
}
- on_migration(this, to);
+ on_migration(*this, to);
return this;
}
/*************
* Callbacks *
*************/
-xbt::signal<void(ExecImplPtr)> ExecImpl::on_creation;
-xbt::signal<void(ExecImplPtr)> ExecImpl::on_completion;
-xbt::signal<void(ExecImplPtr, s4u::Host*)> ExecImpl::on_migration;
+xbt::signal<void(ExecImpl&)> ExecImpl::on_creation;
+xbt::signal<void(ExecImpl const&)> ExecImpl::on_completion;
+xbt::signal<void(ExecImpl const&, s4u::Host*)> ExecImpl::on_migration;
} // namespace activity
} // namespace kernel
/* The host where the execution takes place. nullptr means this is a parallel exec (and only surf knows the hosts) */
s4u::Host* host_ = nullptr;
- static xbt::signal<void(ExecImplPtr)> on_creation;
- static xbt::signal<void(ExecImplPtr)> on_completion;
- static xbt::signal<void(ExecImplPtr, s4u::Host*)> on_migration;
+ static xbt::signal<void(ExecImpl&)> on_creation;
+ static xbt::signal<void(ExecImpl const&)> on_completion;
+ static xbt::signal<void(ExecImpl const&, s4u::Host*)> on_migration;
};
} // namespace activity
} // namespace kernel
surf_action_->set_data(this);
XBT_DEBUG("Create IO synchro %p %s", this, get_cname());
- IoImpl::on_start(this);
+ IoImpl::on_start(*this);
return this;
}
default:
THROW_IMPOSSIBLE;
}
- on_completion(this);
+ on_completion(*this);
finish();
}
/*************
* Callbacks *
*************/
-xbt::signal<void(IoImplPtr)> IoImpl::on_start;
-xbt::signal<void(IoImplPtr)> IoImpl::on_completion;
+xbt::signal<void(IoImpl const&)> IoImpl::on_start;
+xbt::signal<void(IoImpl const&)> IoImpl::on_completion;
} // namespace activity
} // namespace kernel
void cancel();
double get_remaining();
- static xbt::signal<void(IoImplPtr)> on_start;
- static xbt::signal<void(IoImplPtr)> on_completion;
+ static xbt::signal<void(IoImpl const&)> on_start;
+ static xbt::signal<void(IoImpl const&)> on_completion;
};
} // namespace activity
} // namespace kernel
context->attach_start();
/* The on_creation() signal must be delayed until there, where the pid and everything is set */
- simgrid::s4u::ActorPtr tmp = actor->iface(); // Passing this directly to on_creation will lead to crashes
- simgrid::s4u::Actor::on_creation(tmp);
+ simgrid::s4u::Actor::on_creation(*actor->ciface());
return ActorImplPtr(actor);
}
simix_global->mutex.unlock();
context_->iwannadie = false; // don't let the simcall's yield() do a Context::stop(), to avoid infinite loops
- simgrid::simix::simcall([this] { simgrid::s4u::Actor::on_destruction(iface()); });
+ simgrid::simix::simcall([this] { simgrid::s4u::Actor::on_destruction(*ciface()); });
context_->iwannadie = true;
}
intrusive_ptr_add_ref(actor);
/* The on_creation() signal must be delayed until there, where the pid and everything is set */
- s4u::Actor::on_creation(actor->iface());
+ s4u::Actor::on_creation(*actor->ciface());
return ActorImplPtr(actor);
}
namespace kernel {
namespace routing {
-simgrid::xbt::signal<void(NetPoint*)> NetPoint::on_creation;
+simgrid::xbt::signal<void(NetPoint&)> NetPoint::on_creation;
NetPoint::NetPoint(const std::string& name, NetPoint::Type componentType, NetZoneImpl* netzone_p)
: name_(name), component_type_(componentType), englobing_zone_(netzone_p)
else
id_ = static_cast<decltype(id_)>(-1);
simgrid::s4u::Engine::get_instance()->netpoint_register(this);
- simgrid::kernel::routing::NetPoint::on_creation(this);
+ simgrid::kernel::routing::NetPoint::on_creation(*this);
}
}
}
msg_global->task_copy_callback = nullptr;
msg_global->process_data_cleanup = nullptr;
- simgrid::s4u::Actor::on_creation.connect([](simgrid::s4u::ActorPtr actor) {
+ simgrid::s4u::Actor::on_creation.connect([](simgrid::s4u::Actor& actor) {
XBT_DEBUG("creating the extension to store user data");
- actor->extension_set(new simgrid::msg::ActorUserData());
+ actor.extension_set(new simgrid::msg::ActorUserData());
});
- simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::ActorPtr actor) {
+ simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::Actor const& actor) {
// free the data if a function was provided
- void* userdata = actor->extension<simgrid::msg::ActorUserData>()->get_user_data();
+ void* userdata = actor.extension<simgrid::msg::ActorUserData>()->get_user_data();
if (userdata && msg_global->process_data_cleanup) {
msg_global->process_data_cleanup(userdata);
}
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_process, msg, "Logging specific to MSG (process)");
-std::string instr_pid(msg_process_t proc)
+std::string instr_pid(simgrid::s4u::Actor const& proc)
{
- return std::string(proc->get_name()) + "-" + std::to_string(proc->get_pid());
+ return std::string(proc.get_name()) + "-" + std::to_string(proc.get_pid());
}
/******************************** Process ************************************/
s4u::CommPtr Task::send_async(const std::string& alias, void_f_pvoid_t cleanup, bool detached)
{
if (TRACE_actor_is_enabled()) {
- container_t process_container = simgrid::instr::Container::by_name(instr_pid(MSG_process_self()));
+ container_t process_container = simgrid::instr::Container::by_name(instr_pid(*MSG_process_self()));
std::string key = std::string("p") + std::to_string(get_id());
simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->start_event(process_container, "SR", key);
}
}
if (TRACE_actor_is_enabled() && ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) {
- container_t process_container = simgrid::instr::Container::by_name(instr_pid(MSG_process_self()));
+ container_t process_container = simgrid::instr::Container::by_name(instr_pid(*MSG_process_self()));
std::string key = std::string("p") + std::to_string((*task)->get_id());
simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->end_event(process_container, "SR", key);
namespace vm {
class DirtyPageTrackingExt {
bool dp_tracking_ = false;
- std::map<kernel::activity::ExecImplPtr, double> dp_objs_;
+ std::map<kernel::activity::ExecImpl const*, double> dp_objs_;
double dp_updated_by_deleted_tasks_ = 0.0;
// Percentage of pages that get dirty compared to netspeed [0;1] bytes per 1 flop execution
double dp_intensity_ = 0.0;
void start_tracking();
void stop_tracking() { dp_tracking_ = false; }
bool is_tracking() { return dp_tracking_; }
- void track(kernel::activity::ExecImplPtr exec, double amount) { dp_objs_.insert({exec, amount}); }
- void untrack(kernel::activity::ExecImplPtr exec) { dp_objs_.erase(exec); }
- double get_stored_remains(kernel::activity::ExecImplPtr exec) { return dp_objs_.at(exec); }
+ void track(kernel::activity::ExecImpl const* exec, double amount) { dp_objs_.insert({exec, amount}); }
+ void untrack(kernel::activity::ExecImpl const* exec) { dp_objs_.erase(exec); }
+ double get_stored_remains(kernel::activity::ExecImpl const* exec) { return dp_objs_.at(exec); }
void update_dirty_page_count(double delta) { dp_updated_by_deleted_tasks_ += delta; }
double computed_flops_lookup();
double get_intensity() { return dp_intensity_; }
} // namespace vm
} // namespace simgrid
-static void on_virtual_machine_creation(simgrid::vm::VirtualMachineImpl* vm)
+static void on_virtual_machine_creation(simgrid::vm::VirtualMachineImpl& vm)
{
- vm->extension_set<simgrid::vm::DirtyPageTrackingExt>(new simgrid::vm::DirtyPageTrackingExt());
+ vm.extension_set<simgrid::vm::DirtyPageTrackingExt>(new simgrid::vm::DirtyPageTrackingExt());
}
-static void on_exec_creation(simgrid::kernel::activity::ExecImplPtr exec)
+static void on_exec_creation(simgrid::kernel::activity::ExecImpl const& exec)
{
- simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec->host_);
+ simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec.host_);
if (vm == nullptr)
return;
if (vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->is_tracking()) {
- vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->track(exec, exec->get_remaining());
+ vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->track(&exec, exec.get_remaining());
} else {
- vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->track(exec, 0.0);
+ vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->track(&exec, 0.0);
}
}
-static void on_exec_completion(simgrid::kernel::activity::ExecImplPtr exec)
+static void on_exec_completion(simgrid::kernel::activity::ExecImpl const& exec)
{
- simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec->host_);
+ simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(exec.host_);
if (vm == nullptr)
return;
/* If we are in the middle of dirty page tracking, we record how much computation has been done until now, and keep
* the information for the lookup_() function that will called soon. */
if (vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->is_tracking()) {
- double delta = vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->get_stored_remains(exec);
+ double delta = vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->get_stored_remains(&exec);
vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->update_dirty_page_count(delta);
}
- vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->untrack(exec);
+ vm->get_impl()->extension<simgrid::vm::DirtyPageTrackingExt>()->untrack(&exec);
}
void sg_vm_dirty_page_tracking_init()
explicit Adagio(simgrid::s4u::Host* ptr)
: Governor(ptr), rates(100, std::vector<double>(ptr->get_pstate_count(), 0.0))
{
- simgrid::smpi::plugin::ampi::on_iteration_in.connect([this](simgrid::s4u::ActorPtr actor) {
+ simgrid::smpi::plugin::ampi::on_iteration_in.connect([this](simgrid::s4u::Actor const& actor) {
// Every instance of this class subscribes to this event, so one per host
// This means that for any actor, all 'hosts' are normally notified of these
// changes, even those who don't currently run the actor 'proc_id'.
// -> Let's check if this signal call is for us!
- if (get_host() == actor->get_host()) {
+ if (get_host() == actor.get_host()) {
iteration_running = true;
}
});
- simgrid::smpi::plugin::ampi::on_iteration_out.connect([this](simgrid::s4u::ActorPtr actor) {
- if (get_host() == actor->get_host()) {
+ simgrid::smpi::plugin::ampi::on_iteration_out.connect([this](simgrid::s4u::Actor const& actor) {
+ if (get_host() == actor.get_host()) {
iteration_running = false;
task_id = 0;
}
});
- simgrid::kernel::activity::ExecImpl::on_creation.connect([this](simgrid::kernel::activity::ExecImplPtr activity) {
- if (activity->host_ == get_host())
- pre_task();
- });
- simgrid::kernel::activity::ExecImpl::on_completion.connect([this](simgrid::kernel::activity::ExecImplPtr activity) {
- // For more than one host (not yet supported), we can access the host via
- // simcalls_.front()->issuer->iface()->get_host()
- if (activity->host_ == get_host() && iteration_running) {
- comp_timer += activity->surf_action_->get_finish_time() - activity->surf_action_->get_start_time();
- }
- });
+ simgrid::kernel::activity::ExecImpl::on_creation.connect(
+ [this](simgrid::kernel::activity::ExecImpl const& activity) {
+ if (activity.host_ == get_host())
+ pre_task();
+ });
+ simgrid::kernel::activity::ExecImpl::on_completion.connect(
+ [this](simgrid::kernel::activity::ExecImpl const& activity) {
+ // For more than one host (not yet supported), we can access the host via
+ // simcalls_.front()->issuer->iface()->get_host()
+ if (activity.host_ == get_host() && iteration_running) {
+ comp_timer += activity.surf_action_->get_finish_time() - activity.surf_action_->get_start_time();
+ }
+ });
// FIXME I think that this fires at the same time for all hosts, so when the src sends something,
// the dst will be notified even though it didn't even arrive at the recv yet
simgrid::s4u::Link::on_communicate.connect(
- [this](kernel::resource::NetworkAction*, s4u::Host* src, s4u::Host* dst) {
+ [this](kernel::resource::NetworkAction const&, s4u::Host* src, s4u::Host* dst) {
if ((get_host() == src || get_host() == dst) && iteration_running) {
post_task();
}
host.extension_set(new HostEnergy(&host));
}
-static void on_action_state_change(simgrid::surf::CpuAction* action,
+static void on_action_state_change(simgrid::surf::CpuAction const& action,
simgrid::kernel::resource::Action::State /*previous*/)
{
- for (simgrid::surf::Cpu* const& cpu : action->cpus()) {
+ for (simgrid::surf::Cpu* const& cpu : action.cpus()) {
simgrid::s4u::Host* host = cpu->get_host();
if (host != nullptr) {
/* This callback is fired either when the host changes its state (on/off) ("onStateChange") or its speed
* (because the user changed the pstate, or because of external trace events) ("onSpeedChange") */
-static void on_host_change(simgrid::s4u::Host& host)
+static void on_host_change(simgrid::s4u::Host const& host)
{
- if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
+ if (dynamic_cast<simgrid::s4u::VirtualMachine const*>(&host)) // Ignore virtual machines
return;
HostEnergy* host_energy = host.extension<HostEnergy>();
host_energy->update();
}
-static void on_host_destruction(simgrid::s4u::Host& host)
+static void on_host_destruction(simgrid::s4u::Host const& host)
{
- if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
+ if (dynamic_cast<simgrid::s4u::VirtualMachine const*>(&host)) // Ignore virtual machines
return;
XBT_INFO("Energy consumption of host %s: %f Joules", host.get_cname(),
// 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::kernel::activity::ExecImpl::on_creation.connect([](simgrid::kernel::activity::ExecImplPtr activity){
- if (activity->host_ != nullptr) { // We only run on one host
- simgrid::s4u::Host* host = activity->host_;
+ simgrid::kernel::activity::ExecImpl::on_creation.connect([](simgrid::kernel::activity::ExecImpl const& activity) {
+ if (activity.host_ != nullptr) { // We only run on one host
+ simgrid::s4u::Host* host = activity.host_;
simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
if (vm != nullptr)
host = vm->get_pm();
/* **************************** events callback *************************** */
/* This callback is fired either when the host changes its state (on/off) or its speed
* (because the user changed the pstate, or because of external trace events) */
-static void on_host_change(simgrid::s4u::Host& host)
+static void on_host_change(simgrid::s4u::Host const& host)
{
- if (dynamic_cast<simgrid::s4u::VirtualMachine*>(&host)) // Ignore virtual machines
+ if (dynamic_cast<simgrid::s4u::VirtualMachine const*>(&host)) // Ignore virtual machines
return;
host.extension<HostLoad>()->update();
host.extension_set(new HostLoad(&host));
});
- simgrid::kernel::activity::ExecImpl::on_creation.connect([](simgrid::kernel::activity::ExecImplPtr activity){
- if (activity->host_ != nullptr) { // We only run on one host
- simgrid::s4u::Host* host = activity->host_;
+ simgrid::kernel::activity::ExecImpl::on_creation.connect([](simgrid::kernel::activity::ExecImpl& activity) {
+ if (activity.host_ != nullptr) { // We only run on one host
+ simgrid::s4u::Host* host = activity.host_;
simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
if (vm != nullptr)
host = vm->get_pm();
- host->extension<HostLoad>()->add_activity(activity);
+ host->extension<HostLoad>()->add_activity(&activity);
host->extension<HostLoad>()->update(); // If the system was idle until now, we need to update *before*
// this computation starts running so we can keep track of the
// idle time. (Communication operations don't trigger this hook!)
XBT_DEBUG("HostLoad plugin currently does not support executions on several hosts");
}
});
- simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImplPtr activity){
- if (activity->host_ != nullptr) { // We only run on one host
- simgrid::s4u::Host* host = activity->host_;
+ simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImpl const& activity) {
+ if (activity.host_ != nullptr) { // We only run on one host
+ simgrid::s4u::Host* host = activity.host_;
simgrid::s4u::VirtualMachine* vm = dynamic_cast<simgrid::s4u::VirtualMachine*>(host);
if (vm != nullptr)
host = vm->get_pm();
using simgrid::plugin::LinkEnergy;
/* **************************** events callback *************************** */
-static void on_communicate(simgrid::kernel::resource::NetworkAction* action, simgrid::s4u::Host*, simgrid::s4u::Host*)
+static void on_communicate(simgrid::kernel::resource::NetworkAction const& action, simgrid::s4u::Host*,
+ simgrid::s4u::Host*)
{
XBT_DEBUG("onCommunicate is called");
- for (simgrid::kernel::resource::LinkImpl* link : action->links()) {
+ for (simgrid::kernel::resource::LinkImpl* link : action.links()) {
if (link == nullptr)
continue;
simgrid::s4u::Link::on_creation.connect([](simgrid::s4u::Link& link) { link.extension_set(new LinkEnergy(&link)); });
- simgrid::s4u::Link::on_state_change.connect([](simgrid::s4u::Link& link) { link.extension<LinkEnergy>()->update(); });
+ simgrid::s4u::Link::on_state_change.connect(
+ [](simgrid::s4u::Link const& link) { link.extension<LinkEnergy>()->update(); });
- simgrid::s4u::Link::on_destruction.connect([](simgrid::s4u::Link& link) {
+ simgrid::s4u::Link::on_destruction.connect([](simgrid::s4u::Link const& link) {
if (link.get_name() != "__loopback__")
XBT_INFO("Energy consumption of link '%s': %f Joules", link.get_cname(),
link.extension<LinkEnergy>()->get_consumed_energy());
});
- simgrid::s4u::Link::on_communication_state_change.connect(
- [](simgrid::kernel::resource::NetworkAction* action, simgrid::kernel::resource::Action::State /* previous */) {
- for (simgrid::kernel::resource::LinkImpl* link : action->links()) {
- if (link != nullptr)
- link->piface_.extension<LinkEnergy>()->update();
- }
- });
+ simgrid::s4u::Link::on_communication_state_change.connect([](
+ simgrid::kernel::resource::NetworkAction const& action, simgrid::kernel::resource::Action::State /* previous */) {
+ for (simgrid::kernel::resource::LinkImpl* link : action.links()) {
+ if (link != nullptr)
+ link->piface_.extension<LinkEnergy>()->update();
+ }
+ });
simgrid::s4u::Link::on_communicate.connect(&on_communicate);
simgrid::s4u::on_simulation_end.connect(&on_simulation_end);
/*************
* Callbacks *
*************/
-simgrid::xbt::signal<void(VirtualMachineImpl*)> VirtualMachineImpl::on_creation;
-simgrid::xbt::signal<void(VirtualMachineImpl*)> VirtualMachineImpl::on_destruction;
+simgrid::xbt::signal<void(VirtualMachineImpl&)> VirtualMachineImpl::on_creation;
+simgrid::xbt::signal<void(VirtualMachineImpl const&)> VirtualMachineImpl::on_destruction;
/*********
* Model *
*/
const double virt_overhead = 1; // 0.95
-static void host_state_change(s4u::Host& host)
+static void host_state_change(s4u::Host const& host)
{
if (not host.is_on()) { // just turned off.
std::vector<s4u::VirtualMachine*> trash;
}
}
-static s4u::VirtualMachine* get_vm_from_task(kernel::activity::ActivityImplPtr task)
+static s4u::VirtualMachine* get_vm_from_task(kernel::activity::ActivityImpl const& task)
{
- kernel::activity::ExecImpl* exec = dynamic_cast<kernel::activity::ExecImpl*>(task.get());
+ auto* exec = dynamic_cast<kernel::activity::ExecImpl const*>(&task);
return exec != nullptr ? dynamic_cast<s4u::VirtualMachine*>(exec->host_) : nullptr;
}
-static void add_active_task(kernel::activity::ActivityImplPtr task)
+static void add_active_task(kernel::activity::ActivityImpl const& task)
{
s4u::VirtualMachine* vm = get_vm_from_task(task);
if (vm != nullptr) {
}
}
-static void remove_active_task(kernel::activity::ActivityImplPtr task)
+static void remove_active_task(kernel::activity::ActivityImpl const& task)
{
s4u::VirtualMachine* vm = get_vm_from_task(task);
if (vm != nullptr) {
update_action_weight();
XBT_VERB("Create VM(%s)@PM(%s)", piface->get_cname(), physical_host_->get_cname());
- on_creation(this);
+ on_creation(*this);
}
/** @brief A physical host does not disappear in the current SimGrid code, but a VM may disappear during a simulation */
VirtualMachineImpl::~VirtualMachineImpl()
{
- on_destruction(this);
+ on_destruction(*this);
/* I was already removed from the allVms set if the VM was destroyed cleanly */
auto iter = find(allVms_.begin(), allVms_.end(), piface_);
if (iter != allVms_.end())
explicit VirtualMachineImpl(s4u::VirtualMachine* piface, s4u::Host* host, int core_amount, size_t ramsize);
~VirtualMachineImpl();
- /** @brief Callbacks fired after VM creation. Signature: `void(VirtualMachineImpl*)` */
- static xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> on_creation;
- /** @brief Callbacks fired after VM destruction. Signature: `void(VirtualMachineImpl*)` */
- static xbt::signal<void(simgrid::vm::VirtualMachineImpl*)> on_destruction;
+ /** @brief Callbacks fired after VM creation. Signature: `void(VirtualMachineImpl&)` */
+ static xbt::signal<void(simgrid::vm::VirtualMachineImpl&)> on_creation;
+ /** @brief Callbacks fired after VM destruction. Signature: `void(VirtualMachineImpl const&)` */
+ static xbt::signal<void(simgrid::vm::VirtualMachineImpl const&)> on_destruction;
virtual void suspend(kernel::actor::ActorImpl* issuer);
virtual void resume();
}
}
-static void onVirtualMachineShutdown(simgrid::s4u::VirtualMachine& vm)
+static void onVirtualMachineShutdown(simgrid::s4u::VirtualMachine const& vm)
{
if (vm.get_impl()->is_migrating_) {
vm.extension<simgrid::vm::VmMigrationExt>()->rx_->kill();
namespace simgrid {
namespace s4u {
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_start;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_started;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_shutdown;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_suspend;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_resume;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_migration_start;
-simgrid::xbt::signal<void(VirtualMachine&)> VirtualMachine::on_migration_end;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_start;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_started;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_shutdown;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_suspend;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_resume;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_migration_start;
+simgrid::xbt::signal<void(VirtualMachine const&)> VirtualMachine::on_migration_end;
VirtualMachine::VirtualMachine(const std::string& name, s4u::Host* physical_host, int core_amount)
: VirtualMachine(name, physical_host, core_amount, 1024)
namespace simgrid {
namespace s4u {
-xbt::signal<void(ActorPtr)> s4u::Actor::on_creation;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_suspend;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_resume;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_sleep;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_wake_up;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_migration_start;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_migration_end;
-xbt::signal<void(ActorPtr)> s4u::Actor::on_destruction;
+xbt::signal<void(Actor&)> s4u::Actor::on_creation;
+xbt::signal<void(Actor const&)> s4u::Actor::on_suspend;
+xbt::signal<void(Actor const&)> s4u::Actor::on_resume;
+xbt::signal<void(Actor const&)> s4u::Actor::on_sleep;
+xbt::signal<void(Actor const&)> s4u::Actor::on_wake_up;
+xbt::signal<void(Actor const&)> s4u::Actor::on_migration_start;
+xbt::signal<void(Actor const&)> s4u::Actor::on_migration_end;
+xbt::signal<void(Actor const&)> s4u::Actor::on_destruction;
// ***** Actor creation *****
ActorPtr Actor::self()
void Actor::migrate(Host* new_host)
{
- s4u::Actor::on_migration_start(this);
+ s4u::Actor::on_migration_start(*this);
simix::simcall([this, new_host]() {
if (pimpl_->waiting_synchro != nullptr) {
this->pimpl_->set_host(new_host);
});
- s4u::Actor::on_migration_end(this);
+ s4u::Actor::on_migration_end(*this);
}
s4u::Host* Actor::get_host() const
void Actor::suspend()
{
- s4u::Actor::on_suspend(this);
+ s4u::Actor::on_suspend(*this);
simcall_process_suspend(pimpl_);
}
void Actor::resume()
{
simix::simcall([this] { pimpl_->resume(); });
- s4u::Actor::on_resume(this);
+ s4u::Actor::on_resume(*this);
}
bool Actor::is_suspended()
{
if (duration > 0) {
kernel::actor::ActorImpl* actor = SIMIX_process_self();
- Actor::on_sleep(actor->iface());
+ Actor::on_sleep(*actor->ciface());
simcall_process_sleep(duration);
- Actor::on_wake_up(actor->iface());
+ Actor::on_wake_up(*actor->ciface());
}
}
void suspend()
{
kernel::actor::ActorImpl* actor = SIMIX_process_self();
- Actor::on_suspend(actor->iface());
+ Actor::on_suspend(*actor->ciface());
simcall_process_suspend(actor);
}
{
kernel::actor::ActorImpl* self = SIMIX_process_self();
simix::simcall([self] { self->resume(); });
- Actor::on_resume(self->iface());
+ Actor::on_resume(*self->ciface());
}
void exit()
namespace simgrid {
namespace s4u {
-xbt::signal<void(ActorPtr)> Comm::on_sender_start;
-xbt::signal<void(ActorPtr)> Comm::on_receiver_start;
-xbt::signal<void(ActorPtr)> Comm::on_completion;
+xbt::signal<void(Actor const&)> Comm::on_sender_start;
+xbt::signal<void(Actor const&)> Comm::on_receiver_start;
+xbt::signal<void(Actor const&)> Comm::on_completion;
Comm::~Comm()
{
__FUNCTION__);
if (src_buff_ != nullptr) { // Sender side
- on_sender_start(Actor::self());
+ on_sender_start(*Actor::self());
pimpl_ = simcall_comm_isend(sender_, mailbox_->get_impl(), remains_, rate_, src_buff_, src_buff_size_, match_fun_,
clean_fun_, copy_data_function_, user_data_, detached_);
} else if (dst_buff_ != nullptr) { // Receiver side
xbt_assert(not detached_, "Receive cannot be detached");
- on_receiver_start(Actor::self());
+ on_receiver_start(*Actor::self());
pimpl_ = simcall_comm_irecv(receiver_, mailbox_->get_impl(), dst_buff_, &dst_buff_size_, match_fun_,
copy_data_function_, user_data_, rate_);
case State::INITED: // It's not started yet. Do it in one simcall
if (src_buff_ != nullptr) {
- on_sender_start(Actor::self());
+ on_sender_start(*Actor::self());
simcall_comm_send(sender_, mailbox_->get_impl(), remains_, rate_, src_buff_, src_buff_size_, match_fun_,
copy_data_function_, user_data_, timeout);
} else { // Receiver
- on_receiver_start(Actor::self());
+ on_receiver_start(*Actor::self());
simcall_comm_recv(receiver_, mailbox_->get_impl(), dst_buff_, &dst_buff_size_, match_fun_, copy_data_function_,
user_data_, timeout, rate_);
}
case State::STARTED:
simcall_comm_wait(pimpl_, timeout);
- on_completion(Actor::self());
+ on_completion(*Actor::self());
state_ = State::FINISHED;
break;
namespace simgrid {
namespace s4u {
-xbt::signal<void(ActorPtr)> Exec::on_start;
-xbt::signal<void(ActorPtr)> Exec::on_completion;
+xbt::signal<void(Actor const&)> Exec::on_start;
+xbt::signal<void(Actor const&)> Exec::on_completion;
Exec::Exec()
{
start();
simcall_execution_wait(pimpl_);
state_ = State::FINISHED;
- on_completion(Actor::self());
+ on_completion(*Actor::self());
return this;
}
boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->start(flops_amount_, 1. / priority_, bound_);
});
state_ = State::STARTED;
- on_start(Actor::self());
+ on_start(*Actor::self());
return this;
}
boost::static_pointer_cast<kernel::activity::ExecImpl>(pimpl_)->start(hosts_, flops_amounts_, bytes_amounts_);
});
state_ = State::STARTED;
- on_start(Actor::self());
+ on_start(*Actor::self());
return this;
}
double ExecPar::get_remaining_ratio()
namespace s4u {
xbt::signal<void(Host&)> Host::on_creation;
-xbt::signal<void(Host&)> Host::on_destruction;
-xbt::signal<void(Host&)> Host::on_state_change;
-xbt::signal<void(Host&)> Host::on_speed_change;
+xbt::signal<void(Host const&)> Host::on_destruction;
+xbt::signal<void(Host const&)> Host::on_state_change;
+xbt::signal<void(Host const&)> Host::on_speed_change;
Host::Host(const std::string& name) : name_(name)
{
namespace s4u {
xbt::signal<void(Link&)> Link::on_creation;
-xbt::signal<void(Link&)> Link::on_destruction;
-xbt::signal<void(Link&)> Link::on_state_change;
-xbt::signal<void(Link&)> Link::on_bandwidth_change;
-xbt::signal<void(kernel::resource::NetworkAction*, Host* src, Host* dst)> Link::on_communicate;
-xbt::signal<void(kernel::resource::NetworkAction*, kernel::resource::Action::State)>
+xbt::signal<void(Link const&)> Link::on_destruction;
+xbt::signal<void(Link const&)> Link::on_state_change;
+xbt::signal<void(Link const&)> Link::on_bandwidth_change;
+xbt::signal<void(kernel::resource::NetworkAction&, Host* src, Host* dst)> Link::on_communicate;
+xbt::signal<void(kernel::resource::NetworkAction&, kernel::resource::Action::State)>
Link::on_communication_state_change;
Link* Link::by_name(const std::string& name)
xbt::signal<void(bool symmetrical, kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst,
kernel::routing::NetPoint* gw_src, kernel::routing::NetPoint* gw_dst,
- std::vector<kernel::resource::LinkImpl*>& link_list)>
+ std::vector<kernel::resource::LinkImpl*> const& link_list)>
NetZone::on_route_creation;
-xbt::signal<void(NetZone&)> NetZone::on_creation;
-xbt::signal<void(NetZone&)> NetZone::on_seal;
+xbt::signal<void(NetZone const&)> NetZone::on_creation;
+xbt::signal<void(NetZone const&)> NetZone::on_seal;
NetZone::NetZone(kernel::routing::NetZoneImpl* impl) : pimpl_(impl) {}
namespace s4u {
xbt::signal<void(Storage&)> Storage::on_creation;
-xbt::signal<void(Storage&)> Storage::on_destruction;
-xbt::signal<void(Storage&)> Storage::on_state_change;
+xbt::signal<void(Storage const&)> Storage::on_destruction;
+xbt::signal<void(Storage const&)> Storage::on_state_change;
Storage::Storage(const std::string& name, kernel::resource::StorageImpl* pimpl) : pimpl_(pimpl), name_(name)
{
sg_platf_init();
simgrid::s4u::on_platform_created.connect(surf_presolve);
- simgrid::s4u::Storage::on_creation.connect([](simgrid::s4u::Storage& storage) {
+ simgrid::s4u::Storage::on_creation.connect([](simgrid::s4u::Storage const& storage) {
sg_storage_t s = simgrid::s4u::Storage::by_name(storage.get_name());
xbt_assert(s != nullptr, "Storage not found for name %s", storage.get_cname());
});
std::unordered_map<std::string, double> location2speedup;
-static std::map</*process_id*/ simgrid::s4u::ActorPtr, simgrid::smpi::ActorExt*> process_data;
+static std::map</*process_id*/ simgrid::s4u::Actor const*, simgrid::smpi::ActorExt*> process_data;
int process_count = 0;
static int smpi_exit_status = 0;
int smpi_universe_size = 0;
if (me == nullptr) // This happens sometimes (eg, when linking against NS3 because it pulls openMPI...)
return nullptr;
- return process_data.at(me);
+ return process_data.at(me.get());
}
simgrid::smpi::ActorExt* smpi_process_remote(simgrid::s4u::ActorPtr actor)
{
- return process_data.at(actor);
+ return process_data.at(actor.get());
}
MPI_Comm smpi_process_comm_self(){
// Called either directly from the user code, or from the code called by smpirun
void SMPI_init(){
- simgrid::s4u::Actor::on_creation.connect([](simgrid::s4u::ActorPtr actor) {
- if (not actor->is_daemon()) {
- process_data.insert({actor, new simgrid::smpi::ActorExt(actor, nullptr)});
+ simgrid::s4u::Actor::on_creation.connect([](simgrid::s4u::Actor& actor) {
+ if (not actor.is_daemon()) {
+ process_data.insert({&actor, new simgrid::smpi::ActorExt(&actor, nullptr)});
}
});
- simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::ActorPtr actor) {
- auto it = process_data.find(actor);
+ simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::Actor const& actor) {
+ auto it = process_data.find(&actor);
if (it != process_data.end()) {
delete it->second;
process_data.erase(it);
namespace smpi {
namespace plugin {
namespace ampi {
- simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_iteration_in;
- simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_iteration_out;
+simgrid::xbt::signal<void(simgrid::s4u::Actor const&)> on_iteration_in;
+simgrid::xbt::signal<void(simgrid::s4u::Actor const&)> on_iteration_out;
}
}
}
namespace smpi {
namespace plugin {
namespace ampi {
- extern simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_iteration_out;
- extern simgrid::xbt::signal<void(simgrid::s4u::ActorPtr)> on_iteration_in;
+extern simgrid::xbt::signal<void(simgrid::s4u::Actor const&)> on_iteration_out;
+extern simgrid::xbt::signal<void(simgrid::s4u::Actor const&)> on_iteration_in;
}
}
}
{
CHECK_ACTION_PARAMS(action, 0, 0)
TRACE_Iteration_in(simgrid::s4u::this_actor::get_pid(), nullptr);
- simgrid::smpi::plugin::ampi::on_iteration_in(MPI_COMM_WORLD->group()->actor(std::stol(action[0])));
+ simgrid::smpi::plugin::ampi::on_iteration_in(*MPI_COMM_WORLD->group()->actor(std::stol(action[0])));
}
XBT_PRIVATE void action_iteration_out(simgrid::xbt::ReplayAction& action);
{
CHECK_ACTION_PARAMS(action, 0, 0)
TRACE_Iteration_out(simgrid::s4u::this_actor::get_pid(), nullptr);
- simgrid::smpi::plugin::ampi::on_iteration_out(MPI_COMM_WORLD->group()->actor(std::stol(action[0])));
+ simgrid::smpi::plugin::ampi::on_iteration_out(*MPI_COMM_WORLD->group()->actor(std::stol(action[0])));
}
}
}
static bool done = false;
if (!done) {
done = true;
- simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImplPtr activity){
- simgrid::smpi::plugin::lb.record_actor_computation(activity->simcalls_.front()->issuer->iface(), activity->surf_action_->get_cost());
+ simgrid::kernel::activity::ExecImpl::on_completion.connect([](simgrid::kernel::activity::ExecImpl const& activity) {
+ simgrid::smpi::plugin::lb.record_actor_computation(activity.simcalls_.front()->issuer->iface(),
+ activity.surf_action_->get_cost());
});
xbt_replay_action_register(
s4u::Storage::on_state_change(this->piface_);
}
}
-xbt::signal<void(StorageAction*, kernel::resource::Action::State, kernel::resource::Action::State)>
+xbt::signal<void(StorageAction const&, kernel::resource::Action::State, kernel::resource::Action::State)>
StorageAction::on_state_change;
/**********
{
Action::State old = get_state();
Action::set_state(state);
- on_state_change(this, old, state);
+ on_state_change(*this, old, state);
}
} // namespace resource
} // namespace kernel
* @details Callback functions have the following signature: `void(StorageAction& action,
* simgrid::kernel::resource::Action::State old, simgrid::kernel::resource::Action::State current)`
*/
- static xbt::signal<void(StorageAction*, Action::State, Action::State)> on_state_change;
+ static xbt::signal<void(StorageAction const&, Action::State, Action::State)> on_state_change;
/**
* @brief StorageAction constructor
set_last_value(get_variable()->get_value());
}
-simgrid::xbt::signal<void(simgrid::surf::CpuAction*, kernel::resource::Action::State)> CpuAction::on_state_change;
+simgrid::xbt::signal<void(simgrid::surf::CpuAction const&, kernel::resource::Action::State)> CpuAction::on_state_change;
void CpuAction::suspend(){
Action::State previous = get_state();
- on_state_change(this, previous);
+ on_state_change(*this, previous);
Action::suspend();
}
void CpuAction::resume(){
Action::State previous = get_state();
- on_state_change(this, previous);
+ on_state_change(*this, previous);
Action::resume();
}
{
Action::State previous = get_state();
Action::set_state(state);
- on_state_change(this, previous);
+ on_state_change(*this, previous);
}
/** @brief returns a list of all CPUs that this action is using */
class XBT_PUBLIC CpuAction : public simgrid::kernel::resource::Action {
public:
/** @brief Signal emitted when the action state changes (ready/running/done, etc)
- * Signature: `void(CpuAction *action, simgrid::kernel::resource::Action::State previous)`
+ * Signature: `void(CpuAction const& action, simgrid::kernel::resource::Action::State previous)`
*/
- static simgrid::xbt::signal<void(simgrid::surf::CpuAction*, simgrid::kernel::resource::Action::State)> on_state_change;
+ static simgrid::xbt::signal<void(simgrid::surf::CpuAction const&, simgrid::kernel::resource::Action::State)>
+ on_state_change;
CpuAction(simgrid::kernel::resource::Model * model, double cost, bool failed) : Action(model, cost, failed) {}
CpuAction(simgrid::kernel::resource::Model * model, double cost, bool failed, kernel::lmm::Variable* var)
}
XBT_OUT();
- simgrid::s4u::Link::on_communicate(action, src, dst);
+ simgrid::s4u::Link::on_communicate(*action, src, dst);
return action;
}
{
NetworkConstantAction* action = new NetworkConstantAction(this, size, sg_latency_factor);
- simgrid::s4u::Link::on_communicate(action, src, dst);
+ simgrid::s4u::Link::on_communicate(*action, src, dst);
return action;
}
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
-static void IB_create_host_callback(simgrid::s4u::Host& host){
+static void IB_create_host_callback(simgrid::s4u::Host const& host)
+{
using simgrid::kernel::resource::IBNode;
using simgrid::kernel::resource::NetworkIBModel;
((NetworkIBModel*)surf_network_model)->active_nodes.insert({host.get_name(), act});
}
-static void IB_action_state_changed_callback(simgrid::kernel::resource::NetworkAction* action,
+static void IB_action_state_changed_callback(simgrid::kernel::resource::NetworkAction& action,
simgrid::kernel::resource::Action::State /*previous*/)
{
using simgrid::kernel::resource::IBNode;
using simgrid::kernel::resource::NetworkIBModel;
- if (action->get_state() != simgrid::kernel::resource::Action::State::FINISHED)
+ if (action.get_state() != simgrid::kernel::resource::Action::State::FINISHED)
return;
- std::pair<IBNode*,IBNode*> pair = ((NetworkIBModel*)surf_network_model)->active_comms[action];
- XBT_DEBUG("IB callback - action %p finished", action);
-
- ((NetworkIBModel*)surf_network_model)->updateIBfactors(action, pair.first, pair.second, 1);
+ std::pair<IBNode*, IBNode*> pair = ((NetworkIBModel*)surf_network_model)->active_comms[&action];
+ XBT_DEBUG("IB callback - action %p finished", &action);
- ((NetworkIBModel*)surf_network_model)->active_comms.erase(action);
+ ((NetworkIBModel*)surf_network_model)->updateIBfactors(&action, pair.first, pair.second, 1);
+ ((NetworkIBModel*)surf_network_model)->active_comms.erase(&action);
}
-static void IB_action_init_callback(simgrid::kernel::resource::NetworkAction* action, simgrid::s4u::Host* src,
+static void IB_action_init_callback(simgrid::kernel::resource::NetworkAction& action, simgrid::s4u::Host* src,
simgrid::s4u::Host* dst)
{
simgrid::kernel::resource::NetworkIBModel* ibModel = (simgrid::kernel::resource::NetworkIBModel*)surf_network_model;
throw std::out_of_range(std::string("Could not find '") + dst->get_cname() + "' active comms !");
}
- ibModel->active_comms[action]=std::make_pair(act_src, act_dst);
+ ibModel->active_comms[&action] = std::make_pair(act_src, act_dst);
- ibModel->updateIBfactors(action, act_src, act_dst, 0);
+ ibModel->updateIBfactors(&action, act_src, act_dst, 0);
}
/*********
Action::State previous = get_state();
Action::set_state(state);
if (previous != state) // Trigger only if the state changed
- s4u::Link::on_communication_state_change(this, previous);
+ s4u::Link::on_communication_state_change(*this, previous);
}
/** @brief returns a list of all Links that this action is using */
* Callbacks *
*************/
-static void clusterCreation_cb(simgrid::kernel::routing::ClusterCreationArgs* cluster)
+static void clusterCreation_cb(simgrid::kernel::routing::ClusterCreationArgs const& cluster)
{
- for (int const& i : *cluster->radicals) {
+ for (int const& i : *cluster.radicals) {
// Routers don't create a router on the other end of the private link by themselves.
// We just need this router to be given an ID so we create a temporary NetPointNS3 so that it gets one
NetPointNs3* host_dst = new NetPointNs3();
// Create private link
- std::string host_id = cluster->prefix + std::to_string(i) + cluster->suffix;
+ std::string host_id = cluster.prefix + std::to_string(i) + cluster.suffix;
NetPointNs3* host_src = simgrid::s4u::Host::by_name(host_id)->pimpl_netpoint->extension<NetPointNs3>();
xbt_assert(host_src, "Cannot find a NS3 host of name %s", host_id.c_str());
// Any NS3 route is symmetrical
- ns3_add_link(host_src, host_dst, cluster->bw, cluster->lat);
+ ns3_add_link(host_src, host_dst, cluster.bw, cluster.lat);
delete host_dst;
}
//Create link backbone
- ns3_add_cluster(cluster->id.c_str(), cluster->bb_bw, cluster->bb_lat);
+ ns3_add_cluster(cluster.id.c_str(), cluster.bb_bw, cluster.bb_lat);
}
static void routeCreation_cb(bool symmetrical, simgrid::kernel::routing::NetPoint* src,
simgrid::kernel::routing::NetPoint* dst, simgrid::kernel::routing::NetPoint* gw_src,
simgrid::kernel::routing::NetPoint* gw_dst,
- std::vector<simgrid::kernel::resource::LinkImpl*>& link_list)
+ std::vector<simgrid::kernel::resource::LinkImpl*> const& link_list)
{
if (link_list.size() == 1) {
simgrid::kernel::resource::LinkNS3* link = static_cast<simgrid::kernel::resource::LinkNS3*>(link_list[0]);
ns3_initialize(ns3_tcp_model.get().c_str());
- simgrid::kernel::routing::NetPoint::on_creation.connect([](simgrid::kernel::routing::NetPoint* pt) {
- pt->extension_set<NetPointNs3>(new NetPointNs3());
- XBT_VERB("SimGrid's %s is known as node %d within NS3", pt->get_cname(), pt->extension<NetPointNs3>()->node_num);
+ simgrid::kernel::routing::NetPoint::on_creation.connect([](simgrid::kernel::routing::NetPoint& pt) {
+ pt.extension_set<NetPointNs3>(new NetPointNs3());
+ XBT_VERB("SimGrid's %s is known as node %d within NS3", pt.get_cname(), pt.extension<NetPointNs3>()->node_num);
});
simgrid::surf::on_cluster.connect(&clusterCreation_cb);
port_number++;
xbt_assert(port_number <= 65000, "Too many connections! Port number is saturated.");
- s4u::Link::on_communicate(this, src, dst);
+ s4u::Link::on_communicate(*this, src, dst);
}
void NetworkNS3Action::suspend() {
namespace simgrid {
namespace surf {
-simgrid::xbt::signal<void(kernel::routing::ClusterCreationArgs*)> on_cluster;
+simgrid::xbt::signal<void(kernel::routing::ClusterCreationArgs const&)> on_cluster;
}
}
XBT_DEBUG("</AS>");
sg_platf_new_Zone_seal();
- simgrid::surf::on_cluster(cluster);
+ simgrid::surf::on_cluster(*cluster);
delete cluster->radicals;
}
namespace simgrid {
namespace surf {
-extern XBT_PRIVATE simgrid::xbt::signal<void(kernel::routing::ClusterCreationArgs*)> on_cluster;
+extern XBT_PRIVATE simgrid::xbt::signal<void(kernel::routing::ClusterCreationArgs const&)> on_cluster;
}
}
