X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/cf57fb58889894670e2594d2e3b6a213d8fd6089..1ee0ed6b44e3639fcfcbb37a43e8709aa95a2db5:/src/msg/msg_mailbox.c diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c index 3f015f1e24..942f332433 100644 --- a/src/msg/msg_mailbox.c +++ b/src/msg/msg_mailbox.c @@ -6,48 +6,48 @@ /* 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 "mailbox.h" -#include "msg/private.h" +#include "msg_mailbox.h" +#include "msg_private.h" + XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_mailbox, msg, "Logging specific to MSG (mailbox)"); msg_mailbox_t MSG_mailbox_new(const char *alias) { - return SIMIX_req_rdv_create(alias); + return simcall_rdv_create(alias); } void MSG_mailbox_free(void *mailbox) { - SIMIX_req_rdv_destroy((msg_mailbox_t)mailbox); + simcall_rdv_destroy((msg_mailbox_t)mailbox); } int MSG_mailbox_is_empty(msg_mailbox_t mailbox) { - return (NULL == SIMIX_req_rdv_get_head(mailbox)); + return (NULL == simcall_rdv_get_head(mailbox)); } -m_task_t MSG_mailbox_get_head(msg_mailbox_t mailbox) +msg_task_t MSG_mailbox_get_head(msg_mailbox_t mailbox) { - smx_action_t comm = SIMIX_req_rdv_get_head(mailbox); + smx_action_t comm = simcall_rdv_get_head(mailbox); if (!comm) return NULL; - return (m_task_t) SIMIX_req_comm_get_src_data(comm); + return (msg_task_t) simcall_comm_get_src_data(comm); } int MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, - m_host_t host) + msg_host_t host) { - return SIMIX_req_rdv_comm_count_by_host(mailbox, - host->simdata->smx_host); + return simcall_rdv_comm_count_by_host(mailbox, host); } msg_mailbox_t MSG_mailbox_get_by_alias(const char *alias) { - msg_mailbox_t mailbox = SIMIX_req_rdv_get_by_name(alias); + msg_mailbox_t mailbox = simcall_rdv_get_by_name(alias); if (!mailbox) mailbox = MSG_mailbox_new(alias); @@ -55,28 +55,47 @@ msg_mailbox_t MSG_mailbox_get_by_alias(const char *alias) return mailbox; } -msg_mailbox_t MSG_mailbox_get_by_channel(m_host_t host, - m_channel_t channel) -{ - xbt_assert((host != NULL), "Invalid host"); - xbt_assert((channel >= 0) - && (channel < msg_global->max_channel), "Invalid channel %d", - channel); +/** \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. + * 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, + * two different mailboxes should be used. + * + * \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); + + simcall_rdv_set_receiver(mailbox, SIMIX_process_self()); + XBT_VERB("%s mailbox set to receive eagerly for process %p\n",alias, SIMIX_process_self()); - return host->simdata->mailboxes[(size_t) channel]; } -MSG_error_t -MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, m_task_t * task, - m_host_t host, double timeout) +/** \ingroup msg_mailbox_management + * \brief Get a task from a mailbox on a given host + * + * \param mailbox The mailbox where the task was sent + * \param task a memory location for storing a #msg_task_t. + * \param host a #msg_host_t host from where the task was sent + * \param timeout a timeout + + * \return Returns + * #MSG_OK if the task was successfully received, + * #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_host_t host, double timeout) { xbt_ex_t e; - MSG_error_t ret = MSG_OK; + msg_error_t ret = MSG_OK; /* We no longer support getting a task from a specific host */ if (host) THROW_UNIMPLEMENTED; - CHECK_HOST(); #ifdef HAVE_TRACING TRACE_msg_task_get_start(); double start_time = MSG_get_clock(); @@ -86,20 +105,17 @@ MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, m_task_t * task, xbt_assert(task, "Null pointer for the task storage"); if (*task) - XBT_CRITICAL - ("MSG_task_get() was asked to write in a non empty task struct."); + XBT_WARN + ("Asked to write the received task in a non empty struct -- proceeding."); /* Try to receive it by calling SIMIX network layer */ TRY { - SIMIX_req_comm_recv(mailbox, task, NULL, NULL, NULL, timeout); + 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 host_error: - ret = MSG_HOST_FAILURE; - break; case network_error: ret = MSG_TRANSFER_FAILURE; break; @@ -122,34 +138,30 @@ MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, m_task_t * task, MSG_RETURN(ret); } -MSG_error_t -MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, +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; + msg_error_t ret = MSG_OK; simdata_task_t t_simdata = NULL; - m_process_t process = MSG_process_self(); - simdata_process_t p_simdata = SIMIX_process_self_get_data(); -#ifdef HAVE_TRACING - volatile smx_action_t comm = NULL; - int call_end = 0; -#endif - CHECK_HOST(); + msg_process_t process = MSG_process_self(); + simdata_process_t p_simdata = SIMIX_process_self_get_data(process); #ifdef HAVE_TRACING - call_end = TRACE_msg_task_put_start(task); //must be after CHECK_HOST() + 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 = MSG_host_self(); + 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!"); t_simdata->isused=1; + t_simdata->comm = NULL; msg_global->sent_msg++; @@ -157,29 +169,20 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, /* Try to send it by calling SIMIX network layer */ TRY { -#ifdef HAVE_TRACING - if (TRACE_is_enabled()) { - comm = SIMIX_req_comm_isend(mailbox, t_simdata->message_size, + smx_action_t comm = simcall_comm_isend(mailbox, t_simdata->message_size, t_simdata->rate, task, sizeof(void *), - NULL, NULL, 0); - t_simdata->comm = comm; - SIMIX_req_set_category(comm, task->category); - SIMIX_req_comm_wait(comm, timeout); - } else { -#endif - SIMIX_req_comm_send(mailbox, t_simdata->message_size, - t_simdata->rate, task, sizeof(void*), - NULL, NULL, timeout); + NULL, NULL, task, 0); #ifdef HAVE_TRACING + if (TRACE_is_enabled()) { + simcall_set_category(comm, task->category); } #endif + t_simdata->comm = comm; + simcall_comm_wait(comm, timeout); } CATCH(e) { switch (e.category) { - case host_error: - ret = MSG_HOST_FAILURE; - break; case network_error: ret = MSG_TRANSFER_FAILURE; break; @@ -195,6 +198,7 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, t_simdata->isused = 0; } + p_simdata->waiting_task = NULL; #ifdef HAVE_TRACING if (call_end) @@ -202,3 +206,17 @@ MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, #endif MSG_RETURN(ret); } + +#ifdef MSG_USE_DEPRECATED +msg_mailbox_t MSG_mailbox_get_by_channel(msg_host_t host, + m_channel_t channel) +{ + XBT_WARN("DEPRECATED! Now use MSG_mailbox_get_by_alias"); + xbt_assert((host != NULL), "Invalid host"); + xbt_assert((channel >= 0) + && (channel < msg_global->max_channel), "Invalid channel %d", + channel); + + return host->mailboxes[(size_t) channel]; +} +#endif