From: alegrand Date: Thu, 12 Jun 2008 09:38:53 +0000 (+0000) Subject: indent -i2 -kr X-Git-Tag: v3.3~370 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/88f37b6fb2e255b82a42d81005ecb4d40a96fc82 indent -i2 -kr git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@5609 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/src/msg/mailbox.h b/src/msg/mailbox.h index dce26e4a7d..640e7abc2e 100644 --- a/src/msg/mailbox.h +++ b/src/msg/mailbox.h @@ -6,20 +6,16 @@ #include "msg/datatypes.h" SG_BEGIN_DECL() - #define MAX_ALIAS_NAME ((size_t)260) - /* * Initialization of the mailbox module. */ -void -MSG_mailbox_mod_init(void); +void MSG_mailbox_mod_init(void); /* * Terminaison of the mailbox module. */ -void -MSG_mailbox_mod_exit(void); +void MSG_mailbox_mod_exit(void); /*! \brief MSG_mailbox_new - create a new mailbox. @@ -29,23 +25,22 @@ MSG_mailbox_mod_exit(void); * * \param alias The alias of the mailbox to create. * - * \return The newly created mailbox. + * \return The newly created mailbox. */ -msg_mailbox_t -MSG_mailbox_new(const char *alias); +msg_mailbox_t MSG_mailbox_new(const char *alias); /*! \brief MSG_mailbox_create - create a new mailbox. * - * The function MSG_mailbox_new creates a new mailbox identified by the key specified - * by the parameter alias and add it in the global dictionary but doesn't add it in - * the global dictionary. Typicaly, this type of mailbox is associated with a channel. + * The function MSG_mailbox_new creates a new mailbox identified by + * the key specified by the parameter alias and add it in the global + * dictionary but doesn't add it in the global dictionary. Typicaly, + * this type of mailbox is associated with a channel. * * \param alias The alias of the mailbox to create. * - * \return The newly created mailbox. + * \return The newly created mailbox. */ -msg_mailbox_t -MSG_mailbox_create(const char *alias); +msg_mailbox_t MSG_mailbox_create(const char *alias); /* \brief MSG_mailbox_free - release a mailbox from the memory. * @@ -54,10 +49,9 @@ MSG_mailbox_create(const char *alias); * * \param mailbox The mailbox to release. * - * \see MSG_mailbox_destroy. + * \see MSG_mailbox_destroy. */ -void -MSG_mailbox_free(void* mailbox); +void MSG_mailbox_free(void *mailbox); /* \brief MSG_mailbox_get_by_alias - get a mailbox from its alias. * @@ -67,22 +61,22 @@ MSG_mailbox_free(void* mailbox); * * \param alias The alias of the mailbox to return. * - * \return The mailbox associated with the alias specified as parameter - * or a new mailbox if the key does not match. + * \return The mailbox associated with the alias specified as parameter + * or a new mailbox if the key does not match. */ -msg_mailbox_t -MSG_mailbox_get_by_alias(const char* alias); +msg_mailbox_t MSG_mailbox_get_by_alias(const char *alias); /* \brief MSG_mailbox_get_by_channel - get a mailbox of the specified host from its channel. * - * The function MSG_mailbox_get_by_channel returns the mailbox of the specified host - * from the channel specified by the parameter channel. If the mailbox does not exists, - * the function fails. + * The function MSG_mailbox_get_by_channel returns the mailbox of the + * specified host from the channel specified by the parameter + * channel. If the mailbox does not exists, the function fails. * * \param host The host containing he mailbox to get. * \param channel The channel used to identify the mailbox. * - * \return The mailbox of the specified host associated the channel specified as parameter. + * \return The mailbox of the specified host associated the channel + * specified as parameter. * */ msg_mailbox_t @@ -95,71 +89,66 @@ MSG_mailbox_get_by_channel(m_host_t host, m_channel_t channel); * * \param mailbox The mailbox to get the alias. * - * \return The alias of the mailbox specified by the parameter mailbox. + * \return The alias of the mailbox specified by the parameter mailbox. */ -const char* -MSG_mailbox_get_alias(msg_mailbox_t mailbox); +const char *MSG_mailbox_get_alias(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_get_cond - get the simix condition of a mailbox. * - * The function MSG_mailbox_get_cond returns the condition of the mailbox specified - * by the parameter mailbox. + * The function MSG_mailbox_get_cond returns the condition of the + * mailbox specified by the parameter mailbox. * * \param mailbox The mailbox to get the condition. * - * \return The simix condition of the mailbox specified by the parameter mailbox. + * \return The simix condition of the mailbox specified by the parameter mailbox. */ -smx_cond_t -MSG_mailbox_get_cond(msg_mailbox_t mailbox); +smx_cond_t MSG_mailbox_get_cond(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_set_cond - set the simix condition of a mailbox. * - * The function MSG_mailbox_set_cond set the condition of the mailbox specified - * by the parameter mailbox. + * The function MSG_mailbox_set_cond set the condition of the mailbox + * specified by the parameter mailbox. * * \param mailbox The mailbox to set the condition. * \param cond The new simix condition of the mailbox. * */ -void -MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond); +void MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond); /*! \brief MSG_mailbox_get_hostname - get the name of the host owned a mailbox. * - * The function MSG_mailbox_get_hostname returns name of the host owned the mailbox specified - * by the parameter mailbox. + * The function MSG_mailbox_get_hostname returns name of the host + * owned the mailbox specified by the parameter mailbox. * * \param mailbox The mailbox to get the name of the host. * - * \return The name of the host owned the mailbox specified by the parameter mailbox. + * \return The name of the host owned the mailbox specified by the parameter mailbox. */ -const char* -MSG_mailbox_get_hostname(msg_mailbox_t mailbox); +const char *MSG_mailbox_get_hostname(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_set_hostname - set the name of the host owned a mailbox. * - * The function MSG_mailbox_set_hostname sets the name of the host owned the mailbox specified - * by the parameter mailbox. + * The function MSG_mailbox_set_hostname sets the name of the host + * owned the mailbox specified by the parameter mailbox. * * \param mailbox The mailbox to set the name of the host. * \param hostname The name of the owner of the mailbox. * */ -void -MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname); +void MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char *hostname); /*! \brief MSG_mailbox_is_empty - test if a mailbox is empty. * - * The function MSG_mailbox_is_empty tests if a mailbox is empty (contains no msg task). + * The function MSG_mailbox_is_empty tests if a mailbox is empty + * (contains no msg task). * * \param mailbox The mailbox to get test. * - * \return The function returns 1 if the mailbox is empty. Otherwise the function - * returns 0. + * \return The function returns 1 if the mailbox is empty. Otherwise the function + * returns 0. */ -int -MSG_mailbox_is_empty(msg_mailbox_t mailbox); +int MSG_mailbox_is_empty(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_put - put a task in a mailbox. * @@ -168,8 +157,7 @@ MSG_mailbox_is_empty(msg_mailbox_t mailbox); * \param mailbox The mailbox where put the task. * \param task The task to put in the mailbox. */ -void -MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task); +void MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task); /*! \brief MSG_mailbox_remove - remove a task from a mailbox. * @@ -178,8 +166,7 @@ MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task); * \param mailbox The mailbox concerned by this operation. * \param task The task to remove from the mailbox. */ -void -MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task); +void MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task); /*! \brief MSG_mailbox_get_head - get the task at the head of a mailbox. * @@ -189,10 +176,9 @@ MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task); * * \param mailbox The mailbox concerned by the operation. * - * \return The task at the head of the mailbox. + * \return The task at the head of the mailbox. */ -m_task_t -MSG_mailbox_get_head(msg_mailbox_t mailbox); +m_task_t MSG_mailbox_get_head(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_pop_head - get the task at the head of a mailbox * and remove it from it. @@ -202,21 +188,20 @@ MSG_mailbox_get_head(msg_mailbox_t mailbox); * * \param mailbox The mailbox concerned by the operation. * - * \return The task at the head of the mailbox. + * \return The task at the head of the mailbox. */ -m_task_t -MSG_mailbox_pop_head(msg_mailbox_t mailbox); +m_task_t MSG_mailbox_pop_head(msg_mailbox_t mailbox); /*! \brief MSG_mailbox_get_first_host_task - get the first msg task * of a specified mailbox, sended by a process of a specified host. * * \param mailbox The mailbox concerned by the operation. * \param host The msg host of the process that has sended the - * task. + * task. * - * \return The first task in the mailbox specified by the - * parameter mailbox and sended by a process located - * on the host specified by the parameter host. + * \return The first task in the mailbox specified by the + * parameter mailbox and sended by a process located + * on the host specified by the parameter host. */ m_task_t MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host); @@ -226,18 +211,17 @@ MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host); * * \param mailbox The mailbox concerned by the operation. * \param host The msg host containing the processes that have sended the - * tasks. + * tasks. * - * \return The number of tasks in the mailbox specified by the - * parameter mailbox and sended by all the processes located - * on the host specified by the parameter host. + * \return The number of tasks in the mailbox specified by the + * parameter mailbox and sended by all the processes located + * on the host specified by the parameter host. */ int -MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host); +MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, + m_host_t host); SG_END_DECL() - -#endif /* !SMX_MAILBOX_H */ - +#endif /* !SMX_MAILBOX_H */ diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c index d3444a2af7..22c8fb4ad7 100644 --- a/src/msg/msg_mailbox.c +++ b/src/msg/msg_mailbox.c @@ -4,474 +4,435 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_mailbox, msg, "Logging specific to MSG (mailbox)"); -static xbt_dict_t -msg_mailboxes = NULL; +static xbt_dict_t msg_mailboxes = NULL; -void -MSG_mailbox_mod_init(void) +void MSG_mailbox_mod_init(void) { - msg_mailboxes = xbt_dict_new(); + msg_mailboxes = xbt_dict_new(); } -void -MSG_mailbox_mod_exit(void) +void MSG_mailbox_mod_exit(void) { - xbt_dict_free(&msg_mailboxes); + xbt_dict_free(&msg_mailboxes); } -msg_mailbox_t -MSG_mailbox_create(const char *alias) +msg_mailbox_t MSG_mailbox_create(const char *alias) { - msg_mailbox_t mailbox = xbt_new0(s_msg_mailbox_t,1); - - mailbox->tasks = xbt_fifo_new(); - mailbox->cond = NULL; - mailbox->alias = alias ? xbt_strdup(alias) : NULL; - mailbox->hostname = NULL; - - return mailbox; + msg_mailbox_t mailbox = xbt_new0(s_msg_mailbox_t, 1); + + mailbox->tasks = xbt_fifo_new(); + mailbox->cond = NULL; + mailbox->alias = alias ? xbt_strdup(alias) : NULL; + mailbox->hostname = NULL; + + return mailbox; } -msg_mailbox_t -MSG_mailbox_new(const char *alias) +msg_mailbox_t MSG_mailbox_new(const char *alias) { - msg_mailbox_t mailbox = MSG_mailbox_create(alias); - - /* add the mbox in the dictionary */ - xbt_dict_set(msg_mailboxes, alias, mailbox, MSG_mailbox_free); - - return mailbox; + msg_mailbox_t mailbox = MSG_mailbox_create(alias); + + /* add the mbox in the dictionary */ + xbt_dict_set(msg_mailboxes, alias, mailbox, MSG_mailbox_free); + + return mailbox; } -void -MSG_mailbox_free(void* mailbox) +void MSG_mailbox_free(void *mailbox) { - msg_mailbox_t _mailbox = (msg_mailbox_t)mailbox; + msg_mailbox_t _mailbox = (msg_mailbox_t) mailbox; + + if (NULL != (_mailbox->hostname)) + free(_mailbox->hostname); - if(NULL != (_mailbox->hostname)) - free(_mailbox->hostname); + xbt_fifo_free(_mailbox->tasks); + free(_mailbox->alias); - xbt_fifo_free(_mailbox->tasks); - free(_mailbox->alias); - - free(_mailbox); + free(_mailbox); } -void -MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task) +void MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task) { - xbt_fifo_push(mailbox->tasks, task); + xbt_fifo_push(mailbox->tasks, task); } -smx_cond_t -MSG_mailbox_get_cond(msg_mailbox_t mailbox) +smx_cond_t MSG_mailbox_get_cond(msg_mailbox_t mailbox) { - return mailbox->cond; + return mailbox->cond; } -void -MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task) +void MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task) { - xbt_fifo_remove(mailbox->tasks,task); + xbt_fifo_remove(mailbox->tasks, task); } -int -MSG_mailbox_is_empty(msg_mailbox_t mailbox) +int MSG_mailbox_is_empty(msg_mailbox_t mailbox) { - return (NULL == xbt_fifo_get_first_item(mailbox->tasks)); + return (NULL == xbt_fifo_get_first_item(mailbox->tasks)); } -m_task_t -MSG_mailbox_pop_head(msg_mailbox_t mailbox) +m_task_t MSG_mailbox_pop_head(msg_mailbox_t mailbox) { - return (m_task_t)xbt_fifo_shift(mailbox->tasks); + return (m_task_t) xbt_fifo_shift(mailbox->tasks); } -m_task_t -MSG_mailbox_get_head(msg_mailbox_t mailbox) +m_task_t MSG_mailbox_get_head(msg_mailbox_t mailbox) { - xbt_fifo_item_t item; - - if(NULL == (item = xbt_fifo_get_first_item(mailbox->tasks))) - return NULL; - - return (m_task_t)xbt_fifo_get_item_content(item); + xbt_fifo_item_t item; + + if (NULL == (item = xbt_fifo_get_first_item(mailbox->tasks))) + return NULL; + + return (m_task_t) xbt_fifo_get_item_content(item); } m_task_t MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host) { - m_task_t task = NULL; - xbt_fifo_item_t item = NULL; + m_task_t task = NULL; + xbt_fifo_item_t item = NULL; - xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t) - if (task->simdata->source == host) { - xbt_fifo_remove_item(mailbox->tasks, item); - return task; - } + xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t) + if (task->simdata->source == host) { + xbt_fifo_remove_item(mailbox->tasks, item); + return task; + } - return NULL; + return NULL; } int -MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host) +MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, + m_host_t host) { - m_task_t task = NULL; - xbt_fifo_item_t item = NULL; - int count = 0; - - xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t) - { - if (task->simdata->source == host) - count++; - } - - return count; + m_task_t task = NULL; + xbt_fifo_item_t item = NULL; + int count = 0; + + xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t) { + if (task->simdata->source == host) + count++; + } + + return count; } -void -MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond) +void MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond) { - mailbox->cond = cond; + mailbox->cond = cond; } -const char* -MSG_mailbox_get_alias(msg_mailbox_t mailbox) +const char *MSG_mailbox_get_alias(msg_mailbox_t mailbox) { - return mailbox->alias; + return mailbox->alias; } -const char* -MSG_mailbox_get_hostname(msg_mailbox_t mailbox) +const char *MSG_mailbox_get_hostname(msg_mailbox_t mailbox) { - return mailbox->hostname; + return mailbox->hostname; } -void -MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname) +void MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char *hostname) { - mailbox->hostname = xbt_strdup(hostname); + mailbox->hostname = xbt_strdup(hostname); } -msg_mailbox_t -MSG_mailbox_get_by_alias(const char* alias) +msg_mailbox_t MSG_mailbox_get_by_alias(const char *alias) { - msg_mailbox_t mailbox = xbt_dict_get_or_null(msg_mailboxes,alias); - - if(!mailbox) - { - mailbox = MSG_mailbox_new(alias); - MSG_mailbox_set_hostname(mailbox,MSG_host_self()->name); - } - - return mailbox; + msg_mailbox_t mailbox = xbt_dict_get_or_null(msg_mailboxes, alias); + + if (!mailbox) { + mailbox = MSG_mailbox_new(alias); + MSG_mailbox_set_hostname(mailbox, MSG_host_self()->name); + } + + return mailbox; } msg_mailbox_t MSG_mailbox_get_by_channel(m_host_t host, m_channel_t channel) { - xbt_assert0((host != NULL), "Invalid host"); - xbt_assert1((channel >= 0)&& (channel < msg_global->max_channel), "Invalid channel %d",channel); + xbt_assert0((host != NULL), "Invalid host"); + xbt_assert1((channel >= 0) + && (channel < msg_global->max_channel), "Invalid channel %d", + channel); - return host->simdata->mailboxes[(size_t)channel]; + 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) +MSG_error_t +MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, m_task_t * task, + m_host_t host, double timeout) { - m_process_t process = MSG_process_self(); - m_task_t t = NULL; - m_host_t h = NULL; - simdata_task_t t_simdata = NULL; - simdata_host_t h_simdata = NULL; - int first_time = 1; - - smx_cond_t cond = NULL; //conditional wait if the task isn't on the channel yet - - CHECK_HOST(); - - /* Sanity check */ - xbt_assert0(task, "Null pointer for the task storage"); - - if (*task) - CRITICAL0("MSG_task_get() was asked to write in a non empty task struct."); - - /* Get the task */ - h = MSG_host_self(); - h_simdata = h->simdata; - - SIMIX_mutex_lock(h->simdata->mutex); - - while (1) - { - /* if the mailbox is empty (has no task */ - if(!MSG_mailbox_is_empty(mailbox)) - { - if(!host) - { - /* pop the head of the mailbox */ - t = MSG_mailbox_pop_head(mailbox); - break; - } - else - { - /* get the first task of the host */ - if(NULL != (t = MSG_mailbox_get_first_host_task(mailbox,host))) - break; - } - } - - if(timeout > 0) - { - if (!first_time) - { - SIMIX_mutex_unlock(h->simdata->mutex); - /* set the simix condition of the mailbox to NULL */ - MSG_mailbox_set_cond(mailbox, NULL); - SIMIX_cond_destroy(cond); - MSG_RETURN(MSG_TRANSFER_FAILURE); - } - } - - xbt_assert1(!MSG_mailbox_get_cond(mailbox),"A process is already blocked on the channel %s", MSG_mailbox_get_alias(mailbox)); - - cond = SIMIX_cond_init(); - - /* set the condition of the mailbox */ - MSG_mailbox_set_cond(mailbox, cond); - - if (timeout > 0) - SIMIX_cond_wait_timeout(cond, h->simdata->mutex, timeout); - else - SIMIX_cond_wait(MSG_mailbox_get_cond(mailbox), h->simdata->mutex); - - - if (SIMIX_host_get_state(h_simdata->smx_host) == 0) - MSG_RETURN(MSG_HOST_FAILURE); - - first_time = 0; - } - + m_process_t process = MSG_process_self(); + m_task_t t = NULL; + m_host_t h = NULL; + simdata_task_t t_simdata = NULL; + simdata_host_t h_simdata = NULL; + int first_time = 1; + + smx_cond_t cond = NULL; //conditional wait if the task isn't on the channel yet + + CHECK_HOST(); + + /* Sanity check */ + xbt_assert0(task, "Null pointer for the task storage"); + + if (*task) + CRITICAL0 + ("MSG_task_get() was asked to write in a non empty task struct."); + + /* Get the task */ + h = MSG_host_self(); + h_simdata = h->simdata; + + SIMIX_mutex_lock(h->simdata->mutex); + + while (1) { + /* if the mailbox is empty (has no task */ + if (!MSG_mailbox_is_empty(mailbox)) { + if (!host) { + /* pop the head of the mailbox */ + t = MSG_mailbox_pop_head(mailbox); + break; + } else { + /* get the first task of the host */ + if (NULL != (t = MSG_mailbox_get_first_host_task(mailbox, host))) + break; + } + } + + if (timeout > 0) { + if (!first_time) { SIMIX_mutex_unlock(h->simdata->mutex); - - DEBUG1("OK, got a task (%s)", t->name); - /* clean conditional */ - if (cond) - { - SIMIX_cond_destroy(cond); - - MSG_mailbox_set_cond(mailbox,NULL); - } - - t_simdata = t->simdata; - t_simdata->receiver = process; - *task = t; - - SIMIX_mutex_lock(t_simdata->mutex); - - /* Transfer */ - /* create SIMIX action to the communication */ - t_simdata->comm = SIMIX_action_communicate( - t_simdata->sender->simdata->m_host->simdata->smx_host, - process->simdata->m_host->simdata->smx_host, - t->name, - t_simdata->message_size, - t_simdata->rate - ); - - /* if the process is suspend, create the action but stop its execution, it will be restart when the sender process resume */ - if (MSG_process_is_suspended(t_simdata->sender)) - { - DEBUG1("Process sender (%s) suspended", t_simdata->sender->name); - SIMIX_action_set_priority(t_simdata->comm, 0); - } - - process->simdata->waiting_task = t; - SIMIX_register_action_to_condition(t_simdata->comm, t_simdata->cond); - - while (1) - { - SIMIX_cond_wait(t_simdata->cond, t_simdata->mutex); - - if (SIMIX_action_get_state(t_simdata->comm) != SURF_ACTION_RUNNING) - break; - } - - SIMIX_unregister_action_to_condition(t_simdata->comm, t_simdata->cond); - process->simdata->waiting_task = NULL; - - /* the task has already finished and the pointer must be null */ - if (t->simdata->sender) - { - t->simdata->sender->simdata->waiting_task = NULL; - } - - /* for this process, don't need to change in get function */ - t->simdata->receiver = NULL; - SIMIX_mutex_unlock(t_simdata->mutex); - - - if (SIMIX_action_get_state(t_simdata->comm) == SURF_ACTION_DONE) - { - SIMIX_action_destroy(t_simdata->comm); - t_simdata->comm = NULL; - t_simdata->using--; - MSG_RETURN(MSG_OK); - } - else if (SIMIX_host_get_state(h_simdata->smx_host) == 0) - { - SIMIX_action_destroy(t_simdata->comm); - t_simdata->comm = NULL; - t_simdata->using--; - MSG_RETURN(MSG_HOST_FAILURE); - } - else - { - SIMIX_action_destroy(t_simdata->comm); - t_simdata->comm = NULL; - t_simdata->using--; - MSG_RETURN(MSG_TRANSFER_FAILURE); - } + /* set the simix condition of the mailbox to NULL */ + MSG_mailbox_set_cond(mailbox, NULL); + SIMIX_cond_destroy(cond); + MSG_RETURN(MSG_TRANSFER_FAILURE); + } + } + + xbt_assert1(!MSG_mailbox_get_cond(mailbox), + "A process is already blocked on the channel %s", + MSG_mailbox_get_alias(mailbox)); + + cond = SIMIX_cond_init(); + + /* set the condition of the mailbox */ + MSG_mailbox_set_cond(mailbox, cond); + + if (timeout > 0) + SIMIX_cond_wait_timeout(cond, h->simdata->mutex, timeout); + else + SIMIX_cond_wait(MSG_mailbox_get_cond(mailbox), h->simdata->mutex); + + + if (SIMIX_host_get_state(h_simdata->smx_host) == 0) + MSG_RETURN(MSG_HOST_FAILURE); + + first_time = 0; + } + + SIMIX_mutex_unlock(h->simdata->mutex); + + DEBUG1("OK, got a task (%s)", t->name); + /* clean conditional */ + if (cond) { + SIMIX_cond_destroy(cond); + + MSG_mailbox_set_cond(mailbox, NULL); + } + + t_simdata = t->simdata; + t_simdata->receiver = process; + *task = t; + + SIMIX_mutex_lock(t_simdata->mutex); + + /* Transfer */ + /* create SIMIX action to the communication */ + t_simdata->comm = + SIMIX_action_communicate(t_simdata->sender->simdata->m_host-> + simdata->smx_host, + process->simdata->m_host->simdata->smx_host, + t->name, t_simdata->message_size, + t_simdata->rate); + + /* if the process is suspend, create the action but stop its execution, it will be restart when the sender process resume */ + if (MSG_process_is_suspended(t_simdata->sender)) { + DEBUG1("Process sender (%s) suspended", t_simdata->sender->name); + SIMIX_action_set_priority(t_simdata->comm, 0); + } + + process->simdata->waiting_task = t; + SIMIX_register_action_to_condition(t_simdata->comm, t_simdata->cond); + + while (1) { + SIMIX_cond_wait(t_simdata->cond, t_simdata->mutex); + + if (SIMIX_action_get_state(t_simdata->comm) != SURF_ACTION_RUNNING) + break; + } + + SIMIX_unregister_action_to_condition(t_simdata->comm, t_simdata->cond); + process->simdata->waiting_task = NULL; + + /* the task has already finished and the pointer must be null */ + if (t->simdata->sender) { + t->simdata->sender->simdata->waiting_task = NULL; + } + + /* for this process, don't need to change in get function */ + t->simdata->receiver = NULL; + SIMIX_mutex_unlock(t_simdata->mutex); + + + if (SIMIX_action_get_state(t_simdata->comm) == SURF_ACTION_DONE) { + SIMIX_action_destroy(t_simdata->comm); + t_simdata->comm = NULL; + t_simdata->using--; + MSG_RETURN(MSG_OK); + } else if (SIMIX_host_get_state(h_simdata->smx_host) == 0) { + SIMIX_action_destroy(t_simdata->comm); + t_simdata->comm = NULL; + t_simdata->using--; + MSG_RETURN(MSG_HOST_FAILURE); + } else { + SIMIX_action_destroy(t_simdata->comm); + t_simdata->comm = NULL; + t_simdata->using--; + MSG_RETURN(MSG_TRANSFER_FAILURE); + } } -MSG_error_t -MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, double timeout) +MSG_error_t +MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, + double timeout) { - m_process_t process = MSG_process_self(); - const char* hostname; - simdata_task_t task_simdata = NULL; - m_host_t local_host = NULL; - m_host_t remote_host = NULL; - smx_cond_t cond = NULL; - - CHECK_HOST(); - - task_simdata = task->simdata; - task_simdata->sender = process; - task_simdata->source = MSG_process_get_host(process); - - xbt_assert0(task_simdata->using == 1,"This task is still being used somewhere else. You cannot send it now. Go fix your code!"); - - task_simdata->comm = NULL; - - task_simdata->using++; - local_host = ((simdata_process_t) process->simdata)->m_host; - - /* get the host name containing the mailbox */ - hostname = MSG_mailbox_get_hostname(mailbox); - - remote_host = MSG_get_host_by_name(hostname); - - if(NULL == remote_host) - THROW1(not_found_error,0,"Host %s not fount", hostname); - - - DEBUG4("Trying to send a task (%g kB) from %s to %s on the channel aliased by the alias %s",task->simdata->message_size / 1000, local_host->name,remote_host->name, MSG_mailbox_get_alias(mailbox)); - - SIMIX_mutex_lock(remote_host->simdata->mutex); - - /* put the task in the mailbox */ - MSG_mailbox_put(mailbox,task); - - if(NULL != (cond = MSG_mailbox_get_cond(mailbox))) - { - DEBUG0("Somebody is listening. Let's wake him up!"); - SIMIX_cond_signal(cond); - } + m_process_t process = MSG_process_self(); + const char *hostname; + simdata_task_t task_simdata = NULL; + m_host_t local_host = NULL; + m_host_t remote_host = NULL; + smx_cond_t cond = NULL; - - - SIMIX_mutex_unlock(remote_host->simdata->mutex); - - SIMIX_mutex_lock(task->simdata->mutex); - - process->simdata->waiting_task = task; - - if(timeout > 0) - { - xbt_ex_t e; - double time; - double time_elapsed; - time = SIMIX_get_clock(); - - TRY - { - /*verify if the action that ends is the correct. Call the wait_timeout with the new time. If the timeout occurs, an exception is raised */ - while (1) - { - time_elapsed = SIMIX_get_clock() - time; - SIMIX_cond_wait_timeout(task->simdata->cond, task->simdata->mutex,timeout - time_elapsed); - - if ((task->simdata->comm != NULL) && (SIMIX_action_get_state(task->simdata->comm) != SURF_ACTION_RUNNING)) - break; - } - } - CATCH(e) - { - if(e.category==timeout_error) - { - xbt_ex_free(e); - /* verify if the timeout happened and the communication didn't started yet */ - if (task->simdata->comm == NULL) - { - process->simdata->waiting_task = NULL; - - /* remove the task from the mailbox */ - MSG_mailbox_remove(mailbox,task); - - if (task->simdata->receiver) - { - task->simdata->receiver->simdata->waiting_task = NULL; - } - - task->simdata->sender = NULL; - - SIMIX_mutex_unlock(task->simdata->mutex); - MSG_RETURN(MSG_TRANSFER_FAILURE); - } - } - else - { - RETHROW; - } - } - } - else - { - while (1) - { - SIMIX_cond_wait(task->simdata->cond, task->simdata->mutex); - - if (SIMIX_action_get_state(task->simdata->comm) != SURF_ACTION_RUNNING) - break; - } - } - - DEBUG1("Action terminated %s", task->name); - process->simdata->waiting_task = NULL; - - /* the task has already finished and the pointer must be null */ - if (task->simdata->receiver) - { - task->simdata->receiver->simdata->waiting_task = NULL; - } - - task->simdata->sender = NULL; - SIMIX_mutex_unlock(task->simdata->mutex); - - - if (SIMIX_action_get_state(task->simdata->comm) == SURF_ACTION_DONE) - { - MSG_RETURN(MSG_OK); - } - else if (SIMIX_host_get_state(local_host->simdata->smx_host) == 0) - { - MSG_RETURN(MSG_HOST_FAILURE); - } - else - { - MSG_RETURN(MSG_TRANSFER_FAILURE); + CHECK_HOST(); + + task_simdata = task->simdata; + task_simdata->sender = process; + task_simdata->source = MSG_process_get_host(process); + + xbt_assert0(task_simdata->using == 1, + "This task is still being used somewhere else. You cannot send it now. Go fix your code!"); + + task_simdata->comm = NULL; + + task_simdata->using++; + local_host = ((simdata_process_t) process->simdata)->m_host; + + /* get the host name containing the mailbox */ + hostname = MSG_mailbox_get_hostname(mailbox); + + remote_host = MSG_get_host_by_name(hostname); + + if (NULL == remote_host) + THROW1(not_found_error, 0, "Host %s not fount", hostname); + + + DEBUG4 + ("Trying to send a task (%g kB) from %s to %s on the channel aliased by the alias %s", + task->simdata->message_size / 1000, local_host->name, + remote_host->name, MSG_mailbox_get_alias(mailbox)); + + SIMIX_mutex_lock(remote_host->simdata->mutex); + + /* put the task in the mailbox */ + MSG_mailbox_put(mailbox, task); + + if (NULL != (cond = MSG_mailbox_get_cond(mailbox))) { + DEBUG0("Somebody is listening. Let's wake him up!"); + SIMIX_cond_signal(cond); + } + + + + SIMIX_mutex_unlock(remote_host->simdata->mutex); + + SIMIX_mutex_lock(task->simdata->mutex); + + process->simdata->waiting_task = task; + + if (timeout > 0) { + xbt_ex_t e; + double time; + double time_elapsed; + time = SIMIX_get_clock(); + + TRY { + /*verify if the action that ends is the correct. Call the wait_timeout with the new time. If the timeout occurs, an exception is raised */ + while (1) { + time_elapsed = SIMIX_get_clock() - time; + SIMIX_cond_wait_timeout(task->simdata->cond, task->simdata->mutex, + timeout - time_elapsed); + + if ((task->simdata->comm != NULL) + && (SIMIX_action_get_state(task->simdata->comm) != + SURF_ACTION_RUNNING)) + break; + } + } + CATCH(e) { + if (e.category == timeout_error) { + xbt_ex_free(e); + /* verify if the timeout happened and the communication didn't started yet */ + if (task->simdata->comm == NULL) { + process->simdata->waiting_task = NULL; + + /* remove the task from the mailbox */ + MSG_mailbox_remove(mailbox, task); + + if (task->simdata->receiver) { + task->simdata->receiver->simdata->waiting_task = NULL; + } + + task->simdata->sender = NULL; + + SIMIX_mutex_unlock(task->simdata->mutex); + MSG_RETURN(MSG_TRANSFER_FAILURE); } + } else { + RETHROW; + } + } + } else { + while (1) { + SIMIX_cond_wait(task->simdata->cond, task->simdata->mutex); + + if (SIMIX_action_get_state(task->simdata->comm) != + SURF_ACTION_RUNNING) + break; + } + } + + DEBUG1("Action terminated %s", task->name); + process->simdata->waiting_task = NULL; + + /* the task has already finished and the pointer must be null */ + if (task->simdata->receiver) { + task->simdata->receiver->simdata->waiting_task = NULL; + } + + task->simdata->sender = NULL; + SIMIX_mutex_unlock(task->simdata->mutex); + + + if (SIMIX_action_get_state(task->simdata->comm) == SURF_ACTION_DONE) { + MSG_RETURN(MSG_OK); + } else if (SIMIX_host_get_state(local_host->simdata->smx_host) == 0) { + MSG_RETURN(MSG_HOST_FAILURE); + } else { + MSG_RETURN(MSG_TRANSFER_FAILURE); + } }