X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f89bfaee2e744ff4516d025623b33fe11e7a544c..b3b356352e87ae00a20f737c48e19b0c8413455a:/src/msg/msg_mailbox.c diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c index 6082642267..7b2301fd60 100644 --- a/src/msg/msg_mailbox.c +++ b/src/msg/msg_mailbox.c @@ -1,6 +1,6 @@ /* Mailboxes in MSG */ -/* Copyright (c) 2008-2013. The SimGrid Team. +/* Copyright (c) 2008-2015. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -29,7 +29,7 @@ int MSG_mailbox_is_empty(msg_mailbox_t mailbox) msg_task_t MSG_mailbox_get_head(msg_mailbox_t mailbox) { - smx_action_t comm = simcall_rdv_get_head(mailbox); + smx_synchro_t comm = simcall_rdv_get_head(mailbox); if (!comm) return NULL; @@ -58,13 +58,13 @@ msg_mailbox_t MSG_mailbox_get_by_alias(const char *alias) /** \ingroup msg_mailbox_management * \brief Set the mailbox to receive in asynchronous mode * - * All messages sent to this mailbox will be transferred to - * the receiver without waiting for the receive call. + * All messages sent to this mailbox will be transferred to + * the receiver without waiting for the receive call. * The receive call will still be necessary to use the received data. - * If there is a need to receive some messages asynchronously, and some not, + * If there is a need to receive some messages asynchronously, and some not, * two different mailboxes should be used. * - * \param alias The name of the mailbox + * \param alias The name of the mailbox */ void MSG_mailbox_set_async(const char *alias){ msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); @@ -87,58 +87,10 @@ void MSG_mailbox_set_async(const char *alias){ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise. */ msg_error_t -MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, msg_task_t * task, +MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, msg_task_t *task, msg_host_t host, double timeout) { - xbt_ex_t e; - msg_error_t ret = MSG_OK; - /* We no longer support getting a task from a specific host */ - if (host) - THROW_UNIMPLEMENTED; - -#ifdef HAVE_TRACING - TRACE_msg_task_get_start(); - double start_time = MSG_get_clock(); -#endif - - /* Sanity check */ - xbt_assert(task, "Null pointer for the task storage"); - - if (*task) - XBT_WARN - ("Asked to write the received task in a non empty struct -- proceeding."); - - /* Try to receive it by calling SIMIX network layer */ - TRY { - simcall_comm_recv(mailbox, task, NULL, NULL, NULL, timeout); - XBT_DEBUG("Got task %s from %p",(*task)->name,mailbox); - (*task)->simdata->isused=0; - } - CATCH(e) { - switch (e.category) { - case cancel_error: - ret = MSG_HOST_FAILURE; - break; - case network_error: - ret = MSG_TRANSFER_FAILURE; - break; - case timeout_error: - ret = MSG_TIMEOUT; - break; - default: - RETHROW; - } - xbt_ex_free(e); - } - -#ifdef HAVE_TRACING - if (ret != MSG_HOST_FAILURE && - ret != MSG_TRANSFER_FAILURE && - ret != MSG_TIMEOUT) { - TRACE_msg_task_get_end(start_time, *task); - } -#endif - MSG_RETURN(ret); + return MSG_mailbox_get_task_ext_bounded(mailbox, task, host, timeout, -1.0); } /** \ingroup msg_mailbox_management @@ -156,7 +108,7 @@ MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, msg_task_t * task, */ msg_error_t MSG_mailbox_get_task_ext_bounded(msg_mailbox_t mailbox, msg_task_t * task, - msg_host_t host, double timeout, double rate) + msg_host_t host, double timeout, double rate) { xbt_ex_t e; msg_error_t ret = MSG_OK; @@ -164,10 +116,8 @@ MSG_mailbox_get_task_ext_bounded(msg_mailbox_t mailbox, msg_task_t * task, if (host) THROW_UNIMPLEMENTED; -#ifdef HAVE_TRACING TRACE_msg_task_get_start(); double start_time = MSG_get_clock(); -#endif /* Sanity check */ xbt_assert(task, "Null pointer for the task storage"); @@ -178,9 +128,11 @@ MSG_mailbox_get_task_ext_bounded(msg_mailbox_t mailbox, msg_task_t * task, /* Try to receive it by calling SIMIX network layer */ TRY { - simcall_comm_recv_bounded(mailbox, task, NULL, NULL, NULL, timeout, rate); + simcall_comm_recv(mailbox, task, NULL, NULL, NULL, NULL, timeout, rate); XBT_DEBUG("Got task %s from %p",(*task)->name,mailbox); - (*task)->simdata->isused=0; + if (msg_global->debug_multiple_use && (*task)->simdata->isused!=0) + xbt_ex_free(*(xbt_ex_t*)(*task)->simdata->isused); + (*task)->simdata->isused = 0; } CATCH(e) { switch (e.category) { @@ -193,19 +145,20 @@ MSG_mailbox_get_task_ext_bounded(msg_mailbox_t mailbox, msg_task_t * task, case timeout_error: ret = MSG_TIMEOUT; break; + case host_error: + ret = MSG_HOST_FAILURE; + break; default: RETHROW; } xbt_ex_free(e); } -#ifdef HAVE_TRACING if (ret != MSG_HOST_FAILURE && ret != MSG_TRANSFER_FAILURE && ret != MSG_TIMEOUT) { TRACE_msg_task_get_end(start_time, *task); } -#endif MSG_RETURN(ret); } @@ -213,42 +166,49 @@ msg_error_t MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, msg_task_t task, double timeout) { - xbt_ex_t e; msg_error_t ret = MSG_OK; simdata_task_t t_simdata = NULL; msg_process_t process = MSG_process_self(); simdata_process_t p_simdata = SIMIX_process_self_get_data(process); -#ifdef HAVE_TRACING int call_end = TRACE_msg_task_put_start(task); //must be after CHECK_HOST() -#endif /* Prepare the task to send */ t_simdata = task->simdata; t_simdata->sender = process; t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host; - xbt_assert(t_simdata->isused == 0, - "This task is still being used somewhere else. You cannot send it now. Go fix your code!"); + if (t_simdata->isused != 0) { + if (msg_global->debug_multiple_use){ + XBT_ERROR("This task is already used in there:"); + xbt_backtrace_display(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->isused=1; + if (msg_global->debug_multiple_use) + MSG_BT(t_simdata->isused, "Using Backtrace"); + else + t_simdata->isused = (void*)1; t_simdata->comm = NULL; msg_global->sent_msg++; p_simdata->waiting_task = task; + xbt_ex_t e; /* Try to send it by calling SIMIX network layer */ TRY { - smx_action_t comm = NULL; /* MC needs the comm to be set to NULL during the simix call */ - comm = simcall_comm_isend(mailbox, t_simdata->message_size, + smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simix call */ + comm = simcall_comm_isend(SIMIX_process_self(), mailbox,t_simdata->bytes_amount, t_simdata->rate, task, sizeof(void *), - NULL, NULL, task, 0); -#ifdef HAVE_TRACING - if (TRACE_is_enabled()) { + NULL, NULL, NULL, task, 0); + if (TRACE_is_enabled()) simcall_set_category(comm, task->category); - } -#endif t_simdata->comm = comm; simcall_comm_wait(comm, timeout); } @@ -270,15 +230,15 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, msg_task_t task, 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; } p_simdata->waiting_task = NULL; -#ifdef HAVE_TRACING if (call_end) TRACE_msg_task_put_end(); -#endif MSG_RETURN(ret); }