-/* Copyright (c) 2006-2022. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2023. 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. */
#include <simgrid/s4u/Exec.hpp>
#include <simgrid/s4u/VirtualMachine.hpp>
-#include "src/include/mc/mc.h"
#include "src/kernel/EngineImpl.hpp"
#include "src/kernel/actor/ActorImpl.hpp"
+#include "src/kernel/resource/HostImpl.hpp"
+#include "src/mc/mc.h"
#include "src/mc/mc_replay.hpp"
-#include "src/surf/HostImpl.hpp"
#include <algorithm>
{
kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
const kernel::actor::ActorImpl* target = pimpl_;
- kernel::actor::simcall_blocking([issuer, target, timeout] {
- if (target->wannadie()) {
- // The joined actor is already finished, just wake up the issuer right away
- issuer->simcall_answer();
- } else {
- kernel::activity::ActivityImplPtr sync = issuer->join(target, timeout);
- sync->register_simcall(&issuer->simcall_);
- }
- });
+ kernel::actor::ActorJoinSimcall observer{issuer, get_impl(), timeout};
+
+ kernel::actor::simcall_blocking(
+ [issuer, target, timeout] {
+ if (target->wannadie()) {
+ // The joined actor is already finished, just wake up the issuer right away
+ issuer->simcall_answer();
+ } else {
+ kernel::activity::ActivityImplPtr sync = issuer->join(target, timeout);
+ sync->register_simcall(&issuer->simcall_);
+ }
+ },
+ &observer);
}
Actor* Actor::set_auto_restart(bool autorestart)
});
s4u::Actor::on_host_change(*this, *previous_location);
+ s4u::Actor::on_this_host_change(*this, *previous_location);
}
s4u::Host* Actor::get_host() const
return self == nullptr || kernel::EngineImpl::get_instance()->is_maestro(self);
}
-const simgrid::xbt::string& Actor::get_name() const
+const std::string& Actor::get_name() const
{
return this->pimpl_->get_name();
}
kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
kernel::actor::ActorImpl* target = pimpl_;
s4u::Actor::on_suspend(*this);
+ s4u::Actor::on_this_suspend(*this);
kernel::actor::simcall_blocking([issuer, target]() {
target->suspend();
if (target != issuer) {
{
kernel::actor::simcall_answered([this] { pimpl_->resume(); });
s4u::Actor::on_resume(*this);
+ s4u::Actor::on_this_resume(*this);
}
bool Actor::is_suspended() const
if (duration <= 0) /* that's a no-op */
return;
- if (duration < sg_surf_precision) {
+ if (duration < sg_precision_timing) {
static unsigned int warned = 0; // At most 20 such warnings
warned++;
if (warned <= 20)
XBT_INFO("The parameter to sleep_for() is smaller than the SimGrid numerical accuracy (%g < %g). "
"Please refer to https://simgrid.org/doc/latest/Configuring_SimGrid.html#numerical-precision",
- duration, sg_surf_precision);
+ duration, sg_precision_timing);
if (warned == 20)
XBT_VERB("(further warnings about the numerical accuracy of sleep_for() will be omitted).");
}
kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
- Actor::on_sleep(*issuer->get_ciface());
+ kernel::actor::ActorSleepSimcall observer(issuer);
- kernel::actor::simcall_blocking([issuer, duration]() {
- if (MC_is_active() || MC_record_replay_is_active()) {
- MC_process_clock_add(issuer, duration);
- issuer->simcall_answer();
- return;
- }
- kernel::activity::ActivityImplPtr sync = issuer->sleep(duration);
- sync->register_simcall(&issuer->simcall_);
- });
+ Actor::on_sleep(*issuer->get_ciface());
+ issuer->get_ciface()->on_this_sleep(*issuer->get_ciface());
+
+ kernel::actor::simcall_blocking(
+ [issuer, duration]() {
+ if (MC_is_active() || MC_record_replay_is_active()) {
+ // MC_process_clock_add(issuer, duration); // BUG: Makes the exploration loop
+ issuer->simcall_answer();
+ } else {
+ kernel::activity::ActivityImplPtr sync = issuer->sleep(duration);
+ sync->register_simcall(&issuer->simcall_);
+ }
+ },
+ &observer);
Actor::on_wake_up(*issuer->get_ciface());
+ issuer->get_ciface()->on_this_wake_up(*issuer->get_ciface());
}
void yield()
void execute(double flops, double priority)
{
- exec_init(flops)->set_priority(priority)->vetoable_start()->wait();
+ exec_init(flops)->set_priority(priority)->start()->wait();
}
void parallel_execute(const std::vector<s4u::Host*>& hosts, const std::vector<double>& flops_amounts,
ExecPtr exec_async(double flops)
{
ExecPtr res = exec_init(flops);
- res->vetoable_start();
+ res->start();
return res;
}
aid_t get_pid()
{
- return simgrid::kernel::actor::ActorImpl::self()->get_pid();
+ const auto* self = simgrid::kernel::actor::ActorImpl::self();
+ return self ? self->get_pid() : 0;
}
aid_t get_ppid()
const char* get_cname()
{
- return simgrid::kernel::actor::ActorImpl::self()->get_cname();
+ const auto* self = simgrid::kernel::actor::ActorImpl::self();
+ return self ? self->get_cname() : nullptr;
}
Host* get_host()
{
kernel::actor::ActorImpl* self = simgrid::kernel::actor::ActorImpl::self();
s4u::Actor::on_suspend(*self->get_ciface());
+ self->get_ciface()->on_this_suspend(*self->get_ciface());
kernel::actor::simcall_blocking([self] { self->suspend(); });
}
const std::unordered_map<std::string, std::string>* props = actor->get_properties();
if (props == nullptr)
return nullptr;
- for (auto const& kv : *props) {
- xbt_dict_set(as_dict, kv.first.c_str(), xbt_strdup(kv.second.c_str()));
+ for (auto const& [key, value] : *props) {
+ xbt_dict_set(as_dict, key.c_str(), xbt_strdup(value.c_str()));
}
return as_dict;
}
xbt_dict_free(&properties);
/* Let's create the actor: SIMIX may decide to start it right now, even before returning the flow control to us */
- smx_actor_t actor = nullptr;
+ simgrid::kernel::actor::ActorImpl* actor = nullptr;
try {
actor = simgrid::kernel::actor::ActorImpl::attach(name, data, host).get();
actor->set_properties(props);
const char* sg_actor_self_get_name()
{
+ if (simgrid::s4u::Actor::is_maestro())
+ return "maestro";
return simgrid::s4u::this_actor::get_cname();
}