static void victimA_fun()
{
- simgrid::s4u::this_actor::onExit(on_exit, nullptr);
+ simgrid::s4u::this_actor::on_exit(on_exit, nullptr);
XBT_INFO("Hello!");
XBT_INFO("Suspending myself");
simgrid::s4u::this_actor::suspend(); /* - Start by suspending itself */
explicit sleeper(std::vector<std::string> /*args*/)
{
XBT_INFO("Hello! I go to sleep.");
- simgrid::s4u::this_actor::onExit(my_onexit, NULL);
+ simgrid::s4u::this_actor::on_exit(my_onexit, NULL);
simgrid::s4u::this_actor::sleep_for(10);
}
simgrid::s4u::this_actor::migrate(first);
simgrid::s4u::this_actor::execute(flopAmount);
- XBT_INFO("I wake up on %s. Let's suspend a bit", simgrid::s4u::this_actor::getHost()->get_cname());
+ XBT_INFO("I wake up on %s. Let's suspend a bit", simgrid::s4u::this_actor::get_host()->get_cname());
simgrid::s4u::this_actor::suspend();
- XBT_INFO("I wake up on %s", simgrid::s4u::this_actor::getHost()->get_cname());
+ XBT_INFO("I wake up on %s", simgrid::s4u::this_actor::get_host()->get_cname());
XBT_INFO("Done");
}
static void dream_master()
{
XBT_INFO("Let's create a lazy guy."); /* - Create a lazy_guy process */
- simgrid::s4u::ActorPtr lazy = simgrid::s4u::Actor::create("Lazy", simgrid::s4u::this_actor::getHost(), lazy_guy);
+ simgrid::s4u::ActorPtr lazy = simgrid::s4u::Actor::create("Lazy", simgrid::s4u::this_actor::get_host(), lazy_guy);
XBT_INFO("Let's wait a little bit...");
simgrid::s4u::this_actor::sleep_for(10); /* - Wait for 10 seconds */
XBT_INFO("Let's wake the lazy guy up! >:) BOOOOOUUUHHH!!!!");
}
xbt_assert(deadline > 0, "Wrong deadline supplied");
- stream = simgrid::s4u::this_actor::getHost()->extension<HostBittorrent>()->getStream();
+ stream = simgrid::s4u::this_actor::get_host()->extension<HostBittorrent>()->getStream();
if (args.size() == 4 && args[3] == "1") {
bitfield_ = (1U << FILE_PIECES) - 1U;
}
xbt_assert(deadline > 0, "Wrong deadline supplied");
- stream = simgrid::s4u::this_actor::getHost()->extension<HostBittorrent>()->getStream();
+ stream = simgrid::s4u::this_actor::get_host()->extension<HostBittorrent>()->getStream();
mailbox = simgrid::s4u::Mailbox::byName(TRACKER_MAILBOX);
simgrid::s4u::Mailbox::byName(args[0])->put(payload, 1);
/* - ... then wait for the (large) pong */
double* sender_time =
- static_cast<double*>(simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::getHost()->get_name())->get());
+ static_cast<double*>(simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::get_host()->get_name())->get());
double communication_time = simgrid::s4u::Engine::getClock() - *sender_time;
XBT_INFO("Task received : large communication (bandwidth bound)");
/* - Receive the (small) ping first ....*/
double* sender_time =
- static_cast<double*>(simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::getHost()->get_name())->get());
+ static_cast<double*>(simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::get_host()->get_name())->get());
double communication_time = simgrid::s4u::Engine::getClock() - *sender_time;
XBT_INFO("Task received : small communication (latency bound)");
XBT_INFO(" Ping time (latency bound) %f", communication_time);
if (speed > 0) {
double new_bound = (speed / 10) * i;
XBT_INFO("set bound of VM1 to %f", new_bound);
- static_cast<simgrid::s4u::VirtualMachine*>(simgrid::s4u::this_actor::getHost())->setBound(new_bound);
+ static_cast<simgrid::s4u::VirtualMachine*>(simgrid::s4u::this_actor::get_host())->setBound(new_bound);
}
simgrid::s4u::this_actor::sleep_for(100);
double exec_remain_now = exec->get_remaining();
double flops_per_sec = exec_remain_prev - exec_remain_now;
- XBT_INFO("%s@%s: %.0f flops/s", name, simgrid::s4u::this_actor::getHost()->get_cname(), flops_per_sec / 100);
+ XBT_INFO("%s@%s: %.0f flops/s", name, simgrid::s4u::this_actor::get_host()->get_cname(), flops_per_sec / 100);
exec_remain_prev = exec_remain_now;
simgrid::s4u::this_actor::sleep_for(1);
}
simgrid::s4u::this_actor::execute(1000000);
double clock_end = simgrid::s4u::Engine::getClock();
- XBT_INFO("%s:%s task executed %g", simgrid::s4u::this_actor::getHost()->get_cname(),
+ XBT_INFO("%s:%s task executed %g", simgrid::s4u::this_actor::get_host()->get_cname(),
simgrid::s4u::this_actor::get_cname(), clock_end - clock_sta);
}
simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::byName(args.at(0));
s_payload* payload = new s_payload;
payload->tx_actor_name = simgrid::s4u::Actor::self()->get_cname();
- payload->tx_host = simgrid::s4u::this_actor::getHost();
+ payload->tx_host = simgrid::s4u::this_actor::get_host();
payload->clock_sta = simgrid::s4u::Engine::getClock();
mbox->put(payload, 1000000);
static void communication_rx_fun(std::vector<std::string> args)
{
const char* actor_name = simgrid::s4u::Actor::self()->get_cname();
- const char* host_name = simgrid::s4u::this_actor::getHost()->get_cname();
+ const char* host_name = simgrid::s4u::this_actor::get_host()->get_cname();
simgrid::s4u::MailboxPtr mbox = simgrid::s4u::Mailbox::byName(args.at(0));
struct s_payload* payload = static_cast<struct s_payload*>(mbox->get());
// initialize my node
id_ = std::stoi(args[1]);
- stream = simgrid::s4u::this_actor::getHost()->extension<HostChord>()->getStream();
+ stream = simgrid::s4u::this_actor::get_host()->extension<HostChord>()->getStream();
mailbox_ = simgrid::s4u::Mailbox::byName(std::to_string(id_));
next_finger_to_fix = 0;
fingers_ = new int[nb_bits];
simgrid::s4u::MailboxPtr answer_to; // mailbox to send an answer to (if any)
explicit ChordMessage(e_message_type_t type)
- : type(type), issuer_host_name(simgrid::s4u::this_actor::getHost()->get_name())
+ : type(type), issuer_host_name(simgrid::s4u::this_actor::get_host()->get_name())
{
}
static int dvfs()
{
double workload = 100E6;
- simgrid::s4u::Host* host = simgrid::s4u::this_actor::getHost();
+ simgrid::s4u::Host* host = simgrid::s4u::this_actor::get_host();
int nb = host->getPstatesCount();
XBT_INFO("Count of Processor states=%d", nb);
#ifdef __cplusplus
#include <simgrid/s4u/forward.hpp>
-#include <xbt/base.h>
-
-#include <boost/intrusive_ptr.hpp>
namespace simgrid {
namespace config {
* @brief Static methods working on the current actor (see @ref s4u::Actor) */
namespace this_actor {
-XBT_PUBLIC bool isMaestro();
+XBT_PUBLIC bool is_maestro();
/** Block the actor sleeping for that amount of seconds (may throws hostFailure) */
XBT_PUBLIC void sleep_for(double duration);
XBT_PUBLIC ExecPtr exec_async(double flops_amounts);
/** @brief Returns the actor ID of the current actor). */
-XBT_PUBLIC aid_t getPid();
+XBT_PUBLIC aid_t get_pid();
/** @brief Returns the ancestor's actor ID of the current actor. */
-XBT_PUBLIC aid_t getPpid();
+XBT_PUBLIC aid_t get_ppid();
/** @brief Returns the name of the current actor. */
XBT_PUBLIC std::string get_name();
/** @brief Returns the name of the current actor as a C string. */
XBT_PUBLIC const char* get_cname();
-XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_name()") XBT_PUBLIC std::string getName();
-XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_cname()") XBT_PUBLIC const char* getCname();
-
/** @brief Returns the name of the host on which the actor is running. */
-XBT_PUBLIC Host* getHost();
+XBT_PUBLIC Host* get_host();
/** @brief Suspend the actor. */
XBT_PUBLIC void suspend();
/** @brief Resume the actor. */
XBT_PUBLIC void resume();
-XBT_PUBLIC bool isSuspended();
+XBT_PUBLIC bool is_suspended();
/** @brief kill the actor. */
XBT_PUBLIC void kill();
/** @brief Add a function to the list of "on_exit" functions. */
-XBT_PUBLIC void onExit(int_f_pvoid_pvoid_t fun, void* data);
+XBT_PUBLIC void on_exit(int_f_pvoid_pvoid_t fun, void* data);
/** @brief Migrate the actor to a new host. */
XBT_PUBLIC void migrate(Host* new_host);
+
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_name()") XBT_PUBLIC std::string getName();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_cname()") XBT_PUBLIC const char* getCname();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::is_maestro()") XBT_PUBLIC bool isMaestro();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_pid()") XBT_PUBLIC aid_t getPid();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_ppid()") XBT_PUBLIC aid_t getPpid();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::get_host()") XBT_PUBLIC Host* getHost();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::is_suspended()") XBT_PUBLIC bool isSuspended();
+XBT_ATTRIB_DEPRECATED_v323("Please use this_actor::on_exit()") XBT_PUBLIC
+ void onExit(int_f_pvoid_pvoid_t fun, void* data);
}
/** @} */
* In SimGrid, the actor in charge of doing the stuff in kernel mode is called Maestro,
* because it is the one scheduling when the others should move or wait.
*/
-bool isMaestro()
+bool is_maestro()
{
smx_actor_t process = SIMIX_process_self();
return process == nullptr || process == simix_global->maestro_process;
void execute(double flops)
{
- smx_activity_t s = simcall_execution_start(nullptr, flops, 1.0 /*priority*/, 0. /*bound*/, getHost());
+ smx_activity_t s = simcall_execution_start(nullptr, flops, 1.0 /*priority*/, 0. /*bound*/, get_host());
simcall_execution_wait(s);
}
void execute(double flops, double priority)
{
- smx_activity_t s = simcall_execution_start(nullptr, flops, 1 / priority /*priority*/, 0. /*bound*/, getHost());
+ smx_activity_t s = simcall_execution_start(nullptr, flops, 1 / priority /*priority*/, 0. /*bound*/, get_host());
simcall_execution_wait(s);
}
ExecPtr exec_init(double flops_amount)
{
ExecPtr res = ExecPtr(new Exec());
- res->host_ = getHost();
+ res->host_ = get_host();
res->flops_amount_ = flops_amount;
res->set_remaining(flops_amount);
return res;
return res;
}
-aid_t getPid()
+aid_t get_pid()
{
return SIMIX_process_self()->pid;
}
-aid_t getPpid()
+aid_t get_ppid()
{
return SIMIX_process_self()->ppid;
}
return SIMIX_process_self()->get_cname();
}
-Host* getHost()
+Host* get_host()
{
return SIMIX_process_self()->host;
}
void suspend()
{
if (TRACE_actor_is_enabled())
- instr::Container::byName(get_name() + "-" + std::to_string(getPid()))
+ instr::Container::byName(get_name() + "-" + std::to_string(get_pid()))
->getState("ACTOR_STATE")
->pushEvent("suspend");
simcall_process_suspend(SIMIX_process_self());
simgrid::simix::kernelImmediate([process] { process->resume(); });
if (TRACE_actor_is_enabled())
- instr::Container::byName(get_name() + "-" + std::to_string(getPid()))->getState("ACTOR_STATE")->popEvent();
+ instr::Container::byName(get_name() + "-" + std::to_string(get_pid()))->getState("ACTOR_STATE")->popEvent();
}
-bool isSuspended()
+bool is_suspended()
{
smx_actor_t process = SIMIX_process_self();
return simgrid::simix::kernelImmediate([process] { return process->suspended; });
simgrid::simix::kernelImmediate([process] { SIMIX_process_kill(process, process); });
}
-void onExit(int_f_pvoid_pvoid_t fun, void* data)
+void on_exit(int_f_pvoid_pvoid_t fun, void* data)
{
simcall_process_on_exit(SIMIX_process_self(), fun, data);
}
SIMIX_process_self()->iface()->migrate(new_host);
}
+std::string getName() /* deprecated */
+{
+ return get_name();
+}
+const char* getCname() /* deprecated */
+{
+ return get_cname();
+}
+bool isMaestro() /* deprecated */
+{
+ return is_maestro();
+}
+aid_t getPid() /* deprecated */
+{
+ return get_pid();
+}
+aid_t getPpid() /* deprecated */
+{
+ return get_ppid();
+}
+Host* getHost() /* deprecated */
+{
+ return get_host();
+}
+bool isSuspended() /* deprecated */
+{
+ return is_suspended();
+}
+void onExit /* deprecated */ (int_f_pvoid_pvoid_t fun, void* data)
+{
+ on_exit(fun, data);
+}
+
} // namespace this_actor
} // namespace s4u
} // namespace simgrid
namespace simix {
class Global {
- friend XBT_PUBLIC bool simgrid::s4u::this_actor::isMaestro();
+ friend XBT_PUBLIC bool simgrid::s4u::this_actor::is_maestro();
public:
smx_context_factory_t context_factory = nullptr;
if(already_init == 0){
simgrid::smpi::Process::init(argc, argv);
smpi_process()->mark_as_initialized();
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_init(rank);
TRACE_smpi_comm_in(rank, __func__, new simgrid::instr::NoOpTIData("init"));
TRACE_smpi_comm_out(rank);
int PMPI_Finalize()
{
smpi_bench_end();
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__, new simgrid::instr::NoOpTIData("finalize"));
smpi_process()->finalize();
if (flag == nullptr) {
return MPI_ERR_ARG;
} else {
- *flag = simgrid::s4u::this_actor::getPid() ==
+ *flag = simgrid::s4u::this_actor::get_pid() ==
1; // FIXME: I don't think this is correct: This just returns true if the process ID is 1,
// regardless of whether this process called MPI_Thread_Init() or not.
return MPI_SUCCESS;
} else if (not datatype->is_valid()) {
retval = MPI_ERR_ARG;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__,
new simgrid::instr::CollTIData("bcast", root, -1.0,
datatype->is_replayable() ? count : count * datatype->size(), -1,
if (comm == MPI_COMM_NULL) {
retval = MPI_ERR_COMM;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__, new simgrid::instr::NoOpTIData("barrier"));
simgrid::smpi::Colls::barrier(comm);
sendtmpcount=0;
sendtmptype=recvtype;
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(
rank, __func__,
sendtmptype=recvtype;
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int dt_size_recv = recvtype->is_replayable() ? 1 : recvtype->size();
std::vector<int>* trace_recvcounts = new std::vector<int>;
sendcount=recvcount;
sendtype=recvtype;
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__,
new simgrid::instr::CollTIData(
sendcount=recvcounts[comm->rank()];
sendtype=recvtype;
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int dt_size_recv = recvtype->is_replayable() ? 1 : recvtype->size();
std::vector<int>* trace_recvcounts = new std::vector<int>;
recvtype = sendtype;
recvcount = sendcount;
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(
rank, __func__,
recvtype = sendtype;
recvcount = sendcounts[comm->rank()];
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int dt_size_send = sendtype->is_replayable() ? 1 : sendtype->size();
std::vector<int>* trace_sendcounts = new std::vector<int>;
} else if (not datatype->is_valid() || op == MPI_OP_NULL) {
retval = MPI_ERR_ARG;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__,
new simgrid::instr::CollTIData("reduce", root, 0,
sendtmpbuf = static_cast<char*>(xbt_malloc(count*datatype->get_extent()));
simgrid::smpi::Datatype::copy(recvbuf, count, datatype,sendtmpbuf, count, datatype);
}
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__,
new simgrid::instr::CollTIData("allReduce", -1, 0,
} else if (op == MPI_OP_NULL) {
retval = MPI_ERR_OP;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(rank, __func__, new simgrid::instr::Pt2PtTIData(
"scan", -1, datatype->is_replayable() ? count : count * datatype->size(),
} else if (op == MPI_OP_NULL) {
retval = MPI_ERR_OP;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
void* sendtmpbuf = sendbuf;
if (sendbuf == MPI_IN_PLACE) {
sendtmpbuf = static_cast<void*>(xbt_malloc(count * datatype->size()));
} else if (recvcounts == nullptr) {
retval = MPI_ERR_ARG;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
std::vector<int>* trace_recvcounts = new std::vector<int>;
int dt_send_size = datatype->is_replayable() ? 1 : datatype->size();
int totalcount = 0;
} else {
int count = comm->size();
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int dt_send_size = datatype->is_replayable() ? 1 : datatype->size();
std::vector<int>* trace_recvcounts = new std::vector<int>(recvcount * dt_send_size); // copy data to avoid bad free
} else if ((sendbuf != MPI_IN_PLACE && sendtype == MPI_DATATYPE_NULL) || recvtype == MPI_DATATYPE_NULL) {
retval = MPI_ERR_TYPE;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
void* sendtmpbuf = static_cast<char*>(sendbuf);
int sendtmpcount = sendcount;
MPI_Datatype sendtmptype = sendtype;
recvdisps == nullptr) {
retval = MPI_ERR_ARG;
} else {
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int size = comm->size();
int send_size = 0;
int recv_size = 0;
return MPI_ERR_GROUP;
} else if (newcomm == nullptr) {
return MPI_ERR_ARG;
- } else if (group->rank(simgrid::s4u::this_actor::getPid()) == MPI_UNDEFINED) {
+ } else if (group->rank(simgrid::s4u::this_actor::get_pid()) == MPI_UNDEFINED) {
*newcomm= MPI_COMM_NULL;
return MPI_SUCCESS;
}else{
} else if (rank == nullptr) {
return MPI_ERR_ARG;
} else {
- *rank = group->rank(simgrid::s4u::this_actor::getPid());
+ *rank = group->rank(simgrid::s4u::this_actor::get_pid());
return MPI_SUCCESS;
}
}
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("Irecv", src,
} else if(tag<0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
int trace_dst = getPid(comm, dst);
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("Isend", dst,
} else if(tag<0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
int trace_dst = getPid(comm, dst);
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("ISsend", dst,
} else if(tag<0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("recv", src,
datatype->is_replayable() ? count : count * datatype->size(),
} else if(tag < 0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
int dst_traced = getPid(comm, dst);
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("send", dst,
} else if(tag<0 && tag != MPI_ANY_TAG){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
int dst_traced = getPid(comm, dst);
TRACE_smpi_comm_in(my_proc_id, __func__,
new simgrid::instr::Pt2PtTIData("Ssend", dst,
} else if((sendtag<0 && sendtag != MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){
retval = MPI_ERR_TAG;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
int dst_traced = getPid(comm, dst);
int src_traced = getPid(comm, src);
simgrid::smpi::Status::empty(status);
retval = MPI_SUCCESS;
} else {
- int my_proc_id = ((*request)->comm() != MPI_COMM_NULL) ? simgrid::s4u::this_actor::getPid() : -1;
+ int my_proc_id = ((*request)->comm() != MPI_COMM_NULL) ? simgrid::s4u::this_actor::get_pid() : -1;
TRACE_smpi_testing_in(my_proc_id);
retval = MPI_SUCCESS;
} else {
int my_proc_id = (*request)->comm() != MPI_COMM_NULL
- ? simgrid::s4u::this_actor::getPid()
+ ? simgrid::s4u::this_actor::get_pid()
: -1; // TODO: cheinrich: Check if this correct or if it should be MPI_UNDEFINED
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("wait"));
smpi_bench_end();
- int rank_traced = simgrid::s4u::this_actor::getPid(); // FIXME: In PMPI_Wait, we check if the comm is null?
+ int rank_traced = simgrid::s4u::this_actor::get_pid(); // FIXME: In PMPI_Wait, we check if the comm is null?
TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitAny", static_cast<double>(count)));
*index = simgrid::smpi::Request::waitany(count, requests, status);
{
smpi_bench_end();
- int rank_traced = simgrid::s4u::this_actor::getPid(); // FIXME: In PMPI_Wait, we check if the comm is null?
+ int rank_traced = simgrid::s4u::this_actor::get_pid(); // FIXME: In PMPI_Wait, we check if the comm is null?
TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitAll", static_cast<double>(count)));
int retval = simgrid::smpi::Request::waitall(count, requests, status);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_fence"));
retval = win->fence(assert);
TRACE_smpi_comm_out(my_proc_id);
((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
retval = MPI_ERR_TYPE;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if(request == nullptr){
retval = MPI_ERR_REQUEST;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
retval = MPI_ERR_TYPE;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
int dst_traced = group->actor(target_rank)->get_pid();
} else if(request == nullptr){
retval = MPI_ERR_REQUEST;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
int dst_traced = group->actor(target_rank)->get_pid();
} else if (op == MPI_OP_NULL) {
retval = MPI_ERR_OP;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if(request == nullptr){
retval = MPI_ERR_REQUEST;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if (op == MPI_OP_NULL) {
retval = MPI_ERR_OP;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if(request == nullptr){
retval = MPI_ERR_REQUEST;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if ((datatype == MPI_DATATYPE_NULL) || (not datatype->is_valid())) {
retval = MPI_ERR_TYPE;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
MPI_Group group;
win->get_group(&group);
TRACE_smpi_comm_in(my_proc_id, __func__,
} else if (group==MPI_GROUP_NULL){
retval = MPI_ERR_GROUP;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_post"));
retval = win->post(group,assert);
TRACE_smpi_comm_out(my_proc_id);
} else if (group==MPI_GROUP_NULL){
retval = MPI_ERR_GROUP;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_start"));
retval = win->start(group,assert);
TRACE_smpi_comm_out(my_proc_id);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_complete"));
retval = win->complete();
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_wait"));
retval = win->wait();
} else if (rank == MPI_PROC_NULL){
retval = MPI_SUCCESS;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock"));
retval = win->lock(lock_type,rank,assert);
TRACE_smpi_comm_out(my_proc_id);
} else if (rank == MPI_PROC_NULL){
retval = MPI_SUCCESS;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock"));
retval = win->unlock(rank);
TRACE_smpi_comm_out(my_proc_id);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock_all"));
retval = win->lock_all(assert);
TRACE_smpi_comm_out(my_proc_id);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock_all"));
retval = win->unlock_all();
TRACE_smpi_comm_out(my_proc_id);
} else if (rank == MPI_PROC_NULL){
retval = MPI_SUCCESS;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush"));
retval = win->flush(rank);
TRACE_smpi_comm_out(my_proc_id);
} else if (rank == MPI_PROC_NULL){
retval = MPI_SUCCESS;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local"));
retval = win->flush_local(rank);
TRACE_smpi_comm_out(my_proc_id);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_all"));
retval = win->flush_all();
TRACE_smpi_comm_out(my_proc_id);
if (win == MPI_WIN_NULL) {
retval = MPI_ERR_WIN;
} else {
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local_all"));
retval = win->flush_local_all();
TRACE_smpi_comm_out(my_proc_id);
if (TRACE_is_enabled()) { \
simgrid::instr::EventType* type = simgrid::instr::Container::getRoot()->type_->getOrCreateEventType(#cat); \
\
- std::string cont_name = std::string("rank-" + std::to_string(simgrid::s4u::this_actor::getPid())); \
+ std::string cont_name = std::string("rank-" + std::to_string(simgrid::s4u::this_actor::get_pid())); \
type->addEntityValue(Colls::mpi_coll_##cat##_description[i].name, "1.0 1.0 1.0"); \
new simgrid::instr::NewEvent(SIMIX_get_clock(), simgrid::instr::Container::byName(cont_name), type, \
type->getEntityValue(Colls::mpi_coll_##cat##_description[i].name)); \
if (duration >= smpi_cpu_threshold) {
XBT_DEBUG("Sleep for %g to handle real computation time", duration);
double flops = duration * smpi_host_speed;
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_computing_in(rank, flops);
smpi_execute_flops(flops);
#if HAVE_PAPI
if (xbt_cfg_get_string("smpi/papi-events")[0] != '\0' && TRACE_smpi_is_enabled()) {
container_t container =
- new simgrid::instr::Container(std::string("rank-") + std::to_string(simgrid::s4u::this_actor::getPid));
+ new simgrid::instr::Container(std::string("rank-") + std::to_string(simgrid::s4u::this_actor::get_pid));
papi_counter_t& counter_data = smpi_process()->papi_counters();
for (auto const& pair : counter_data) {
SampleLocation(bool global, const char* file, int line) : std::string(std::string(file) + ":" + std::to_string(line))
{
if (not global)
- this->append(":" + std::to_string(simgrid::s4u::this_actor::getPid()));
+ this->append(":" + std::to_string(simgrid::s4u::this_actor::get_pid()));
}
};
}
int smpi_process_index(){
- return simgrid::s4u::this_actor::getPid();
+ return simgrid::s4u::this_actor::get_pid();
}
void * smpi_process_get_user_data(){
static std::vector<MPI_Request>* get_reqq_self()
{
- return reqq.at(simgrid::s4u::this_actor::getPid());
+ return reqq.at(simgrid::s4u::this_actor::get_pid());
}
static void set_reqq_self(std::vector<MPI_Request> *mpi_request)
{
- reqq.insert({simgrid::s4u::this_actor::getPid(), mpi_request});
+ reqq.insert({simgrid::s4u::this_actor::get_pid(), mpi_request});
}
/* Helper function */
T args;
public:
- explicit ReplayAction(std::string name) : name(name), my_proc_id(simgrid::s4u::this_actor::getPid()) {}
+ explicit ReplayAction(std::string name) : name(name), my_proc_id(simgrid::s4u::this_actor::get_pid()) {}
virtual ~ReplayAction() = default;
virtual void execute(simgrid::xbt::ReplayAction& action)
smpi_process()->mark_as_initialized();
smpi_process()->set_replaying(true);
- int my_proc_id = simgrid::s4u::this_actor::getPid();
+ int my_proc_id = simgrid::s4u::this_actor::get_pid();
TRACE_smpi_init(my_proc_id);
TRACE_smpi_computing_init(my_proc_id);
TRACE_smpi_comm_in(my_proc_id, "smpi_replay_run_init", new simgrid::instr::NoOpTIData("init"));
smpi_free_replay_tmp_buffers();
}
- TRACE_smpi_comm_in(simgrid::s4u::this_actor::getPid(), "smpi_replay_run_finalize",
+ TRACE_smpi_comm_in(simgrid::s4u::this_actor::get_pid(), "smpi_replay_run_finalize",
new simgrid::instr::NoOpTIData("finalize"));
smpi_process()->finalize();
- TRACE_smpi_comm_out(simgrid::s4u::this_actor::getPid());
- TRACE_smpi_finalize(simgrid::s4u::this_actor::getPid());
+ TRACE_smpi_comm_out(simgrid::s4u::this_actor::get_pid());
+ TRACE_smpi_finalize(simgrid::s4u::this_actor::get_pid());
}
/** @brief chain a replay initialization and a replay start */
}
char* F2C::get_key_id(char* key, int id) {
- std::snprintf(key, KEY_SIZE, "%x_%ld", static_cast<unsigned>(id), simgrid::s4u::this_actor::getPid());
+ std::snprintf(key, KEY_SIZE, "%x_%ld", static_cast<unsigned>(id), simgrid::s4u::this_actor::get_pid());
return key;
}
MPI_Request Request::send_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
- return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, PERSISTENT | SEND | PREPARED);
}
MPI_Request Request::ssend_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
- return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, PERSISTENT | SSEND | SEND | PREPARED);
}
MPI_Request Request::isend_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
- return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, PERSISTENT | ISEND | SEND | PREPARED);
}
{
return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype,
src == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(src)->get_pid(),
- simgrid::s4u::this_actor::getPid(), tag, comm, PERSISTENT | RECV | PREPARED);
+ simgrid::s4u::this_actor::get_pid(), tag, comm, PERSISTENT | RECV | PREPARED);
}
MPI_Request Request::rma_recv_init(void *buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm,
{
return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype,
src == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(src)->get_pid(),
- simgrid::s4u::this_actor::getPid(), tag, comm, PERSISTENT | RECV | PREPARED);
+ simgrid::s4u::this_actor::get_pid(), tag, comm, PERSISTENT | RECV | PREPARED);
}
MPI_Request Request::isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */
- request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, NON_PERSISTENT | ISEND | SEND);
request->start();
return request;
MPI_Request Request::issend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */
- request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, NON_PERSISTENT | ISEND | SSEND | SEND);
request->start();
return request;
MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */
request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype,
src == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(src)->get_pid(),
- simgrid::s4u::this_actor::getPid(), tag, comm, NON_PERSISTENT | RECV);
+ simgrid::s4u::this_actor::get_pid(), tag, comm, NON_PERSISTENT | RECV);
request->start();
return request;
}
void Request::send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */
- request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, NON_PERSISTENT | SEND);
request->start();
void Request::ssend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)
{
MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */
- request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::getPid(),
+ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(),
comm->group()->actor(dst)->get_pid(), tag, comm, NON_PERSISTENT | SSEND | SEND);
request->start();
{
MPI_Request requests[2];
MPI_Status stats[2];
- int myid = simgrid::s4u::this_actor::getPid();
+ int myid = simgrid::s4u::this_actor::get_pid();
if ((comm->group()->actor(dst)->get_pid() == myid) && (comm->group()->actor(src)->get_pid() == myid)) {
Datatype::copy(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype);
if (status != MPI_STATUS_IGNORE) {
double maxrate = xbt_cfg_get_double("smpi/iprobe-cpu-usage");
MPI_Request request = new Request(nullptr, 0, MPI_CHAR,
source == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(source)->get_pid(),
- simgrid::s4u::this_actor::getPid(), tag, comm, PERSISTENT | RECV);
+ simgrid::s4u::this_actor::get_pid(), tag, comm, PERSISTENT | RECV);
if (smpi_iprobe_sleep > 0) {
smx_activity_t iprobe_sleep = simcall_execution_start(
"iprobe", /* flops to executek*/ nsleeps * smpi_iprobe_sleep * speed * maxrate, /* priority */ 1.0,
}
if (TRACE_smpi_view_internals() && ((req->flags_ & RECV) != 0)){
- int rank = simgrid::s4u::this_actor::getPid();
+ int rank = simgrid::s4u::this_actor::get_pid();
int src_traced = (req->src_ == MPI_ANY_SOURCE ? req->real_src_ : req->src_);
TRACE_smpi_recv(src_traced, rank,req->tag_);
}
static void worker()
{
simgrid::s4u::this_actor::sleep_for(.5);
- XBT_INFO("Worker started (PID:%ld, PPID:%ld)", simgrid::s4u::this_actor::getPid(),
- simgrid::s4u::this_actor::getPpid());
+ XBT_INFO("Worker started (PID:%ld, PPID:%ld)", simgrid::s4u::this_actor::get_pid(),
+ simgrid::s4u::this_actor::get_ppid());
while (1) {
- XBT_INFO("Plop i am %ssuspended", simgrid::s4u::this_actor::isSuspended() ? "" : "not ");
+ XBT_INFO("Plop i am %ssuspended", simgrid::s4u::this_actor::is_suspended() ? "" : "not ");
simgrid::s4u::this_actor::sleep_for(1);
}
XBT_INFO("I'm done. See you!");
{
simgrid::s4u::this_actor::sleep_for(1);
std::vector<simgrid::s4u::ActorPtr>* actor_list = new std::vector<simgrid::s4u::ActorPtr>();
- simgrid::s4u::this_actor::getHost()->actorList(actor_list);
+ simgrid::s4u::this_actor::get_host()->actorList(actor_list);
for (auto const& actor : *actor_list) {
XBT_INFO("Actor (pid=%ld, ppid=%ld, name=%s)", actor->get_pid(), actor->get_ppid(), actor->get_cname());
- if (simgrid::s4u::this_actor::getPid() != actor->get_pid())
+ if (simgrid::s4u::this_actor::get_pid() != actor->get_pid())
actor->kill();
}
simgrid::s4u::ActorPtr actor =
- simgrid::s4u::Actor::create("worker from master", simgrid::s4u::this_actor::getHost(), worker);
+ simgrid::s4u::Actor::create("worker from master", simgrid::s4u::this_actor::get_host(), worker);
simgrid::s4u::this_actor::sleep_for(2);
XBT_INFO("Suspend Actor (pid=%ld)", actor->get_pid());
static void host()
{
simgrid::s4u::Storage* storage = simgrid::s4u::Storage::byName("Disk1");
- int id = simgrid::s4u::this_actor::getPid();
+ int id = simgrid::s4u::this_actor::get_pid();
XBT_INFO("process %d is writing!", id);
storage->write(3000000);
XBT_INFO("process %d goes to sleep for %d seconds", id, id);
static void sendpid()
{
simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName("mailbox");
- int pid = simgrid::s4u::this_actor::getPid();
+ int pid = simgrid::s4u::this_actor::get_pid();
double comm_size = 100000;
- simgrid::s4u::this_actor::onExit((int_f_pvoid_pvoid_t)my_onexit, &pid);
+ simgrid::s4u::this_actor::on_exit((int_f_pvoid_pvoid_t)my_onexit, &pid);
XBT_INFO("Sending pid of \"%d\".", pid);
mailbox->put(&pid, comm_size);
static void server()
{
- storage_info(simgrid::s4u::this_actor::getHost());
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::getHost()->get_cname());
+ storage_info(simgrid::s4u::this_actor::get_host());
+ simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName(simgrid::s4u::this_actor::get_host()->get_cname());
XBT_INFO("Server waiting for transfers ...");
while (1) {
}
}
- storage_info(simgrid::s4u::this_actor::getHost());
+ storage_info(simgrid::s4u::this_actor::get_host());
dump_platform_storages();
}