X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8de7a90b044d2c8cf008e498f533cd7131c9f106..b51da37243dc16575499f4cb7729fe8bdd7fa514:/src/msg/msg_gos.cpp diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp index becc04b412..1d5ebf1271 100644 --- a/src/msg/msg_gos.cpp +++ b/src/msg/msg_gos.cpp @@ -3,6 +3,8 @@ /* 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 + #include "src/simix/smx_private.h" /* MSG_task_listen looks inside the rdv directly. Not clean. */ #include "msg_private.h" #include "mc/mc.h" @@ -42,7 +44,6 @@ msg_error_t MSG_task_execute(msg_task_t task) */ msg_error_t MSG_parallel_task_execute(msg_task_t task) { - xbt_ex_t e; simdata_task_t simdata = task->simdata; simdata_process_t p_simdata = (simdata_process_t) SIMIX_process_self_get_data(); e_smx_state_t comp_state; @@ -50,8 +51,8 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) TRACE_msg_task_execute_start(task); - xbt_assert((!simdata->compute) && (task->simdata->isused == 0), - "This task is executed somewhere else. Go fix your code! %d", task->simdata->isused!=NULL); + xbt_assert((!simdata->compute) && !task->simdata->isused, + "This task is executed somewhere else. Go fix your code!"); XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self())); @@ -60,11 +61,8 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) return MSG_OK; } - TRY { - if (msg_global->debug_multiple_use) - MSG_BT(simdata->isused, "Using Backtrace"); - else - simdata->isused = (void*)1; + try { + simdata->setUsed(); if (simdata->host_nb > 0) { simdata->compute = static_cast( @@ -87,15 +85,12 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) p_simdata->waiting_action = simdata->compute; comp_state = simcall_execution_wait(simdata->compute); - p_simdata->waiting_action = NULL; - - if (msg_global->debug_multiple_use && simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)simdata->isused); - simdata->isused = 0; + p_simdata->waiting_action = nullptr; + simdata->setNotUsed(); XBT_DEBUG("Execution task '%s' finished in state %d", task->name, (int)comp_state); } - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case cancel_error: status = MSG_TASK_CANCELED; @@ -104,14 +99,14 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) status = MSG_HOST_FAILURE; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } - /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */ + + /* action ended, set comm and compute = nullptr, the actions is already destroyed in the main function */ simdata->flops_amount = 0.0; - simdata->comm = NULL; - simdata->compute = NULL; + simdata->comm = nullptr; + simdata->compute = nullptr; TRACE_msg_task_execute_end(task); MSG_RETURN(status); @@ -126,16 +121,15 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) */ msg_error_t MSG_process_sleep(double nb_sec) { - xbt_ex_t e; msg_error_t status = MSG_OK; /*msg_process_t proc = MSG_process_self();*/ TRACE_msg_process_sleep_in(MSG_process_self()); - TRY { + try { simcall_process_sleep(nb_sec); } - CATCH(e) { + catch(xbt_ex& e) { switch (e.category) { case cancel_error: XBT_DEBUG("According to the JAVA API, a sleep call should only deal with HostFailureException, WTF here ?"); @@ -148,9 +142,8 @@ msg_error_t MSG_process_sleep(double nb_sec) status = MSG_TASK_CANCELED; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } TRACE_msg_process_sleep_out(MSG_process_self()); @@ -208,7 +201,7 @@ msg_error_t MSG_task_receive_bounded(msg_task_t * task, const char *alias, doubl */ msg_error_t MSG_task_receive_with_timeout(msg_task_t * task, const char *alias, double timeout) { - return MSG_task_receive_ext(task, alias, timeout, NULL); + return MSG_task_receive_ext(task, alias, timeout, nullptr); } /** \ingroup msg_task_usage @@ -225,7 +218,7 @@ msg_error_t MSG_task_receive_with_timeout(msg_task_t * task, const char *alias, */ msg_error_t MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char *alias, double timeout,double rate) { - return MSG_task_receive_ext_bounded(task, alias, timeout, NULL, rate); + return MSG_task_receive_ext_bounded(task, alias, timeout, nullptr, rate); } /** \ingroup msg_task_usage @@ -246,21 +239,19 @@ msg_error_t MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char */ msg_error_t MSG_task_receive_ext(msg_task_t * task, const char *alias, double timeout, msg_host_t host) { - xbt_ex_t e; msg_error_t ret = MSG_OK; XBT_DEBUG("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'", alias); - TRY { + try { ret = MSG_mailbox_get_task_ext(MSG_mailbox_get_by_alias(alias), task, host, timeout); } - CATCH(e) { + catch(xbt_ex& e) { switch (e.category) { case cancel_error: /* may be thrown by MSG_mailbox_get_by_alias */ ret = MSG_HOST_FAILURE; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } return ret; } @@ -290,7 +281,7 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *al int (*match_fun)(void*,void*, smx_synchro_t), void *match_data, void_f_pvoid_t cleanup, int detached) { - simdata_task_t t_simdata = NULL; + simdata_task_t t_simdata = nullptr; msg_process_t process = MSG_process_self(); msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); int call_end = TRACE_msg_task_put_start(task); @@ -299,39 +290,22 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *al t_simdata = task->simdata; t_simdata->sender = process; t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data())->m_host; - - if (t_simdata->isused != 0) { - if (msg_global->debug_multiple_use){ - XBT_ERROR("This task is already used in there:"); - xbt_backtrace_display((xbt_ex_t*) t_simdata->isused); - XBT_ERROR("And you try to reuse it from here:"); - xbt_backtrace_display_current(); - } else { - xbt_assert(t_simdata->isused == 0, - "This task is still being used somewhere else. You cannot send it now. Go fix your code!" - "(use --cfg=msg/debug-multiple-use:on to get the backtrace of the other process)"); - } - } - - if (msg_global->debug_multiple_use) - MSG_BT(t_simdata->isused, "Using Backtrace"); - else - t_simdata->isused = (void*)1; - t_simdata->comm = NULL; + t_simdata->setUsed(); + t_simdata->comm = nullptr; msg_global->sent_msg++; /* Send it by calling SIMIX network layer */ smx_synchro_t act = simcall_comm_isend(SIMIX_process_self(), mailbox, t_simdata->bytes_amount, t_simdata->rate, - task, sizeof(void *), match_fun, cleanup, NULL, match_data,detached); + task, sizeof(void *), match_fun, cleanup, nullptr, match_data,detached); t_simdata->comm = static_cast(act); /* FIXME: is the field t_simdata->comm still useful? */ msg_comm_t comm; if (detached) { - comm = NULL; + comm = nullptr; } else { comm = xbt_new0(s_msg_comm_t, 1); comm->task_sent = task; - comm->task_received = NULL; + comm->task_received = nullptr; comm->status = MSG_OK; comm->s_comm = act; } @@ -355,7 +329,7 @@ static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *al */ msg_comm_t MSG_task_isend(msg_task_t task, const char *alias) { - return MSG_task_isend_internal(task, alias, NULL, NULL, NULL, 0); + return MSG_task_isend_internal(task, alias, nullptr, nullptr, nullptr, 0); } /** \ingroup msg_task_usage @@ -372,7 +346,7 @@ msg_comm_t MSG_task_isend(msg_task_t task, const char *alias) msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate) { task->simdata->rate = maxrate; - return MSG_task_isend_internal(task, alias, NULL, NULL, NULL, 0); + return MSG_task_isend_internal(task, alias, nullptr, nullptr, nullptr, 0); } /** \ingroup msg_task_usage @@ -392,7 +366,7 @@ msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias, double max msg_comm_t MSG_task_isend_with_matching(msg_task_t task, const char *alias, int (*match_fun)(void*, void*, smx_synchro_t), void *match_data) { - return MSG_task_isend_internal(task, alias, match_fun, match_data, NULL, 0); + return MSG_task_isend_internal(task, alias, match_fun, match_data, nullptr, 0); } /** \ingroup msg_task_usage @@ -408,11 +382,11 @@ msg_comm_t MSG_task_isend_with_matching(msg_task_t task, const char *alias, * \param task a #msg_task_t to send on another location. * \param alias name of the mailbox to sent the task to * \param cleanup a function to destroy the task if the communication fails, e.g. MSG_task_destroy - * (if NULL, no function will be called) + * (if nullptr, no function will be called) */ void MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup) { - MSG_task_isend_internal(task, alias, NULL, NULL, cleanup, 1); + MSG_task_isend_internal(task, alias, nullptr, nullptr, cleanup, 1); } /** \ingroup msg_task_usage @@ -429,7 +403,7 @@ void MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup) * \param alias name of the mailbox to sent the task to * \param cleanup a function to destroy the task if the * communication fails, e.g. MSG_task_destroy - * (if NULL, no function will be called) + * (if nullptr, no function will be called) * \param maxrate the maximum communication rate for sending this task * */ @@ -474,10 +448,10 @@ msg_comm_t MSG_task_irecv_bounded(msg_task_t *task, const char *name, double rat /* Try to receive it by calling SIMIX network layer */ msg_comm_t comm = xbt_new0(s_msg_comm_t, 1); - comm->task_sent = NULL; + comm->task_sent = nullptr; comm->task_received = task; comm->status = MSG_OK; - comm->s_comm = simcall_comm_irecv(MSG_process_self(), rdv, task, NULL, NULL, NULL, NULL, rate); + comm->s_comm = simcall_comm_irecv(MSG_process_self(), rdv, task, nullptr, nullptr, nullptr, nullptr, rate); return comm; } @@ -492,20 +466,16 @@ msg_comm_t MSG_task_irecv_bounded(msg_task_t *task, const char *name, double rat */ int MSG_comm_test(msg_comm_t comm) { - xbt_ex_t e; int finished = 0; - TRY { + try { finished = simcall_comm_test(comm->s_comm); - - if (finished && comm->task_received != NULL) { + if (finished && comm->task_received != nullptr) { /* I am the receiver */ - if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused); - (*comm->task_received)->simdata->isused = 0; + (*comm->task_received)->simdata->setNotUsed(); } } - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case network_error: comm->status = MSG_TRANSFER_FAILURE; @@ -516,9 +486,8 @@ int MSG_comm_test(msg_comm_t comm) finished = 1; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } return finished; @@ -533,22 +502,22 @@ int MSG_comm_test(msg_comm_t comm) */ int MSG_comm_testany(xbt_dynar_t comms) { - xbt_ex_t e; int finished_index = -1; - /* create the equivalent dynar with SIMIX objects */ - xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), NULL); + /* Create the equivalent array with SIMIX objects: */ + std::vector s_comms; + s_comms.reserve(xbt_dynar_length(comms)); msg_comm_t comm; unsigned int cursor; xbt_dynar_foreach(comms, cursor, comm) { - xbt_dynar_push(s_comms, &comm->s_comm); + s_comms.push_back(comm->s_comm); } msg_error_t status = MSG_OK; - TRY { - finished_index = simcall_comm_testany(s_comms); + try { + finished_index = simcall_comm_testany(s_comms.data(), s_comms.size()); } - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case network_error: finished_index = e.value; @@ -559,22 +528,18 @@ int MSG_comm_testany(xbt_dynar_t comms) status = MSG_TIMEOUT; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } - xbt_dynar_free(&s_comms); if (finished_index != -1) { comm = xbt_dynar_get_as(comms, finished_index, msg_comm_t); /* the communication is finished */ comm->status = status; - if (status == MSG_OK && comm->task_received != NULL) { + if (status == MSG_OK && comm->task_received != nullptr) { /* I am the receiver */ - if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused); - (*comm->task_received)->simdata->isused = 0; + (*comm->task_received)->simdata->setNotUsed(); } } @@ -601,20 +566,17 @@ void MSG_comm_destroy(msg_comm_t comm) */ msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout) { - xbt_ex_t e; - TRY { + try { simcall_comm_wait(comm->s_comm, timeout); - if (comm->task_received != NULL) { + if (comm->task_received != nullptr) { /* I am the receiver */ - if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused); - (*comm->task_received)->simdata->isused = 0; + (*comm->task_received)->simdata->setNotUsed(); } /* FIXME: these functions are not traceable */ } - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case network_error: comm->status = MSG_TRANSFER_FAILURE; @@ -623,9 +585,8 @@ msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout) comm->status = MSG_TIMEOUT; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } return comm->status; @@ -654,11 +615,10 @@ void MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout) */ int MSG_comm_waitany(xbt_dynar_t comms) { - xbt_ex_t e; int finished_index = -1; /* create the equivalent dynar with SIMIX objects */ - xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), NULL); + xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), nullptr); msg_comm_t comm; unsigned int cursor; xbt_dynar_foreach(comms, cursor, comm) { @@ -666,10 +626,10 @@ int MSG_comm_waitany(xbt_dynar_t comms) } msg_error_t status = MSG_OK; - TRY { - finished_index = simcall_comm_waitany(s_comms); + try { + finished_index = simcall_comm_waitany(s_comms, -1); } - CATCH(e) { + catch(xbt_ex& e) { switch (e.category) { case network_error: finished_index = e.value; @@ -680,9 +640,8 @@ int MSG_comm_waitany(xbt_dynar_t comms) status = MSG_TIMEOUT; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } xbt_assert(finished_index != -1, "WaitAny returned -1"); @@ -692,11 +651,9 @@ int MSG_comm_waitany(xbt_dynar_t comms) /* the communication is finished */ comm->status = status; - if (comm->task_received != NULL) { + if (comm->task_received != nullptr) { /* I am the receiver */ - if (msg_global->debug_multiple_use && (*comm->task_received)->simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)(*comm->task_received)->simdata->isused); - (*comm->task_received)->simdata->isused = 0; + (*comm->task_received)->simdata->setNotUsed(); } return finished_index; @@ -799,7 +756,7 @@ msg_error_t MSG_task_send_bounded(msg_task_t task, const char *alias, double max msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout) { msg_error_t ret = MSG_OK; - simdata_task_t t_simdata = NULL; + simdata_task_t t_simdata = nullptr; msg_process_t process = MSG_process_self(); simdata_process_t p_simdata = (simdata_process_t) SIMIX_process_self_get_data(); msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); @@ -811,41 +768,24 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl t_simdata->sender = process; t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data())->m_host; - if (t_simdata->isused != 0) { - if (msg_global->debug_multiple_use){ - XBT_ERROR("This task is already used in there:"); - xbt_backtrace_display((xbt_ex_t*) t_simdata->isused); - XBT_ERROR("And you try to reuse it from here:"); - xbt_backtrace_display_current(); - } else { - xbt_assert(t_simdata->isused == 0, - "This task is still being used somewhere else. You cannot send it now. Go fix your code!" - " (use --cfg=msg/debug-multiple-use:on to get the backtrace of the other process)"); - } - } + t_simdata->setUsed(); - if (msg_global->debug_multiple_use) - MSG_BT(t_simdata->isused, "Using Backtrace"); - else - t_simdata->isused = (void*)1; - t_simdata->comm = NULL; + t_simdata->comm = nullptr; msg_global->sent_msg++; p_simdata->waiting_task = task; - xbt_ex_t e; /* Try to send it by calling SIMIX network layer */ - TRY { - smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simix call */ + try { + smx_synchro_t comm = nullptr; /* MC needs the comm to be set to nullptr during the simix call */ comm = simcall_comm_isend(SIMIX_process_self(), mailbox,t_simdata->bytes_amount, - t_simdata->rate, task, sizeof(void *), NULL, NULL, NULL, task, 0); + t_simdata->rate, task, sizeof(void *), nullptr, nullptr, nullptr, task, 0); if (TRACE_is_enabled()) simcall_set_category(comm, task->category); t_simdata->comm = static_cast(comm); simcall_comm_wait(comm, timeout); } - - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case cancel_error: ret = MSG_HOST_FAILURE; @@ -857,17 +797,14 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl ret = MSG_TIMEOUT; break; default: - RETHROW; + throw; } - xbt_ex_free(e); /* If the send failed, it is not used anymore */ - if (msg_global->debug_multiple_use && t_simdata->isused!=0) - xbt_ex_free(*(xbt_ex_t*)t_simdata->isused); - t_simdata->isused = 0; + t_simdata->setNotUsed(); } - p_simdata->waiting_task = NULL; + p_simdata->waiting_task = nullptr; if (call_end) TRACE_msg_task_put_end(); MSG_RETURN(ret); @@ -902,7 +839,8 @@ msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alia int MSG_task_listen(const char *alias) { smx_mailbox_t mbox = MSG_mailbox_get_by_alias(alias); - return !MSG_mailbox_is_empty(mbox) || (mbox->permanent_receiver && !mbox->done_comm_queue->empty()); + return !MSG_mailbox_is_empty(mbox) || + (mbox->permanent_receiver && !mbox->done_comm_queue.empty()); } /** \ingroup msg_task_usage @@ -917,7 +855,7 @@ int MSG_task_listen_from(const char *alias) { msg_task_t task; - if (NULL == (task = MSG_mailbox_front(MSG_mailbox_get_by_alias(alias)))) + if (nullptr == (task = MSG_mailbox_front(MSG_mailbox_get_by_alias(alias)))) return -1; return MSG_process_get_PID(task->simdata->sender); @@ -951,7 +889,7 @@ void MSG_task_set_category (msg_task_t task, const char *category) * * \see MSG_task_set_category * - * \return Returns the name of the tracing category of the given task, NULL otherwise + * \return Returns the name of the tracing category of the given task, nullptr otherwise */ const char *MSG_task_get_category (msg_task_t task) { @@ -963,7 +901,7 @@ const char *MSG_task_get_category (msg_task_t task) * * \param asr the name of a router or AS * \param name a property name - * \return value of a property (or NULL if property not set) + * \return value of a property (or nullptr if property not set) */ const char *MSG_as_router_get_property_value(const char* asr, const char *name) {