dos2unix

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@5608 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/src/msg/mailbox.h b/src/msg/mailbox.h
index f0414af..dce26e4 100644 (file)
--- a/src/msg/mailbox.h
+++ b/src/msg/mailbox.h
@@ -1,243 +1,243 @@
-#ifndef SMX_MAILBOX_H\r
-#define SMX_MAILBOX_H\r
-\r
-#include "xbt/fifo.h"\r
-#include "simix/private.h"\r
-#include "msg/datatypes.h"\r
-\r
-SG_BEGIN_DECL()\r
-\r
-#define MAX_ALIAS_NAME ((size_t)260)\r
-\r
-/*\r
- * Initialization of the mailbox module.\r
- */\r
-void\r
-MSG_mailbox_mod_init(void);\r
-\r
-/*\r
- * Terminaison of the mailbox module.\r
- */\r
-void\r
-MSG_mailbox_mod_exit(void);\r
-\r
-\r
-/*! \brief MSG_mailbox_new - create a new mailbox.\r
- *\r
- * The function MSG_mailbox_new creates a new mailbox identified by the key specified\r
- * by the parameter alias and add it in the global dictionary.\r
- *\r
- * \param alias                The alias of the mailbox to create.\r
- * \r
- * \return                     The newly created mailbox.\r
- */\r
-msg_mailbox_t\r
-MSG_mailbox_new(const char *alias);\r
-\r
-/*! \brief MSG_mailbox_create - create a new mailbox.\r
- *\r
- * The function MSG_mailbox_new creates a new mailbox identified by the key specified\r
- * by the parameter alias and add it in the global dictionary but doesn't add it in\r
- * the global dictionary. Typicaly, this type of mailbox is associated with a channel.\r
- *\r
- * \param alias                The alias of the mailbox to create.\r
- * \r
- * \return                     The newly created mailbox.\r
- */\r
-msg_mailbox_t\r
-MSG_mailbox_create(const char *alias);\r
-\r
-/* \brief MSG_mailbox_free - release a mailbox from the memory.\r
- *\r
- * The function MSG_mailbox_free release a mailbox from the memory but does\r
- * not remove it from the dictionary.\r
- *\r
- * \param mailbox      The mailbox to release.\r
- *\r
- * \see                                MSG_mailbox_destroy.\r
- */\r
-void\r
-MSG_mailbox_free(void* mailbox);\r
-\r
-/* \brief MSG_mailbox_get_by_alias - get a mailbox from its alias.\r
- *\r
- * The function MSG_mailbox_get_by_alias returns the mailbox associated with\r
- * the key specified by the parameter alias. If the mailbox does not exists,\r
- * the function create it.\r
- *\r
- * \param alias                The alias of the mailbox to return.\r
- *\r
- * \return                     The mailbox associated with the alias specified as parameter\r
- *                                     or a new mailbox if the key does not match.\r
- */\r
-msg_mailbox_t\r
-MSG_mailbox_get_by_alias(const char* alias);\r
-\r
-/* \brief MSG_mailbox_get_by_channel - get a mailbox of the specified host from its channel.\r
- *\r
- * The function MSG_mailbox_get_by_channel returns the mailbox of the specified host\r
- * from the channel specified by the parameter channel. If the mailbox does not exists,\r
- * the function fails.\r
- *\r
- * \param host         The host containing he mailbox to get.\r
- * \param channel      The channel used to identify the mailbox.\r
- *\r
- * \return                     The mailbox of the specified host associated the channel specified as parameter.\r
- *             \r
- */\r
-msg_mailbox_t\r
-MSG_mailbox_get_by_channel(m_host_t host, m_channel_t channel);\r
-\r
-/*! \brief MSG_mailbox_get_alias - get the alias associated with the mailbox.\r
- *\r
- * The function MSG_mailbox_get_alias returns the alias of the mailbox specified\r
- * by the parameter mailbox.\r
- *\r
- * \param mailbox      The mailbox to get the alias.\r
- *\r
- * \return                     The alias of the mailbox specified by the parameter mailbox.\r
- */\r
-const char*\r
-MSG_mailbox_get_alias(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_get_cond - get the simix condition of a mailbox.\r
- *\r
- * The function MSG_mailbox_get_cond returns the condition of the mailbox specified\r
- * by the parameter mailbox.\r
- *\r
- * \param mailbox      The mailbox to get the condition.\r
- *\r
- * \return                     The simix condition of the mailbox specified by the parameter mailbox.\r
- */\r
-smx_cond_t\r
-MSG_mailbox_get_cond(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_set_cond - set the simix condition of a mailbox.\r
- *\r
- * The function MSG_mailbox_set_cond set the condition of the mailbox specified\r
- * by the parameter mailbox.\r
- *\r
- * \param mailbox      The mailbox to set the condition.\r
- * \param cond         The new simix condition of the mailbox.\r
- *\r
- */\r
-void\r
-MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond);\r
-\r
-/*! \brief MSG_mailbox_get_hostname - get the name of the host owned a mailbox.\r
- *\r
- * The function MSG_mailbox_get_hostname returns name of the host owned the mailbox specified\r
- * by the parameter mailbox.\r
- *\r
- * \param mailbox      The mailbox to get the name of the host.\r
- *\r
- * \return                     The name of the host owned the mailbox specified by the parameter mailbox.\r
- */\r
-const char*\r
-MSG_mailbox_get_hostname(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_set_hostname - set the name of the host owned a mailbox.\r
- *\r
- * The function MSG_mailbox_set_hostname sets the name of the host owned the mailbox specified\r
- * by the parameter mailbox.\r
- *\r
- * \param mailbox      The mailbox to set the name of the host.\r
- * \param hostname     The name of the owner of the mailbox.\r
- *\r
- */\r
-void\r
-MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname);\r
-\r
-\r
-/*! \brief MSG_mailbox_is_empty - test if a mailbox is empty.\r
- *\r
- * The function MSG_mailbox_is_empty tests if a mailbox is empty (contains no msg task). \r
- *\r
- * \param mailbox      The mailbox to get test.\r
- *\r
- * \return                     The function returns 1 if the mailbox is empty. Otherwise the function\r
- *                                     returns 0.\r
- */\r
-int\r
-MSG_mailbox_is_empty(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_put - put a task in a mailbox.\r
- *\r
- * The MSG_mailbox_put puts a task in a specified mailbox.\r
- *\r
- * \param mailbox      The mailbox where put the task.\r
- * \param task         The task to put in the mailbox.\r
- */\r
-void\r
-MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task);\r
-\r
-/*! \brief MSG_mailbox_remove - remove a task from a mailbox.\r
- *\r
- * The MSG_mailbox_remove removes a task from a specified mailbox.\r
- *\r
- * \param mailbox      The mailbox concerned by this operation.\r
- * \param task         The task to remove from the mailbox.\r
- */\r
-void\r
-MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task);\r
-\r
-/*! \brief MSG_mailbox_get_head - get the task at the head of a mailbox.\r
- *\r
- * The MSG_mailbox_get_head returns the task at the head of the mailbox.\r
- * This function does not remove the task from the mailbox (contrary to\r
- * the function MSG_mailbox_pop_head).\r
- *\r
- * \param mailbox      The mailbox concerned by the operation.\r
- *\r
- * \return                     The task at the head of the mailbox.\r
- */\r
-m_task_t\r
-MSG_mailbox_get_head(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_pop_head - get the task at the head of a mailbox\r
- * and remove it from it.\r
- *\r
- * The MSG_mailbox_pop_head returns the task at the head of the mailbox\r
- * and remove it from it.\r
- *\r
- * \param mailbox      The mailbox concerned by the operation.\r
- *\r
- * \return                     The task at the head of the mailbox.\r
- */\r
-m_task_t\r
-MSG_mailbox_pop_head(msg_mailbox_t mailbox);\r
-\r
-/*! \brief MSG_mailbox_get_first_host_task - get the first msg task\r
- * of a specified mailbox, sended by a process of a specified host.\r
- *\r
- * \param mailbox      The mailbox concerned by the operation.\r
- * \param host         The msg host of the process that has sended the\r
- *                                     task.\r
- *\r
- * \return                     The first task in the mailbox specified by the\r
- *                                     parameter mailbox and sended by a process located\r
- *                                     on the host specified by the parameter host.\r
- */\r
-m_task_t\r
-MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host);\r
-\r
-/*! \brief MSG_mailbox_get_count_host_waiting_tasks - Return the number of tasks \r
-   waiting to be received in a mailbox and sent by a host.\r
- *\r
- * \param mailbox      The mailbox concerned by the operation.\r
- * \param host         The msg host containing the processes that have sended the\r
- *                                     tasks.\r
- *\r
- * \return                     The number of tasks in the mailbox specified by the\r
- *                                     parameter mailbox and sended by all the processes located\r
- *                                     on the host specified by the parameter host.\r
- */\r
-int\r
-MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host);\r
-\r
-\r
-SG_END_DECL()\r
-\r
-\r
-#endif /* !SMX_MAILBOX_H */\r
-\r
+#ifndef SMX_MAILBOX_H
+#define SMX_MAILBOX_H
+
+#include "xbt/fifo.h"
+#include "simix/private.h"
+#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);
+
+/*
+ * Terminaison of the mailbox module.
+ */
+void
+MSG_mailbox_mod_exit(void);
+
+
+/*! \brief MSG_mailbox_new - 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.
+ *
+ * \param alias                The alias of the mailbox to create.
+ * 
+ * \return                     The newly created mailbox.
+ */
+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.
+ *
+ * \param alias                The alias of the mailbox to create.
+ * 
+ * \return                     The newly created mailbox.
+ */
+msg_mailbox_t
+MSG_mailbox_create(const char *alias);
+
+/* \brief MSG_mailbox_free - release a mailbox from the memory.
+ *
+ * The function MSG_mailbox_free release a mailbox from the memory but does
+ * not remove it from the dictionary.
+ *
+ * \param mailbox      The mailbox to release.
+ *
+ * \see                                MSG_mailbox_destroy.
+ */
+void
+MSG_mailbox_free(void* mailbox);
+
+/* \brief MSG_mailbox_get_by_alias - get a mailbox from its alias.
+ *
+ * The function MSG_mailbox_get_by_alias returns the mailbox associated with
+ * the key specified by the parameter alias. If the mailbox does not exists,
+ * the function create it.
+ *
+ * \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.
+ */
+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.
+ *
+ * \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.
+ *             
+ */
+msg_mailbox_t
+MSG_mailbox_get_by_channel(m_host_t host, m_channel_t channel);
+
+/*! \brief MSG_mailbox_get_alias - get the alias associated with the mailbox.
+ *
+ * The function MSG_mailbox_get_alias returns the alias of the mailbox specified
+ * by the parameter mailbox.
+ *
+ * \param mailbox      The mailbox to get the alias.
+ *
+ * \return                     The alias of the mailbox specified by the parameter 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.
+ *
+ * \param mailbox      The mailbox to get the condition.
+ *
+ * \return                     The simix condition of the mailbox specified by the parameter 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.
+ *
+ * \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);
+
+/*! \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.
+ *
+ * \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.
+ */
+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.
+ *
+ * \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);
+
+
+/*! \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). 
+ *
+ * \param mailbox      The mailbox to get test.
+ *
+ * \return                     The function returns 1 if the mailbox is empty. Otherwise the function
+ *                                     returns 0.
+ */
+int
+MSG_mailbox_is_empty(msg_mailbox_t mailbox);
+
+/*! \brief MSG_mailbox_put - put a task in a mailbox.
+ *
+ * The MSG_mailbox_put puts a task in a specified 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);
+
+/*! \brief MSG_mailbox_remove - remove a task from a mailbox.
+ *
+ * The MSG_mailbox_remove removes a task from a specified mailbox.
+ *
+ * \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);
+
+/*! \brief MSG_mailbox_get_head - get the task at the head of a mailbox.
+ *
+ * The MSG_mailbox_get_head returns the task at the head of the mailbox.
+ * This function does not remove the task from the mailbox (contrary to
+ * the function MSG_mailbox_pop_head).
+ *
+ * \param mailbox      The mailbox concerned by the operation.
+ *
+ * \return                     The task at the head of the 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.
+ *
+ * The MSG_mailbox_pop_head returns the task at the head of the mailbox
+ * and remove it from it.
+ *
+ * \param mailbox      The mailbox concerned by the operation.
+ *
+ * \return                     The task at the head of the 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.
+ *
+ * \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);
+
+/*! \brief MSG_mailbox_get_count_host_waiting_tasks - Return the number of tasks 
+   waiting to be received in a mailbox and sent by a host.
+ *
+ * \param mailbox      The mailbox concerned by the operation.
+ * \param host         The msg host containing the processes that have sended the
+ *                                     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.
+ */
+int
+MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host);
+
+
+SG_END_DECL()
+
+
+#endif /* !SMX_MAILBOX_H */
+

diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c
index 1faac65..d3444a2 100644 (file)
--- a/src/msg/msg_mailbox.c
+++ b/src/msg/msg_mailbox.c
@@ -1,477 +1,477 @@
-#include "mailbox.h"\r
-#include "msg/private.h"\r
-\r
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_mailbox, msg,\r
-                               "Logging specific to MSG (mailbox)");\r
-\r
-static xbt_dict_t \r
-msg_mailboxes = NULL;\r
-\r
-void\r
-MSG_mailbox_mod_init(void)\r
-{\r
-       msg_mailboxes = xbt_dict_new(); \r
-}\r
-\r
-void\r
-MSG_mailbox_mod_exit(void)\r
-{\r
-       xbt_dict_free(&msg_mailboxes);\r
-}\r
-\r
-msg_mailbox_t\r
-MSG_mailbox_create(const char *alias)\r
-{\r
-       msg_mailbox_t mailbox = xbt_new0(s_msg_mailbox_t,1);\r
-       \r
-       mailbox->tasks = xbt_fifo_new();\r
-       mailbox->cond = NULL;\r
-        mailbox->alias = alias ? xbt_strdup(alias) : NULL;\r
-       mailbox->hostname = NULL;\r
-       \r
-       return mailbox;\r
-}\r
-\r
-msg_mailbox_t\r
-MSG_mailbox_new(const char *alias)\r
-{\r
-       msg_mailbox_t mailbox = MSG_mailbox_create(alias);\r
-       \r
-       /* add the mbox in the dictionary */\r
-       xbt_dict_set(msg_mailboxes, alias, mailbox, MSG_mailbox_free);\r
-       \r
-       return mailbox;\r
-}\r
-\r
-void\r
-MSG_mailbox_free(void* mailbox)\r
-{\r
-       msg_mailbox_t _mailbox = (msg_mailbox_t)mailbox;\r
-\r
-       if(NULL != (_mailbox->hostname))\r
-               free(_mailbox->hostname);\r
-\r
-       xbt_fifo_free(_mailbox->tasks);\r
-       free(_mailbox->alias);\r
-       \r
-       free(_mailbox);\r
-}\r
-\r
-void\r
-MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task)\r
-{\r
-       xbt_fifo_push(mailbox->tasks, task);\r
-}\r
-\r
-smx_cond_t\r
-MSG_mailbox_get_cond(msg_mailbox_t mailbox)\r
-{\r
-       return mailbox->cond;\r
-}\r
-\r
-void\r
-MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task)\r
-{\r
-       xbt_fifo_remove(mailbox->tasks,task);\r
-}\r
-\r
-int\r
-MSG_mailbox_is_empty(msg_mailbox_t mailbox)\r
-{\r
-       return (NULL == xbt_fifo_get_first_item(mailbox->tasks));\r
-}\r
-\r
-m_task_t\r
-MSG_mailbox_pop_head(msg_mailbox_t mailbox)\r
-{\r
-       return (m_task_t)xbt_fifo_shift(mailbox->tasks);\r
-}\r
-\r
-m_task_t\r
-MSG_mailbox_get_head(msg_mailbox_t mailbox)\r
-{\r
-       xbt_fifo_item_t item;\r
-       \r
-       if(NULL == (item = xbt_fifo_get_first_item(mailbox->tasks)))\r
-               return NULL;\r
-               \r
-       return (m_task_t)xbt_fifo_get_item_content(item);\r
-}\r
-\r
-\r
-m_task_t\r
-MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host)\r
-{\r
- m_task_t task = NULL;\r
- xbt_fifo_item_t item = NULL;\r
-\r
- xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t)\r
-   if (task->simdata->source == host) {\r
-     xbt_fifo_remove_item(mailbox->tasks, item);\r
-     return task;\r
-   }\r
-\r
- return NULL;\r
-}\r
-\r
-int\r
-MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host)\r
-{\r
-       m_task_t task = NULL;\r
-       xbt_fifo_item_t item = NULL;\r
-       int count = 0;\r
-       \r
-       xbt_fifo_foreach(mailbox->tasks, item, task, m_task_t) \r
-       {\r
-               if (task->simdata->source == host)\r
-                       count++;\r
-       }\r
-               \r
-       return count;\r
-}\r
-\r
-void\r
-MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond)\r
-{\r
-       mailbox->cond = cond;\r
-}\r
-\r
-const char*\r
-MSG_mailbox_get_alias(msg_mailbox_t mailbox)\r
-{\r
-       return mailbox->alias;\r
-}\r
-\r
-const char*\r
-MSG_mailbox_get_hostname(msg_mailbox_t mailbox)\r
-{\r
-       return mailbox->hostname;\r
-}\r
-\r
-void\r
-MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname)\r
-{\r
-       mailbox->hostname = xbt_strdup(hostname);\r
-}\r
-\r
-msg_mailbox_t\r
-MSG_mailbox_get_by_alias(const char* alias)\r
-{\r
-\r
-       msg_mailbox_t mailbox = xbt_dict_get_or_null(msg_mailboxes,alias);\r
-   \r
-       if(!mailbox)\r
-       {\r
-               mailbox = MSG_mailbox_new(alias);\r
-               MSG_mailbox_set_hostname(mailbox,MSG_host_self()->name);\r
-       }\r
-       \r
-       return mailbox; \r
-}\r
-\r
-msg_mailbox_t\r
-MSG_mailbox_get_by_channel(m_host_t host, m_channel_t channel)\r
-{\r
-        xbt_assert0((host != NULL), "Invalid host");\r
-        xbt_assert1((channel >= 0)&& (channel < msg_global->max_channel), "Invalid channel %d",channel);\r
-\r
-        return host->simdata->mailboxes[(size_t)channel];\r
-}\r
-\r
-MSG_error_t \r
-MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, m_task_t* task, m_host_t host, double timeout)\r
-{\r
-       m_process_t process = MSG_process_self();\r
-       m_task_t t = NULL;\r
-       m_host_t h = NULL;\r
-       simdata_task_t t_simdata = NULL;\r
-       simdata_host_t h_simdata = NULL;\r
-       int first_time = 1;\r
-       \r
-       smx_cond_t cond = NULL; //conditional wait if the task isn't on the channel yet\r
-       \r
-       CHECK_HOST();\r
-       \r
-       /* Sanity check */\r
-       xbt_assert0(task, "Null pointer for the task storage");\r
-       \r
-       if (*task)\r
-               CRITICAL0("MSG_task_get() was asked to write in a non empty task struct.");\r
-       \r
-       /* Get the task */\r
-       h = MSG_host_self();\r
-       h_simdata = h->simdata;\r
-       \r
-       SIMIX_mutex_lock(h->simdata->mutex);\r
-       \r
-       while (1) \r
-       {\r
-               /* if the mailbox is empty (has no task */\r
-               if(!MSG_mailbox_is_empty(mailbox))\r
-               {\r
-                       if(!host) \r
-                       {\r
-                               /* pop the head of the mailbox */\r
-                               t = MSG_mailbox_pop_head(mailbox);\r
-                               break;\r
-                       } \r
-                       else \r
-                       {\r
-                               /* get the first task of the host */\r
-                               if(NULL != (t = MSG_mailbox_get_first_host_task(mailbox,host)))\r
-                                       break;\r
-                       }\r
-               }\r
-       \r
-               if(timeout > 0) \r
-               {\r
-                       if (!first_time) \r
-                       {\r
-                               SIMIX_mutex_unlock(h->simdata->mutex);\r
-                               /* set the simix condition of the mailbox to NULL */\r
-                               MSG_mailbox_set_cond(mailbox, NULL);\r
-                               SIMIX_cond_destroy(cond);\r
-                               MSG_RETURN(MSG_TRANSFER_FAILURE);\r
-                       }\r
-               }\r
-               \r
-               xbt_assert1(!MSG_mailbox_get_cond(mailbox),"A process is already blocked on the channel %s", MSG_mailbox_get_alias(mailbox));\r
-               \r
-               cond = SIMIX_cond_init();\r
-               \r
-               /* set the condition of the mailbox */\r
-               MSG_mailbox_set_cond(mailbox, cond);\r
-               \r
-               if (timeout > 0)\r
-                       SIMIX_cond_wait_timeout(cond, h->simdata->mutex, timeout);\r
-               else \r
-                       SIMIX_cond_wait(MSG_mailbox_get_cond(mailbox), h->simdata->mutex);\r
-                       \r
-       \r
-               if (SIMIX_host_get_state(h_simdata->smx_host) == 0)\r
-                       MSG_RETURN(MSG_HOST_FAILURE);\r
-       \r
-               first_time = 0;\r
-       }\r
-       \r
-       SIMIX_mutex_unlock(h->simdata->mutex);\r
-       \r
-       DEBUG1("OK, got a task (%s)", t->name);\r
-       /* clean conditional */\r
-       if (cond) \r
-       {\r
-               SIMIX_cond_destroy(cond);\r
-               \r
-               MSG_mailbox_set_cond(mailbox,NULL);\r
-       }\r
-       \r
-       t_simdata = t->simdata;\r
-       t_simdata->receiver = process;\r
-       *task = t;\r
-       \r
-       SIMIX_mutex_lock(t_simdata->mutex);\r
-       \r
-       /* Transfer */\r
-       /* create SIMIX action to the communication */\r
-       t_simdata->comm = SIMIX_action_communicate(\r
-                                                                                               t_simdata->sender->simdata->m_host->simdata->smx_host,\r
-                                                                                               process->simdata->m_host->simdata->smx_host,\r
-                                                                                               t->name, \r
-                                                                                               t_simdata->message_size,\r
-                                                                                               t_simdata->rate\r
-                                                                                       );\r
-       \r
-       /* if the process is suspend, create the action but stop its execution, it will be restart when the sender process resume */\r
-       if (MSG_process_is_suspended(t_simdata->sender)) \r
-       {\r
-               DEBUG1("Process sender (%s) suspended", t_simdata->sender->name);\r
-               SIMIX_action_set_priority(t_simdata->comm, 0);\r
-       }\r
-       \r
-       process->simdata->waiting_task = t;\r
-       SIMIX_register_action_to_condition(t_simdata->comm, t_simdata->cond);\r
-       \r
-       while (1) \r
-       {\r
-               SIMIX_cond_wait(t_simdata->cond, t_simdata->mutex);\r
-               \r
-               if (SIMIX_action_get_state(t_simdata->comm) != SURF_ACTION_RUNNING)\r
-                       break;\r
-       }\r
-       \r
-       SIMIX_unregister_action_to_condition(t_simdata->comm, t_simdata->cond);\r
-               process->simdata->waiting_task = NULL;\r
-       \r
-       /* the task has already finished and the pointer must be null */\r
-       if (t->simdata->sender) \r
-       {\r
-               t->simdata->sender->simdata->waiting_task = NULL;\r
-       }\r
-       \r
-       /* for this process, don't need to change in get function */\r
-       t->simdata->receiver = NULL;\r
-       SIMIX_mutex_unlock(t_simdata->mutex);\r
-       \r
-       \r
-       if (SIMIX_action_get_state(t_simdata->comm) == SURF_ACTION_DONE) \r
-       {\r
-               SIMIX_action_destroy(t_simdata->comm);\r
-               t_simdata->comm = NULL;\r
-               t_simdata->using--;\r
-               MSG_RETURN(MSG_OK);\r
-       } \r
-       else if (SIMIX_host_get_state(h_simdata->smx_host) == 0) \r
-       {\r
-               SIMIX_action_destroy(t_simdata->comm);\r
-               t_simdata->comm = NULL;\r
-               t_simdata->using--;\r
-               MSG_RETURN(MSG_HOST_FAILURE);\r
-       } \r
-       else \r
-       {\r
-               SIMIX_action_destroy(t_simdata->comm);\r
-               t_simdata->comm = NULL;\r
-               t_simdata->using--;\r
-               MSG_RETURN(MSG_TRANSFER_FAILURE);\r
-       }\r
-}\r
-\r
-MSG_error_t \r
-MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, double timeout)\r
-{\r
-       m_process_t process = MSG_process_self();\r
-       const char* hostname;\r
-       simdata_task_t task_simdata = NULL;\r
-       m_host_t local_host = NULL;\r
-       m_host_t remote_host = NULL;\r
-       smx_cond_t cond = NULL;\r
-\r
-       CHECK_HOST();\r
-       \r
-       task_simdata = task->simdata;\r
-       task_simdata->sender = process;\r
-       task_simdata->source = MSG_process_get_host(process);\r
-       \r
-       xbt_assert0(task_simdata->using == 1,"This task is still being used somewhere else. You cannot send it now. Go fix your code!");\r
-       \r
-       task_simdata->comm = NULL;\r
-       \r
-       task_simdata->using++;\r
-       local_host = ((simdata_process_t) process->simdata)->m_host;\r
-       \r
-       /* get the host name containing the mailbox */\r
-       hostname = MSG_mailbox_get_hostname(mailbox);\r
-\r
-       remote_host = MSG_get_host_by_name(hostname);\r
-\r
-       if(NULL == remote_host)\r
-               THROW1(not_found_error,0,"Host %s not fount", hostname);\r
-\r
-\r
-       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));\r
-       \r
-       SIMIX_mutex_lock(remote_host->simdata->mutex);\r
-\r
-       /* put the task in the mailbox */\r
-       MSG_mailbox_put(mailbox,task);\r
-       \r
-       if(NULL != (cond = MSG_mailbox_get_cond(mailbox)))\r
-       {\r
-               DEBUG0("Somebody is listening. Let's wake him up!");\r
-               SIMIX_cond_signal(cond);\r
-       }\r
-\r
-       \r
-       \r
-       SIMIX_mutex_unlock(remote_host->simdata->mutex);\r
-       \r
-       SIMIX_mutex_lock(task->simdata->mutex);\r
-\r
-       process->simdata->waiting_task = task;\r
-       \r
-       if(timeout > 0) \r
-       {\r
-               xbt_ex_t e;\r
-               double time;\r
-               double time_elapsed;\r
-               time = SIMIX_get_clock();\r
-               \r
-               TRY \r
-               {\r
-                       /*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 */\r
-                       while (1) \r
-                       {\r
-                               time_elapsed = SIMIX_get_clock() - time;\r
-                               SIMIX_cond_wait_timeout(task->simdata->cond, task->simdata->mutex,timeout - time_elapsed);\r
-                               \r
-                               if ((task->simdata->comm != NULL) && (SIMIX_action_get_state(task->simdata->comm) != SURF_ACTION_RUNNING))\r
-                                       break;\r
-                       }\r
-               } \r
-               CATCH(e) \r
-               {\r
-                       if(e.category==timeout_error) \r
-                       {\r
-                               xbt_ex_free(e);\r
-                               /* verify if the timeout happened and the communication didn't started yet */\r
-                               if (task->simdata->comm == NULL) \r
-                               {\r
-                                       process->simdata->waiting_task = NULL;\r
-                                       \r
-                                       /* remove the task from the mailbox */\r
-                                       MSG_mailbox_remove(mailbox,task);\r
-                                       \r
-                                       if (task->simdata->receiver) \r
-                                       {\r
-                                               task->simdata->receiver->simdata->waiting_task = NULL;\r
-                                       }\r
-                                       \r
-                                       task->simdata->sender = NULL;\r
-                                       \r
-                                       SIMIX_mutex_unlock(task->simdata->mutex);\r
-                                       MSG_RETURN(MSG_TRANSFER_FAILURE);\r
-                               }\r
-                       } \r
-                       else \r
-                       {\r
-                               RETHROW;\r
-                       }\r
-               }\r
-       } \r
-       else \r
-       {\r
-               while (1) \r
-               {\r
-                       SIMIX_cond_wait(task->simdata->cond, task->simdata->mutex);\r
-                       \r
-                       if (SIMIX_action_get_state(task->simdata->comm) != SURF_ACTION_RUNNING)\r
-                               break;\r
-               }\r
-       }\r
-       \r
-       DEBUG1("Action terminated %s", task->name);\r
-       process->simdata->waiting_task = NULL;\r
-       \r
-       /* the task has already finished and the pointer must be null */\r
-       if (task->simdata->receiver) \r
-       {\r
-               task->simdata->receiver->simdata->waiting_task = NULL;\r
-       }\r
-       \r
-       task->simdata->sender = NULL;\r
-       SIMIX_mutex_unlock(task->simdata->mutex);\r
-\r
-       \r
-       if (SIMIX_action_get_state(task->simdata->comm) == SURF_ACTION_DONE)\r
-       {\r
-               MSG_RETURN(MSG_OK);\r
-       } \r
-       else if (SIMIX_host_get_state(local_host->simdata->smx_host) == 0) \r
-       {\r
-               MSG_RETURN(MSG_HOST_FAILURE);\r
-       } \r
-       else \r
-       {\r
-               MSG_RETURN(MSG_TRANSFER_FAILURE);\r
-       }\r
-}\r
+#include "mailbox.h"
+#include "msg/private.h"
+
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_mailbox, msg,
+                               "Logging specific to MSG (mailbox)");
+
+static xbt_dict_t 
+msg_mailboxes = NULL;
+
+void
+MSG_mailbox_mod_init(void)
+{
+       msg_mailboxes = xbt_dict_new(); 
+}
+
+void
+MSG_mailbox_mod_exit(void)
+{
+       xbt_dict_free(&msg_mailboxes);
+}
+
+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
+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;
+}
+
+void
+MSG_mailbox_free(void* mailbox)
+{
+       msg_mailbox_t _mailbox = (msg_mailbox_t)mailbox;
+
+       if(NULL != (_mailbox->hostname))
+               free(_mailbox->hostname);
+
+       xbt_fifo_free(_mailbox->tasks);
+       free(_mailbox->alias);
+       
+       free(_mailbox);
+}
+
+void
+MSG_mailbox_put(msg_mailbox_t mailbox, m_task_t task)
+{
+       xbt_fifo_push(mailbox->tasks, task);
+}
+
+smx_cond_t
+MSG_mailbox_get_cond(msg_mailbox_t mailbox)
+{
+       return mailbox->cond;
+}
+
+void
+MSG_mailbox_remove(msg_mailbox_t mailbox, m_task_t task)
+{
+       xbt_fifo_remove(mailbox->tasks,task);
+}
+
+int
+MSG_mailbox_is_empty(msg_mailbox_t mailbox)
+{
+       return (NULL == xbt_fifo_get_first_item(mailbox->tasks));
+}
+
+m_task_t
+MSG_mailbox_pop_head(msg_mailbox_t mailbox)
+{
+       return (m_task_t)xbt_fifo_shift(mailbox->tasks);
+}
+
+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);
+}
+
+
+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;
+
+ 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;
+}
+
+int
+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;
+}
+
+void
+MSG_mailbox_set_cond(msg_mailbox_t mailbox, smx_cond_t cond)
+{
+       mailbox->cond = cond;
+}
+
+const char*
+MSG_mailbox_get_alias(msg_mailbox_t mailbox)
+{
+       return mailbox->alias;
+}
+
+const char*
+MSG_mailbox_get_hostname(msg_mailbox_t mailbox)
+{
+       return mailbox->hostname;
+}
+
+void
+MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname)
+{
+       mailbox->hostname = xbt_strdup(hostname);
+}
+
+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
+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);
+
+        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)
+{
+       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;
+       }
+       
+       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)
+{
+       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);
+       }
+
+       
+       
+       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);
+       }
+}