-/* Copyright (c) 2009-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2009-2018. 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 "mc/mc.h"
#include "simgrid/s4u/Activity.hpp"
#include "simgrid/s4u/Mailbox.hpp"
-#include "src/mc/mc_replay.h"
-#include "src/simix/smx_private.h"
+#include "src/mc/mc_replay.hpp"
+#include "src/simix/smx_private.hpp"
#include "src/surf/cpu_interface.hpp"
#include "src/surf/surf_interface.hpp"
/**
* \brief Checks if there is a communication activity queued in a deque matching our needs
+ * \param deque where to search into
* \param type The type of communication we are looking for (comm_send, comm_recv)
+ * \param match_fun the function to apply
+ * \param this_user_data additional parameter to the match_fun
+ * \param my_synchro what to compare against
+ * \param remove_matching whether or not to clean the found object from the queue
* \return The communication activity if found, nullptr otherwise
*/
static simgrid::kernel::activity::CommImplPtr
simcall_HANDLER_comm_wait(simcall, comm, timeout);
}
XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend(
- smx_simcall_t simcall, smx_actor_t src_proc, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
+ smx_simcall_t /*simcall*/, smx_actor_t src_proc, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
size_t src_buff_size, int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
void (*clean_fun)(void*), // used to free the synchro in case of problem after a detached send
void (*copy_data_fun)(smx_activity_t, void*, size_t), // used to copy data if not default one
simcall_HANDLER_comm_wait(simcall, comm, timeout);
}
-XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv(smx_simcall_t simcall, smx_actor_t receiver, smx_mailbox_t mbox,
- void* dst_buff, size_t* dst_buff_size,
+XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv(smx_simcall_t /*simcall*/, smx_actor_t receiver,
+ smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
simix_match_func_t match_fun,
void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data,
double rate)
other_comm = std::move(this_synchro);
mbox->push(other_comm);
} else {
- if (other_comm->surf_comm && other_comm->remains() < 1e-12) {
+ if (other_comm->surfAction_ && other_comm->remains() < 1e-12) {
XBT_DEBUG("comm %p has been already sent, and is finished, destroy it", other_comm.get());
other_comm->state = SIMIX_DONE;
other_comm->type = SIMIX_COMM_DONE;
return other_comm;
}
-smx_activity_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type, int src, int tag,
+smx_activity_t simcall_HANDLER_comm_iprobe(smx_simcall_t simcall, smx_mailbox_t mbox, int type,
simix_match_func_t match_fun, void* data)
{
- return SIMIX_comm_iprobe(simcall->issuer, mbox, type, src, tag, match_fun, data);
+ return SIMIX_comm_iprobe(simcall->issuer, mbox, type, match_fun, data);
}
-smx_activity_t SIMIX_comm_iprobe(smx_actor_t dst_proc, smx_mailbox_t mbox, int type, int src, int tag,
- simix_match_func_t match_fun, void* data)
+smx_activity_t SIMIX_comm_iprobe(smx_actor_t dst_proc, smx_mailbox_t mbox, int type, simix_match_func_t match_fun,
+ void* data)
{
XBT_DEBUG("iprobe from %p %p", mbox, &mbox->comm_queue);
simgrid::kernel::activity::CommImplPtr this_comm;
/* otherwise set up a waiting timeout on the right side */
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
SIMIX_comm_finish(synchro);
- } else { /* if (timeout >= 0) { we need a surf sleep action even when there is no timeout, otherwise surf won't tell us when the host fails */
- surf_action_t sleep = simcall->issuer->host->pimpl_cpu->sleep(timeout);
- sleep->setData(&*synchro);
+ } else { /* we need a surf sleep action even when there is no timeout, otherwise surf won't tell us when the host
+ fails */
+ simgrid::kernel::resource::Action* sleep = simcall->issuer->host->pimpl_cpu->sleep(timeout);
+ sleep->set_data(synchro.get());
simgrid::kernel::activity::CommImplPtr comm =
boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(synchro);
/**
* \brief Starts the simulation of a communication synchro.
- * \param synchro the communication synchro
+ * \param comm the communication that will be started
*/
static inline void SIMIX_comm_start(simgrid::kernel::activity::CommImplPtr comm)
{
simgrid::s4u::Host* sender = comm->src_proc->host;
simgrid::s4u::Host* receiver = comm->dst_proc->host;
- comm->surf_comm = surf_network_model->communicate(sender, receiver, comm->task_size, comm->rate);
- comm->surf_comm->setData(comm.get());
+ comm->surfAction_ = surf_network_model->communicate(sender, receiver, comm->task_size, comm->rate);
+ comm->surfAction_->set_data(comm.get());
comm->state = SIMIX_RUNNING;
- XBT_DEBUG("Starting communication %p from '%s' to '%s' (surf_action: %p)", comm.get(), sender->getCname(),
- receiver->getCname(), comm->surf_comm);
+ XBT_DEBUG("Starting communication %p from '%s' to '%s' (surf_action: %p)", comm.get(), sender->get_cname(),
+ receiver->get_cname(), comm->surfAction_);
/* If a link is failed, detect it immediately */
- if (comm->surf_comm->getState() == simgrid::surf::Action::State::failed) {
- XBT_DEBUG("Communication from '%s' to '%s' failed to start because of a link failure", sender->getCname(),
- receiver->getCname());
+ if (comm->surfAction_->get_state() == simgrid::kernel::resource::Action::State::failed) {
+ XBT_DEBUG("Communication from '%s' to '%s' failed to start because of a link failure", sender->get_cname(),
+ receiver->get_cname());
comm->state = SIMIX_LINK_FAILURE;
comm->cleanupSurf();
}
- /* If any of the process is suspend, create the synchro but stop its execution,
+ /* If any of the process is suspended, create the synchro but stop its execution,
it will be restarted when the sender process resume */
if (comm->src_proc->isSuspended() || comm->dst_proc->isSuspended()) {
if (comm->src_proc->isSuspended())
XBT_DEBUG("The communication is suspended on startup because src (%s@%s) was suspended since it initiated the "
"communication",
- comm->src_proc->cname(), comm->src_proc->host->getCname());
+ comm->src_proc->get_cname(), comm->src_proc->host->get_cname());
else
XBT_DEBUG("The communication is suspended on startup because dst (%s@%s) was suspended since it initiated the "
"communication",
- comm->dst_proc->cname(), comm->dst_proc->host->getCname());
+ comm->dst_proc->get_cname(), comm->dst_proc->host->get_cname());
- comm->surf_comm->suspend();
+ comm->surfAction_->suspend();
}
}
}
case SIMIX_SRC_HOST_FAILURE:
if (simcall->issuer == comm->src_proc)
simcall->issuer->context->iwannadie = 1;
- // SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
else
SMX_EXCEPTION(simcall->issuer, network_error, 0, "Remote peer failed");
break;
case SIMIX_DST_HOST_FAILURE:
if (simcall->issuer == comm->dst_proc)
simcall->issuer->context->iwannadie = 1;
- // SMX_EXCEPTION(simcall->issuer, host_error, 0, "Host failed");
else
SMX_EXCEPTION(simcall->issuer, network_error, 0, "Remote peer failed");
break;
case SIMIX_LINK_FAILURE:
XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) "
"detached:%d",
- synchro.get(), comm->src_proc ? comm->src_proc->host->getCname() : nullptr,
- comm->dst_proc ? comm->dst_proc->host->getCname() : nullptr, simcall->issuer->cname(),
+ synchro.get(), comm->src_proc ? comm->src_proc->host->get_cname() : nullptr,
+ comm->dst_proc ? comm->dst_proc->host->get_cname() : nullptr, simcall->issuer->get_cname(),
simcall->issuer, comm->detached);
if (comm->src_proc == simcall->issuer) {
XBT_DEBUG("I'm source");
}
else if (simcall->call == SIMCALL_COMM_TESTANY) {
e.value = -1;
- auto comms = simcall_comm_testany__get__comms(simcall);
+ auto* comms = simcall_comm_testany__get__comms(simcall);
auto count = simcall_comm_testany__get__count(simcall);
auto element = std::find(comms, comms + count, synchro);
if (element == comms + count)
return;
XBT_DEBUG("Copying comm %p data from %s (%p) -> %s (%p) (%zu bytes)", comm.get(),
- comm->src_proc ? comm->src_proc->host->getCname() : "a finished process", comm->src_buff,
- comm->dst_proc ? comm->dst_proc->host->getCname() : "a finished process", comm->dst_buff, buff_size);
+ comm->src_proc ? comm->src_proc->host->get_cname() : "a finished process", comm->src_buff,
+ comm->dst_proc ? comm->dst_proc->host->get_cname() : "a finished process", comm->dst_buff, buff_size);
/* Copy at most dst_buff_size bytes of the message to receiver's buffer */
if (comm->dst_buff_size)
- buff_size = MIN(buff_size, *(comm->dst_buff_size));
+ buff_size = std::min(buff_size, *(comm->dst_buff_size));
/* Update the receiver's buffer size to the copied amount */
if (comm->dst_buff_size)