#include <boost/range/algorithm.hpp>
+#include <xbt/ex.hpp>
+
+#include <simgrid/s4u/host.hpp>
+
#include "src/surf/surf_interface.hpp"
#include "src/simix/smx_private.h"
#include "xbt/log.h"
smx_mailbox_t mbox = (smx_mailbox_t) xbt_dict_get_or_null(mailboxes, name);
if (!mbox) {
- mbox = xbt_new0(s_smx_mailbox_t, 1);
+ mbox = new s_smx_mailbox_t();
mbox->name = xbt_strdup(name);
mbox->comm_queue = new std::deque<smx_synchro_t>();
mbox->done_comm_queue = nullptr; // Allocated on need only
- mbox->permanent_receiver=NULL;
+ mbox->permanent_receiver=nullptr;
XBT_DEBUG("Creating a mailbox at %p with name %s", mbox, name);
- xbt_dict_set(mailboxes, mbox->name, mbox, NULL);
+ xbt_dict_set(mailboxes, mbox->name, mbox, nullptr);
}
return mbox;
}
xbt_free(mbox->name);
delete mbox->comm_queue;
delete mbox->done_comm_queue;
-
- xbt_free(mbox);
+ delete mbox;
}
smx_mailbox_t SIMIX_mbox_get_by_name(const char *name)
{
simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
- comm->mbox = NULL;
+ comm->mbox = nullptr;
for (auto it = mbox->comm_queue->begin(); it != mbox->comm_queue->end(); it++)
if (*it == comm) {
mbox->comm_queue->erase(it);
/**
* \brief Checks if there is a communication synchro queued in a deque matching our needs
* \param type The type of communication we are looking for (comm_send, comm_recv)
- * \return The communication synchro if found, NULL otherwise
+ * \return The communication synchro if found, nullptr otherwise
*/
static smx_synchro_t _find_matching_comm(std::deque<smx_synchro_t> *deque, e_smx_comm_type_t type,
int (*match_fun)(void *, void *,smx_synchro_t), void *this_user_data, smx_synchro_t my_synchro, bool remove_matching)
{
- void* other_user_data = NULL;
+ void* other_user_data = nullptr;
for(auto it = deque->begin(); it != deque->end(); it++){
smx_synchro_t synchro = *it;
#if HAVE_MC
comm->mbox_cpy = comm->mbox;
#endif
- comm->mbox = NULL;
+ comm->mbox = nullptr;
return comm;
}
XBT_DEBUG("Sorry, communication synchro %p does not match our needs:"
comm, (int)comm->type, (int)type);
}
XBT_DEBUG("No matching communication synchro found");
- return NULL;
+ return nullptr;
}
/******************************************************************************/
void (*copy_data_fun)(smx_synchro_t, void*, size_t),
void *data, double timeout){
smx_synchro_t comm = simcall_HANDLER_comm_isend(simcall, src, mbox, task_size, rate,
- src_buff, src_buff_size, match_fun, NULL, copy_data_fun,
+ src_buff, src_buff_size, match_fun, nullptr, copy_data_fun,
data, 0);
SIMCALL_SET_MC_VALUE(simcall, 0);
simcall_HANDLER_comm_wait(simcall, comm, timeout);
other_synchro = this_synchro;
other_comm = static_cast<simgrid::simix::Comm*>(other_synchro);
- if (mbox->permanent_receiver!=NULL){
+ if (mbox->permanent_receiver!=nullptr){
//this mailbox is for small messages, which have to be sent right now
other_synchro->state = SIMIX_READY;
- other_comm->dst_proc=mbox->permanent_receiver;
+ other_comm->dst_proc=mbox->permanent_receiver.get();
other_comm->ref();
mbox->done_comm_queue->push_back(other_synchro);
other_comm->mbox=mbox;
other_comm->detached = true;
other_comm->clean_fun = clean_fun;
} else {
- other_comm->clean_fun = NULL;
+ other_comm->clean_fun = nullptr;
}
/* Setup the communication synchro */
if (MC_is_active() || MC_record_replay_is_active()) {
other_comm->state = SIMIX_RUNNING;
- return (detached ? NULL : other_comm);
+ return (detached ? nullptr : other_comm);
}
SIMIX_comm_start(other_comm);
- return (detached ? NULL : other_comm);
+ return (detached ? nullptr : other_comm);
}
XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_process_t receiver, smx_mailbox_t mbox,
XBT_DEBUG("comm %p has been already sent, and is finished, destroy it",other_comm);
other_comm->state = SIMIX_DONE;
other_comm->type = SIMIX_COMM_DONE;
- other_comm->mbox = NULL;
+ other_comm->mbox = nullptr;
}
other_comm->unref();
static_cast<simgrid::simix::Comm*>(this_synchro)->unref();
this_comm = new simgrid::simix::Comm(SIMIX_COMM_RECEIVE);
smx_type = SIMIX_COMM_SEND;
}
- smx_synchro_t other_synchro=NULL;
+ smx_synchro_t other_synchro=nullptr;
if(mbox->permanent_receiver && ! mbox->done_comm_queue->empty()){
XBT_DEBUG("first check in the permanent recv mailbox, to see if we already got something");
other_synchro =
{
unsigned int cursor;
smx_synchro_t synchro;
+ // The default result is -1 -- this means, "nothing is ready".
+ // It can be changed below, but only if something matches.
simcall_comm_testany__set__result(simcall, -1);
if (MC_is_active() || MC_record_replay_is_active()){
XBT_DEBUG("Link failure in synchro %p between '%s' and '%s': posting an exception to the issuer: %s (%p) detached:%d",
synchro,
- comm->src_proc ? sg_host_get_name(comm->src_proc->host) : NULL,
- comm->dst_proc ? sg_host_get_name(comm->dst_proc->host) : NULL,
+ comm->src_proc ? sg_host_get_name(comm->src_proc->host) : nullptr,
+ comm->dst_proc ? sg_host_get_name(comm->dst_proc->host) : nullptr,
simcall->issuer->name.c_str(), simcall->issuer, comm->detached);
if (comm->src_proc == simcall->issuer) {
XBT_DEBUG("I'm source");
}
/* if there is an exception during a waitany or a testany, indicate the position of the failed communication */
- if (simcall->issuer->doexception) {
- if (simcall->call == SIMCALL_COMM_WAITANY) {
- simcall->issuer->running_ctx->exception.value = xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro);
+ if (simcall->issuer->exception) {
+ // In order to modify the exception we have to rethrow it:
+ try {
+ std::rethrow_exception(simcall->issuer->exception);
+ }
+ catch(xbt_ex& e) {
+ if (simcall->call == SIMCALL_COMM_WAITANY) {
+ e.value = xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro);
+ }
+ else if (simcall->call == SIMCALL_COMM_TESTANY) {
+ e.value = xbt_dynar_search(simcall_comm_testany__get__comms(simcall), &synchro);
+ }
+ simcall->issuer->exception = std::make_exception_ptr(e);
}
- else if (simcall->call == SIMCALL_COMM_TESTANY) {
- simcall->issuer->running_ctx->exception.value = xbt_dynar_search(simcall_comm_testany__get__comms(simcall), &synchro);
+ catch(...) {
+ // Nothing to do
}
}
simcall->issuer->context->iwannadie = 1;
}
- simcall->issuer->waiting_synchro = NULL;
+ simcall->issuer->waiting_synchro = nullptr;
xbt_fifo_remove(simcall->issuer->comms, synchro);
if(comm->detached){
if(simcall->issuer == comm->src_proc){
memcpy(comm->dst_buff, buff, buff_size);
if (comm->detached) { // if this is a detached send, the source buffer was duplicated by SMPI sender to make the original buffer available to the application ASAP
xbt_free(buff);
- comm->src_buff = NULL;
+ comm->src_buff = nullptr;
}
}
