X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/48efae676c3604efffe21365b2d525e578fd22e5..37f79c31cbc78af908f87b9e3cc15223b5a450ac:/src/msg/msg_gos.cpp diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp index 1867677b68..c9cd6f41a2 100644 --- a/src/msg/msg_gos.cpp +++ b/src/msg/msg_gos.cpp @@ -42,7 +42,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 +49,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 +59,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 +83,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 +97,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 +119,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 +140,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 +199,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 +216,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 +237,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 +279,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 +288,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 +327,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 +344,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 +364,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 +380,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 +401,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 +446,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 +464,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 +484,8 @@ int MSG_comm_test(msg_comm_t comm) finished = 1; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } return finished; @@ -533,11 +500,10 @@ 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); + 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) { @@ -545,10 +511,10 @@ int MSG_comm_testany(xbt_dynar_t comms) } msg_error_t status = MSG_OK; - TRY { + try { finished_index = simcall_comm_testany(s_comms); } - CATCH(e) { + catch (xbt_ex& e) { switch (e.category) { case network_error: finished_index = e.value; @@ -559,9 +525,8 @@ int MSG_comm_testany(xbt_dynar_t comms) status = MSG_TIMEOUT; break; default: - RETHROW; + throw; } - xbt_ex_free(e); } xbt_dynar_free(&s_comms); @@ -570,11 +535,9 @@ int MSG_comm_testany(xbt_dynar_t comms) /* 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 +564,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 +583,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 +613,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 +624,10 @@ int MSG_comm_waitany(xbt_dynar_t comms) } msg_error_t status = MSG_OK; - TRY { + try { finished_index = simcall_comm_waitany(s_comms); } - CATCH(e) { + catch(xbt_ex& e) { switch (e.category) { case network_error: finished_index = e.value; @@ -680,9 +638,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 +649,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 +754,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 +766,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 +795,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); @@ -917,7 +852,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); @@ -931,7 +866,7 @@ int MSG_task_listen_from(const char *alias) * parameter category must contain a category that was previously declared with the function #TRACE_category * (or with #TRACE_category_with_color). * - * See \ref tracing for details on how to trace the (categorized) resource utilization. + * See \ref outcomes_vizu for details on how to trace the (categorized) resource utilization. * * \param task the task that is going to be categorized * \param category the name of the category to be associated to the task @@ -951,7 +886,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 +898,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) {