This change is relative with the mailbox concept :

include/msg/msg.h		The function MSG_task_receive_with_time_out is renamed MSG_task_receive_with_timeout

src/msg/private.h		Add the declaration of the structure of a mailbox, the structure simdata_host use now the concept of mailbox

src/msg/global.c		The initialization and the finalization of the mailbox module are respectively call by the functions MSG_global_init()
						and MSG_clean()

src/msg/msg_mailbox.c	Implementation of the functions MSG_mailbox_get_task_ext and MSG_mailbox_put_with_timeout, MSG_mailbox_get_by_channel;
						the MSG_mailbox_destroy function is deleted...

src/msg/msg_mailbox.h 	renamed mailbox.h

src/msg/host.c			The host use now the mailbox concept (the mailboxes of the hosts are not added in the global dictionary)

src/msg/gos.c			All the functions use now the now concept of mailbox, refactoring of code (the code related with the mailboxes
						is merged in the MSG_mailbox* functions)

src/simix/smx_global.c	The initialization and the finalization module functions are now call in the msg.c source file.

src/simix/smx_process.c	Add the mailbox identified by the alias "Host:Process" in the global dictionary

src/java/jmsg.c			msg_mailbox.h is renamed mailbox.h

src/Makefile.am			msg_mailbox.h is renamed mailbox.h

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

diff --git a/include/msg/msg.h b/include/msg/msg.h
index cf80731..eacf081 100644 (file)
--- a/include/msg/msg.h
+++ b/include/msg/msg.h
@@ -101,7 +101,7 @@ XBT_PUBLIC(MSG_error_t) MSG_task_cancel(m_task_t task);
 XBT_PUBLIC(MSG_error_t) MSG_task_destroy(m_task_t task);
 
 XBT_PUBLIC(MSG_error_t) MSG_task_get(m_task_t * task, m_channel_t channel);
 XBT_PUBLIC(MSG_error_t) MSG_task_destroy(m_task_t task);
 
 XBT_PUBLIC(MSG_error_t) MSG_task_get(m_task_t * task, m_channel_t channel);

-XBT_PUBLIC(MSG_error_t) MSG_task_get_with_time_out(m_task_t * task, m_channel_t channel,
+XBT_PUBLIC(MSG_error_t) MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel,

                                                   double max_duration);
 XBT_PUBLIC(MSG_error_t) MSG_task_get_from_host(m_task_t * task, int channel, 
                                               m_host_t host);
                                                   double max_duration);
 XBT_PUBLIC(MSG_error_t) MSG_task_get_from_host(m_task_t * task, int channel, 
                                               m_host_t host);


@@ -137,7 +137,7 @@ XBT_PUBLIC(MSG_error_t)
 MSG_task_receive_ext(m_task_t* task, const char* alias, double timeout, m_host_t host);
 
 XBT_PUBLIC(MSG_error_t) 
 MSG_task_receive_ext(m_task_t* task, const char* alias, double timeout, m_host_t host);
 
 XBT_PUBLIC(MSG_error_t) 

-MSG_task_receive_with_time_out(m_task_t * task, const char* alias, double timeout);
+MSG_task_receive_with_timeout(m_task_t * task, const char* alias, double timeout);

 
 XBT_PUBLIC(MSG_error_t) 
 MSG_task_receive(m_task_t * task, const char* alias);
 
 XBT_PUBLIC(MSG_error_t) 
 MSG_task_receive(m_task_t * task, const char* alias);

diff --git a/src/Makefile.am b/src/Makefile.am
index f59e303..4a6794a 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -62,7 +62,7 @@ EXTRA_DIST= \
        include/xbt/xbt_os_thread.h \
        \
        msg/private.h \
        include/xbt/xbt_os_thread.h \
        \
        msg/private.h \

-       msg/msg_mailbox.h \
+       msg/mailbox.h \

        \
        simdag/private.h \
        \
        \
        simdag/private.h \
        \

diff --git a/src/java/jmsg.c b/src/java/jmsg.c
index f0aae36..e1f2dcf 100644 (file)
--- a/src/java/jmsg.c
+++ b/src/java/jmsg.c
@@ -23,7 +23,7 @@
 
 #include "jmsg.h"
 
 
 #include "jmsg.h"
 

-#include "msg/msg_mailbox.h"
+#include "msg/mailbox.h"

 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
 
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
 


@@ -845,7 +845,7 @@ Java_simgrid_msg_Msg_init(JNIEnv* env, jclass cls, jobjectArray jargs) {
 
   argc++;
        
 
   argc++;
        

-  argv = (char**)calloc(argc,sizeof(char*));
+  argv = xbt_new0(char*,1);

         
   argv[0] = strdup("java");
        
         
   argv[0] = strdup("java");
        

diff --git a/src/msg/global.c b/src/msg/global.c
index 3436087..3ab2eca 100644 (file)
--- a/src/msg/global.c
+++ b/src/msg/global.c
@@ -12,6 +12,7 @@
 #include "xbt/log.h"
 #include "xbt/virtu.h"
 #include "xbt/ex.h"            /* ex_backtrace_display */
 #include "xbt/log.h"
 #include "xbt/virtu.h"
 #include "xbt/ex.h"            /* ex_backtrace_display */

+#include "mailbox.h"

 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_kernel, msg,
                                "Logging specific to MSG (kernel)");
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_kernel, msg,
                                "Logging specific to MSG (kernel)");


@@ -54,6 +55,9 @@ void MSG_global_init(int *argc, char **argv)
     msg_global->max_channel = 0;
     msg_global->PID = 1;
 
     msg_global->max_channel = 0;
     msg_global->PID = 1;
 

+       /* initialization of the mailbox module */
+       MSG_mailbox_mod_init();
+

     SIMIX_function_register_process_create(_MSG_process_create_from_SIMIX);
     SIMIX_function_register_process_cleanup(__MSG_process_cleanup);
     SIMIX_function_register_process_kill(_MSG_process_kill_from_SIMIX);
     SIMIX_function_register_process_create(_MSG_process_create_from_SIMIX);
     SIMIX_function_register_process_cleanup(__MSG_process_cleanup);
     SIMIX_function_register_process_kill(_MSG_process_kill_from_SIMIX);


@@ -232,8 +236,14 @@ MSG_error_t MSG_clean(void)
 
   free(msg_global);
   msg_global = NULL;
 
   free(msg_global);
   msg_global = NULL;

+
+  /* cleanup all resources in the mailbox module */
+  MSG_mailbox_mod_exit();
+

   SIMIX_clean();
 
   SIMIX_clean();
 

+  
+

   return MSG_OK;
 }
 
   return MSG_OK;
 }
 

diff --git a/src/msg/gos.c b/src/msg/gos.c
index 4a91629..ad589ed 100644 (file)
--- a/src/msg/gos.c
+++ b/src/msg/gos.c
@@ -10,167 +10,268 @@
 #include "msg/private.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
 #include "msg/private.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"

-#include "msg_mailbox.h"
+#include "mailbox.h"

 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg,
                                "Logging specific to MSG (gos)");
 
 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg,
                                "Logging specific to MSG (gos)");
 

-/** \defgroup msg_gos_functions MSG Operating System Functions
- *  \brief This section describes the functions that can be used
- *  by an agent for handling some task.
+/** \ingroup msg_gos_functions
+ *
+ * \brief Return the last value returned by a MSG function (except
+ * MSG_get_errno...).

  */
  */

-
-MSG_error_t MSG_task_get_ext(m_task_t * task,
-                            m_channel_t channel,
-                            double max_duration,
-                            m_host_t host)
+MSG_error_t 
+MSG_get_errno(void)

 {
 {

+       return PROCESS_GET_ERRNO();
+}

 
 

-  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;
-  xbt_fifo_item_t item = NULL;
-
-  smx_cond_t cond = NULL;      //conditional wait if the task isn't on the channel yet
-
-  CHECK_HOST();
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-  /* 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;
-
-  DEBUG2("Waiting for a task on channel %d (%s)", channel, h->name);
-
-  SIMIX_mutex_lock(h->simdata->mutex);
-  while (1) {
-    if (xbt_fifo_size(h_simdata->mbox[channel]) > 0) {
-      if (!host) {
-       t = xbt_fifo_shift(h_simdata->mbox[channel]);
-       break;
-      } else {
-       xbt_fifo_foreach(h->simdata->mbox[channel], item, t, m_task_t) {
-         if (t->simdata->source == host)
-           break;
-       }
-       if (item) {
-         xbt_fifo_remove_item(h->simdata->mbox[channel], item);
-         break;
+/** \ingroup msg_gos_functions
+ * \brief Executes a task and waits for its termination.
+ *
+ * This function is used for describing the behavior of an agent. It
+ * takes only one parameter.
+ * \param task a #m_task_t to execute on the location on which the
+   agent is running.
+ * \return #MSG_FATAL if \a task is not properly initialized and
+ * #MSG_OK otherwise.
+ */
+MSG_error_t 
+MSG_task_execute(m_task_t task)
+{
+       simdata_task_t simdata = NULL;
+       m_process_t self = MSG_process_self();
+       CHECK_HOST();
+       
+       simdata = task->simdata;
+       xbt_assert0((!simdata->compute) && (task->simdata->using == 1),"This task is executed somewhere else. Go fix your code!");
+       
+       DEBUG1("Computing on %s", MSG_process_self()->simdata->m_host->name);
+       
+       simdata->using++;
+       SIMIX_mutex_lock(simdata->mutex);
+       simdata->compute = SIMIX_action_execute(SIMIX_host_self(), task->name, simdata->computation_amount);
+       SIMIX_action_set_priority(simdata->compute, simdata->priority);
+       
+       self->simdata->waiting_task = task;
+       SIMIX_register_action_to_condition(simdata->compute, simdata->cond);
+       SIMIX_cond_wait(simdata->cond, simdata->mutex);
+       SIMIX_unregister_action_to_condition(simdata->compute, simdata->cond);
+       self->simdata->waiting_task = NULL;
+       
+       SIMIX_mutex_unlock(simdata->mutex);
+       simdata->using--;
+       
+       if (SIMIX_action_get_state(task->simdata->compute) == SURF_ACTION_DONE) 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->computation_amount = 0.0;
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_OK);
+       } 
+       else if(SIMIX_host_get_state(SIMIX_host_self()) == 0) 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_HOST_FAILURE);
+       } 
+       else 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_TASK_CANCELLED);

        }
        }

-      }
-    }
-
-    if (max_duration > 0) {
-      if (!first_time) {
-       SIMIX_mutex_unlock(h->simdata->mutex);
-       h_simdata->sleeping[channel] = NULL;
-       SIMIX_cond_destroy(cond);
-       MSG_RETURN(MSG_TRANSFER_FAILURE);
-      }
-    }
-    xbt_assert1(!(h_simdata->sleeping[channel]),
-               "A process is already blocked on channel %d", channel);
-
-    cond = SIMIX_cond_init();
-    h_simdata->sleeping[channel] = cond;
-    if (max_duration > 0)
-      SIMIX_cond_wait_timeout(cond, h->simdata->mutex, max_duration);
-    else 
-      SIMIX_cond_wait(h_simdata->sleeping[channel], 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);
+/** \ingroup m_task_management
+ * \brief Creates a new #m_task_t (a parallel one....).
+ *
+ * A constructor for #m_task_t taking six arguments and returning the 
+   corresponding object.
+ * \param name a name for the object. It is for user-level information
+   and can be NULL.
+ * \param host_nb the number of hosts implied in the parallel task.
+ * \param host_list an array of \p host_nb m_host_t.
+ * \param computation_amount an array of \p host_nb
+   doubles. computation_amount[i] is the total number of operations
+   that have to be performed on host_list[i].
+ * \param communication_amount an array of \p host_nb* \p host_nb doubles.
+ * \param data a pointer to any data may want to attach to the new
+   object.  It is for user-level information and can be NULL. It can
+   be retrieved with the function \ref MSG_task_get_data.
+ * \see m_task_t
+ * \return The new corresponding object.
+ */
+m_task_t 
+MSG_parallel_task_create(const char *name,int host_nb, const m_host_t * host_list, double *computation_amount, double *communication_amount, void *data)
+{
+       int i;
+       simdata_task_t simdata = xbt_new0(s_simdata_task_t, 1);
+       m_task_t task = xbt_new0(s_m_task_t, 1);
+       task->simdata = simdata;
+       
+       /* Task structure */
+       task->name = xbt_strdup(name);
+       task->data = data;
+       
+       /* Simulator Data */
+       simdata->computation_amount = 0;
+       simdata->message_size = 0;
+       simdata->cond = SIMIX_cond_init();
+       simdata->mutex = SIMIX_mutex_init();
+       simdata->compute = NULL;
+       simdata->comm = NULL;
+       simdata->rate = -1.0;
+       simdata->using = 1;
+       simdata->sender = NULL;
+       simdata->receiver = NULL;
+       simdata->source = NULL;
+       
+       simdata->host_nb = host_nb;
+       simdata->host_list = xbt_new0(smx_host_t, host_nb);
+       simdata->comp_amount = computation_amount;
+       simdata->comm_amount = communication_amount;
+       
+       for (i = 0; i < host_nb; i++)
+               simdata->host_list[i] = host_list[i]->simdata->smx_host;
+       
+       return task;
+}

 
 

-  DEBUG1("OK, got a task (%s)", t->name);
-  /* clean conditional */
-  if (cond) {
-    SIMIX_cond_destroy(cond);
-    h_simdata->sleeping[channel] = NULL;
-  }
+MSG_error_t 
+MSG_parallel_task_execute(m_task_t task)
+{
+       simdata_task_t simdata = NULL;
+       m_process_t self = MSG_process_self();
+       CHECK_HOST();
+       
+       simdata = task->simdata;
+       
+       xbt_assert0((!simdata->compute) && (task->simdata->using == 1),"This task is executed somewhere else. Go fix your code!");
+       
+       xbt_assert0(simdata->host_nb,"This is not a parallel task. Go to hell.");
+       
+       DEBUG1("Computing on %s", MSG_process_self()->simdata->m_host->name);
+       
+       simdata->using++;
+       
+       SIMIX_mutex_lock(simdata->mutex);
+       simdata->compute =
+       SIMIX_action_parallel_execute(task->name, simdata->host_nb, simdata->host_list, simdata->comp_amount, simdata->comm_amount, 1.0, -1.0);
+       
+       self->simdata->waiting_task = task;
+       SIMIX_register_action_to_condition(simdata->compute, simdata->cond);
+       SIMIX_cond_wait(simdata->cond, simdata->mutex);
+       SIMIX_unregister_action_to_condition(simdata->compute, simdata->cond);
+       self->simdata->waiting_task = NULL;
+       
+       
+       SIMIX_mutex_unlock(simdata->mutex);
+       simdata->using--;
+       
+       if (SIMIX_action_get_state(task->simdata->compute) == SURF_ACTION_DONE) 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->computation_amount = 0.0;
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_OK);
+       } 
+       else if(SIMIX_host_get_state(SIMIX_host_self()) == 0) 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_HOST_FAILURE);
+       } 
+       else 
+       {
+               /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+               SIMIX_action_destroy(task->simdata->compute);
+               simdata->comm = NULL;
+               simdata->compute = NULL;
+               MSG_RETURN(MSG_TASK_CANCELLED);
+       }

 
 

-  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;
+/** \ingroup msg_gos_functions
+ * \brief Sleep for the specified number of seconds
+ *
+ * Makes the current process sleep until \a time seconds have elapsed.
+ *
+ * \param nb_sec a number of second
+ */
+MSG_error_t 
+MSG_process_sleep(double nb_sec)
+{
+       smx_action_t act_sleep;
+       m_process_t proc = MSG_process_self();
+       smx_mutex_t mutex;
+       smx_cond_t cond;
+       
+       /* create action to sleep */
+       act_sleep = SIMIX_action_sleep(SIMIX_process_get_host(proc->simdata->s_process), nb_sec);
+       
+       mutex = SIMIX_mutex_init();
+       SIMIX_mutex_lock(mutex);
+       
+       /* create conditional and register action to it */
+       cond = SIMIX_cond_init();
+       
+       SIMIX_register_action_to_condition(act_sleep, cond);
+       SIMIX_cond_wait(cond, mutex);
+       SIMIX_unregister_action_to_condition(act_sleep, cond);
+       SIMIX_mutex_unlock(mutex);
+       
+       /* remove variables */
+       SIMIX_cond_destroy(cond);
+       SIMIX_mutex_destroy(mutex);
+       
+       if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) 
+       {
+               if (SIMIX_host_get_state(SIMIX_host_self()) == SURF_CPU_OFF) 
+               {
+                       SIMIX_action_destroy(act_sleep);
+                       MSG_RETURN(MSG_HOST_FAILURE);
+               }
+       } 
+       else 
+       {
+               SIMIX_action_destroy(act_sleep);
+               MSG_RETURN(MSG_HOST_FAILURE);

        }
        }

-  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;
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    //t->simdata->comm = NULL;
-    //t->simdata->compute = NULL;
-  }
-  /* for this process, don't need to change in get function */
-  t->simdata->receiver = NULL;
-  SIMIX_mutex_unlock(t_simdata->mutex);
+       
+       MSG_RETURN(MSG_OK);
+}

 
 

+/** \ingroup msg_gos_functions
+ * \brief Return the number of MSG tasks currently running on
+ * the host of the current running process.
+ */
+static int 
+MSG_get_msgload(void)
+{
+       xbt_die("not implemented yet");
+       return 0;
+}

 
 

-  if (SIMIX_action_get_state(t_simdata->comm) == SURF_ACTION_DONE) {
-    //t_simdata->comm = NULL;
-    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) {
-    //t_simdata->comm = NULL;
-    SIMIX_action_destroy(t_simdata->comm);
-    t_simdata->comm = NULL;
-               t_simdata->using--;
-    MSG_RETURN(MSG_HOST_FAILURE);
-  } else {
-    //t_simdata->comm = NULL;
-    SIMIX_action_destroy(t_simdata->comm);
-    t_simdata->comm = NULL;
-               t_simdata->using--;
-    MSG_RETURN(MSG_TRANSFER_FAILURE);
-  }

 
 

-}

 
 /** \ingroup msg_gos_functions
 
 /** \ingroup msg_gos_functions

- * \brief Listen on a channel and wait for receiving a task.
+ * \brief Listen on \a channel and waits for receiving a task from \a host.

  *
  *

- * It takes two parameters.
+ * It takes three parameters.

  * \param task a memory location for storing a #m_task_t. It will
    hold a task when this function will return. Thus \a task should not
    be equal to \c NULL and \a *task should be equal to \c NULL. If one of
  * \param task a memory location for storing a #m_task_t. It will
    hold a task when this function will return. Thus \a task should not
    be equal to \c NULL and \a *task should be equal to \c NULL. If one of


@@ -178,18 +279,20 @@ MSG_error_t MSG_task_get_ext(m_task_t * task,
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().

+ * \param host the host that is to be watched.

  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING
  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING

- * if \a *task is not equal to \c NULL, and #MSG_OK otherwise.
+   if \a *task is not equal to \c NULL, and #MSG_OK otherwise.

  */
  */

-MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel)
+MSG_error_t 
+MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host)

 {
 {

-  return MSG_task_get_with_time_out(task, channel, -1);
+       return MSG_task_get_ext(task, channel, -1, host);

 }
 
 /** \ingroup msg_gos_functions
 }
 
 /** \ingroup msg_gos_functions

- * \brief Listen on a channel and wait for receiving a task with a timeout.
+ * \brief Listen on a channel and wait for receiving a task.

  *
  *

- * It takes three parameters.
+ * It takes two parameters.

  * \param task a memory location for storing a #m_task_t. It will
    hold a task when this function will return. Thus \a task should not
    be equal to \c NULL and \a *task should be equal to \c NULL. If one of
  * \param task a memory location for storing a #m_task_t. It will
    hold a task when this function will return. Thus \a task should not
    be equal to \c NULL and \a *task should be equal to \c NULL. If one of


@@ -197,22 +300,17 @@ MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel)
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().

- * \param max_duration the maximum time to wait for a task before giving
-    up. In such a case, #MSG_TRANSFER_FAILURE will be returned, \a task 
-    will not be modified and will still be
-    equal to \c NULL when returning. 

  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING
  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING

-   if \a *task is not equal to \c NULL, and #MSG_OK otherwise.
+ * if \a *task is not equal to \c NULL, and #MSG_OK otherwise.

  */
  */

-MSG_error_t MSG_task_get_with_time_out(m_task_t * task,
-                                      m_channel_t channel,
-                                      double max_duration)
+MSG_error_t 
+MSG_task_get(m_task_t * task, m_channel_t channel)

 {
 {

-  return MSG_task_get_ext(task, channel, max_duration, NULL);
+       return MSG_task_get_with_timeout(task, channel, -1);

 }
 
 /** \ingroup msg_gos_functions
 }
 
 /** \ingroup msg_gos_functions

- * \brief Listen on \a channel and waits for receiving a task from \a host.
+ * \brief Listen on a channel and wait for receiving a task with a timeout.

  *
  * It takes three parameters.
  * \param task a memory location for storing a #m_task_t. It will
  *
  * It takes three parameters.
  * \param task a memory location for storing a #m_task_t. It will


@@ -222,184 +320,100 @@ MSG_error_t MSG_task_get_with_time_out(m_task_t * task,
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().
  * \param channel the channel on which the agent should be
    listening. This value has to be >=0 and < than the maximal
    number of channels fixed with MSG_set_channel_number().

- * \param host the host that is to be watched.
+ * \param max_duration the maximum time to wait for a task before giving
+    up. In such a case, #MSG_TRANSFER_FAILURE will be returned, \a task 
+    will not be modified and will still be
+    equal to \c NULL when returning. 

  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING
    if \a *task is not equal to \c NULL, and #MSG_OK otherwise.
  */
  * \return #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING
    if \a *task is not equal to \c NULL, and #MSG_OK otherwise.
  */

-MSG_error_t MSG_task_get_from_host(m_task_t * task, int channel,
-                                  m_host_t host)
+MSG_error_t 
+MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel, double max_duration)

 {
 {

-  return MSG_task_get_ext(task, channel, -1, host);
+  return MSG_task_get_ext(task, channel, max_duration, NULL);

 }
 
 }
 

-/** \ingroup msg_gos_functions
- * \brief Test whether there is a pending communication on a channel.
- *
- * It takes one parameter.
- * \param channel the channel on which the agent should be
-   listening. This value has to be >=0 and < than the maximal
-   number of channels fixed with MSG_set_channel_number().
- * \return 1 if there is a pending communication and 0 otherwise
+/** \defgroup msg_gos_functions MSG Operating System Functions
+ *  \brief This section describes the functions that can be used
+ *  by an agent for handling some task.

  */
  */

-int MSG_task_Iprobe(m_channel_t channel)
-{
-  m_host_t h = NULL;
-
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-  CHECK_HOST();

 
 

-  DEBUG2("Probing on channel %d (%s)", channel, h->name);
-
-  h = MSG_host_self();
-  return (xbt_fifo_get_first_item(h->simdata->mbox[channel]) != NULL);
+MSG_error_t 
+MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout,m_host_t host)
+{
+       xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d",channel);
+        
+       return MSG_mailbox_get_task_ext(MSG_mailbox_get_by_channel(MSG_host_self(), channel), task, host, timeout);

 }
 
 }
 

-/** \ingroup msg_gos_functions
- * \brief Test whether there is a pending communication on a channel, and who sent it.
- *
- * It takes one parameter.
- * \param channel the channel on which the agent should be
-   listening. This value has to be >=0 and < than the maximal
-   number of channels fixed with MSG_set_channel_number().
- * \return -1 if there is no pending communication and the PID of the process who sent it otherwise
- */
-int MSG_task_probe_from(m_channel_t channel)
+MSG_error_t 
+MSG_task_receive_from_host(m_task_t * task, const char* alias, m_host_t host)

 {
 {

-  m_host_t h = NULL;
-  xbt_fifo_item_t item;
-  m_task_t t;
-
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-  CHECK_HOST();
-
-  h = MSG_host_self();
+       return MSG_task_receive_ext(task, alias, -1, host);
+}

 
 

-  DEBUG2("Probing on channel %d (%s)", channel, h->name);
+MSG_error_t 
+MSG_task_receive(m_task_t * task, const char* alias)
+{
+       return MSG_task_receive_with_timeout(task, alias, -1);  
+}

 
 

-  item = xbt_fifo_get_first_item(h->simdata->mbox[channel]);
-  if ((!item) || (!(t = xbt_fifo_get_item_content(item))))
-    return -1;
+MSG_error_t 
+MSG_task_receive_with_timeout(m_task_t * task, const char* alias, double timeout)
+{
+       return MSG_task_receive_ext(task, alias, timeout, NULL);                
+}

 
 

-  return MSG_process_get_PID(t->simdata->sender);
+MSG_error_t 
+MSG_task_receive_ext(m_task_t* task, const char* alias, double timeout, m_host_t host)
+{
+       return MSG_mailbox_get_task_ext(MSG_mailbox_get_by_alias(alias), task, host, timeout);

 }
 
 }
 

+

 /** \ingroup msg_gos_functions
 /** \ingroup msg_gos_functions

- * \brief Wait for at most \a max_duration second for a task reception
-   on \a channel. 
- 
- * \a PID is updated with the PID of the first process that triggered this event if any.
+ * \brief Put a task on a channel of an host and waits for the end of the
+ * transmission.

  *
  *

- * It takes three parameters:
- * \param channel the channel on which the agent should be
-   listening. This value has to be >=0 and < than the maximal.
-   number of channels fixed with MSG_set_channel_number().
- * \param PID a memory location for storing an int.
- * \param max_duration the maximum time to wait for a task before
-    giving up. In the case of a reception, *\a PID will be updated
-    with the PID of the first process to send a task.
- * \return #MSG_HOST_FAILURE if the host is shut down in the meantime
-   and #MSG_OK otherwise.
+ * This function is used for describing the behavior of an agent. It
+ * takes three parameter.
+ * \param task a #m_task_t to send on another location. This task
+   will not be usable anymore when the function will return. There is
+   no automatic task duplication and you have to save your parameters
+   before calling this function. Tasks are unique and once it has been
+   sent to another location, you should not access it anymore. You do
+   not need to call MSG_task_destroy() but to avoid using, as an
+   effect of inattention, this task anymore, you definitely should
+   renitialize it with #MSG_TASK_UNINITIALIZED. Note that this task
+   can be transfered iff it has been correctly created with
+   MSG_task_create().
+ * \param dest the destination of the message
+ * \param channel the channel on which the agent should put this
+   task. This value has to be >=0 and < than the maximal number of
+   channels fixed with MSG_set_channel_number().
+ * \return #MSG_FATAL if \a task is not properly initialized and
+ * #MSG_OK otherwise. Returns #MSG_HOST_FAILURE if the host on which
+ * this function was called was shut down. Returns
+ * #MSG_TRANSFER_FAILURE if the transfer could not be properly done
+ * (network failure, dest failure)

  */
  */

-MSG_error_t MSG_channel_select_from(m_channel_t channel,
-                                   double max_duration, int *PID)
+MSG_error_t 
+MSG_task_put(m_task_t task, m_host_t dest, m_channel_t channel)

 {
 {

-  m_host_t h = NULL;
-  simdata_host_t h_simdata = NULL;
-  xbt_fifo_item_t item;
-  m_task_t t;
-  int first_time = 1;
-  smx_cond_t cond;
-
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-  if (PID) {
-    *PID = -1;
-  }
-
-  if (max_duration == 0.0) {
-    *PID = MSG_task_probe_from(channel);
-    MSG_RETURN(MSG_OK);
-  } else {
-    CHECK_HOST();
-    h = MSG_host_self();
-    h_simdata = h->simdata;
-
-    DEBUG2("Probing on channel %d (%s)", channel, h->name);
-    while (!(item = xbt_fifo_get_first_item(h->simdata->mbox[channel]))) {
-      if (max_duration > 0) {
-       if (!first_time) {
-         MSG_RETURN(MSG_OK);
-       }
-      }
-      SIMIX_mutex_lock(h_simdata->mutex);
-      xbt_assert1(!(h_simdata->sleeping[channel]),
-                 "A process is already blocked on this channel %d",
-                 channel);
-      cond = SIMIX_cond_init();
-      h_simdata->sleeping[channel] = cond;     /* I'm waiting. Wake me up when you're ready */
-      if (max_duration > 0) {
-       SIMIX_cond_wait_timeout(cond, h_simdata->mutex, max_duration);
-      } else {
-       SIMIX_cond_wait(cond, h_simdata->mutex);
-      }
-      SIMIX_cond_destroy(cond);
-      SIMIX_mutex_unlock(h_simdata->mutex);
-      if (SIMIX_host_get_state(h_simdata->smx_host) == 0) {
-       MSG_RETURN(MSG_HOST_FAILURE);
-      }
-      h_simdata->sleeping[channel] = NULL;
-      first_time = 0;
-    }
-    if (!item || !(t = xbt_fifo_get_item_content(item))) {
-      MSG_RETURN(MSG_OK);
-    }
-    if (PID) {
-      *PID = MSG_process_get_PID(t->simdata->sender);
-    }
-    MSG_RETURN(MSG_OK);
-  }
+       return MSG_task_put_with_timeout(task, dest, channel, -1.0);

 }
 
 }
 

-

 /** \ingroup msg_gos_functions
 /** \ingroup msg_gos_functions

-
- * \brief Return the number of tasks waiting to be received on a \a
-   channel and sent by \a host.
+ * \brief Does exactly the same as MSG_task_put but with a bounded transmition 
+ * rate.

  *
  *

- * It takes two parameters.
- * \param channel the channel on which the agent should be
-   listening. This value has to be >=0 and < than the maximal
-   number of channels fixed with MSG_set_channel_number().
- * \param host the host that is to be watched.
- * \return the number of tasks waiting to be received on \a channel
-   and sent by \a host.
+ * \sa MSG_task_put

  */
  */

-int MSG_task_probe_from_host(int channel, m_host_t host)
+MSG_error_t
+MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, double maxrate)

 {
 {

-  xbt_fifo_item_t item;
-  m_task_t t;
-  int count = 0;
-  m_host_t h = NULL;
-
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-  CHECK_HOST();
-  h = MSG_host_self();
-
-  DEBUG2("Probing on channel %d (%s)", channel, h->name);
-
-  xbt_fifo_foreach(h->simdata->mbox[channel], item, t, m_task_t) {
-    if (t->simdata->source == host)
-      count++;
-  }
-
-  return count;
+       task->simdata->rate = maxrate;
+       return MSG_task_put(task, dest, channel);

 }
 
 /** \ingroup msg_gos_functions \brief Put a task on a channel of an
 }
 
 /** \ingroup msg_gos_functions \brief Put a task on a channel of an


@@ -431,598 +445,230 @@ int MSG_task_probe_from_host(int channel, m_host_t host)
    #MSG_TRANSFER_FAILURE if the transfer could not be properly done
    (network failure, dest failure, timeout...)
  */
    #MSG_TRANSFER_FAILURE if the transfer could not be properly done
    (network failure, dest failure, timeout...)
  */

-MSG_error_t MSG_task_put_with_timeout(m_task_t task, m_host_t dest,
-                                     m_channel_t channel,
-                                     double max_duration)
+MSG_error_t 
+MSG_task_put_with_timeout(m_task_t task, m_host_t dest, m_channel_t channel, double timeout)

 {
 {

+       xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel);
+       
+       return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_channel(dest, channel), task, timeout);
+}

 
 

+MSG_error_t 
+MSG_task_send(m_task_t task,const char* alias)
+{
+       return MSG_task_send_with_timeout(task, alias, -1);
+}

 
 

-  m_process_t process = MSG_process_self();
-  simdata_task_t task_simdata = NULL;
-  m_host_t local_host = NULL;
-  m_host_t remote_host = NULL;
-  CHECK_HOST();
-
-  xbt_assert1((channel >= 0)
-             && (channel < msg_global->max_channel), "Invalid channel %d",
-             channel);
-
-  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;
-  remote_host = dest;
-
-  DEBUG4("Trying to send a task (%g kB) from %s to %s on channel %d",
-        task->simdata->message_size / 1000, local_host->name,
-        remote_host->name, channel);
-
-  SIMIX_mutex_lock(remote_host->simdata->mutex);
-  xbt_fifo_push(((simdata_host_t) remote_host->simdata)->
-               mbox[channel], task);
-
-
-  if (remote_host->simdata->sleeping[channel]) {
-    DEBUG0("Somebody is listening. Let's wake him up!");
-    SIMIX_cond_signal(remote_host->simdata->sleeping[channel]);
-  }
-  SIMIX_mutex_unlock(remote_host->simdata->mutex);
-
-  process->simdata->put_host = dest;
-  process->simdata->put_channel = channel;
-  SIMIX_mutex_lock(task->simdata->mutex);
-  // DEBUG4("Task sent (%g kB) from %s to %s on channel %d, waiting...", task->simdata->message_size/1000,local_host->name, remote_host->name, channel);
-
-  process->simdata->waiting_task = task;
-  if (max_duration > 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,
-                                               max_duration-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;
-         xbt_fifo_remove(((simdata_host_t) remote_host->simdata)->
-                         mbox[channel], 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;
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    //      task->simdata->comm = NULL;
-    //task->simdata->compute = 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);
-  }
+MSG_error_t 
+MSG_task_send_bounded(m_task_t task, const char* alias, double maxrate)
+{
+       task->simdata->rate = maxrate;
+       return MSG_task_send(task, alias);

 }
 
 }
 

-/** \ingroup msg_gos_functions
- * \brief Put a task on a channel of an host and waits for the end of the
- * transmission.
- *
- * This function is used for describing the behavior of an agent. It
- * takes three parameter.
- * \param task a #m_task_t to send on another location. This task
-   will not be usable anymore when the function will return. There is
-   no automatic task duplication and you have to save your parameters
-   before calling this function. Tasks are unique and once it has been
-   sent to another location, you should not access it anymore. You do
-   not need to call MSG_task_destroy() but to avoid using, as an
-   effect of inattention, this task anymore, you definitely should
-   renitialize it with #MSG_TASK_UNINITIALIZED. Note that this task
-   can be transfered iff it has been correctly created with
-   MSG_task_create().
- * \param dest the destination of the message
- * \param channel the channel on which the agent should put this
-   task. This value has to be >=0 and < than the maximal number of
-   channels fixed with MSG_set_channel_number().
- * \return #MSG_FATAL if \a task is not properly initialized and
- * #MSG_OK otherwise. Returns #MSG_HOST_FAILURE if the host on which
- * this function was called was shut down. Returns
- * #MSG_TRANSFER_FAILURE if the transfer could not be properly done
- * (network failure, dest failure)
- */
-MSG_error_t MSG_task_put(m_task_t task, m_host_t dest, m_channel_t channel)
+                                   
+MSG_error_t 
+MSG_task_send_with_timeout(m_task_t task, const char* alias, double timeout)

 {
 {

-  return MSG_task_put_with_timeout(task, dest, channel, -1.0);
+       return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias), task, timeout);

 }
 
 }
 

-/** \ingroup msg_gos_functions
- * \brief Does exactly the same as MSG_task_put but with a bounded transmition 
- * rate.
- *
- * \sa MSG_task_put
- */
-MSG_error_t MSG_task_put_bounded(m_task_t task,
-                                m_host_t dest, m_channel_t channel,
-                                double max_rate)
+int 
+MSG_task_listen(const char* alias)

 {
 {

-  MSG_error_t res = MSG_OK;
-  task->simdata->rate = max_rate;
-  res = MSG_task_put(task, dest, channel);
-  return (res);
+       CHECK_HOST();
+       
+       return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));

 }
 
 /** \ingroup msg_gos_functions
 }
 
 /** \ingroup msg_gos_functions

- * \brief Executes a task and waits for its termination.
+ * \brief Test whether there is a pending communication on a channel.

  *
  *

- * This function is used for describing the behavior of an agent. It
- * takes only one parameter.
- * \param task a #m_task_t to execute on the location on which the
-   agent is running.
- * \return #MSG_FATAL if \a task is not properly initialized and
- * #MSG_OK otherwise.
+ * It takes one parameter.
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal
+   number of channels fixed with MSG_set_channel_number().
+ * \return 1 if there is a pending communication and 0 otherwise

  */
  */

-MSG_error_t MSG_task_execute(m_task_t task)
+int 
+MSG_task_Iprobe(m_channel_t channel)

 {
 {

-  simdata_task_t simdata = NULL;
-  m_process_t self = MSG_process_self();
+  xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel);
+  

   CHECK_HOST();
   CHECK_HOST();

-
-  simdata = task->simdata;
-  xbt_assert0((!simdata->compute) && (task->simdata->using == 1),
-             "This task is executed somewhere else. Go fix your code!");
-
-  DEBUG1("Computing on %s", MSG_process_self()->simdata->m_host->name);
-  simdata->using++;
-  SIMIX_mutex_lock(simdata->mutex);
-  simdata->compute =
-      SIMIX_action_execute(SIMIX_host_self(), task->name,
-                          simdata->computation_amount);
-  SIMIX_action_set_priority(simdata->compute, simdata->priority);
-
-  self->simdata->waiting_task = task;
-  SIMIX_register_action_to_condition(simdata->compute, simdata->cond);
-  SIMIX_cond_wait(simdata->cond, simdata->mutex);
-  SIMIX_unregister_action_to_condition(simdata->compute, simdata->cond);
-  self->simdata->waiting_task = NULL;
-
-  SIMIX_mutex_unlock(simdata->mutex);
-  simdata->using--;
-
-  if (SIMIX_action_get_state(task->simdata->compute) == SURF_ACTION_DONE) {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->computation_amount = 0.0;
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_OK);
-  } else if (SIMIX_host_get_state(SIMIX_host_self()) == 0) {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_HOST_FAILURE);
-  } else {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_TASK_CANCELLED);
-  }
+  
+  return !MSG_mailbox_is_empty(MSG_mailbox_get_by_channel(MSG_host_self(), channel));

 }
 
 }
 

+/** \ingroup msg_gos_functions

 
 

-/** \ingroup m_task_management
- * \brief Creates a new #m_task_t (a parallel one....).
+ * \brief Return the number of tasks waiting to be received on a \a
+   channel and sent by \a host.

  *
  *

- * A constructor for #m_task_t taking six arguments and returning the 
-   corresponding object.
- * \param name a name for the object. It is for user-level information
-   and can be NULL.
- * \param host_nb the number of hosts implied in the parallel task.
- * \param host_list an array of \p host_nb m_host_t.
- * \param computation_amount an array of \p host_nb
-   doubles. computation_amount[i] is the total number of operations
-   that have to be performed on host_list[i].
- * \param communication_amount an array of \p host_nb* \p host_nb doubles.
- * \param data a pointer to any data may want to attach to the new
-   object.  It is for user-level information and can be NULL. It can
-   be retrieved with the function \ref MSG_task_get_data.
- * \see m_task_t
- * \return The new corresponding object.
+ * It takes two parameters.
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal
+   number of channels fixed with MSG_set_channel_number().
+ * \param host the host that is to be watched.
+ * \return the number of tasks waiting to be received on \a channel
+   and sent by \a host.

  */
  */

-m_task_t MSG_parallel_task_create(const char *name,
-                                 int host_nb,
-                                 const m_host_t * host_list,
-                                 double *computation_amount,
-                                 double *communication_amount, void *data)
+int 
+MSG_task_probe_from_host(int channel, m_host_t host)

 {
 {

-  int i;
-  simdata_task_t simdata = xbt_new0(s_simdata_task_t, 1);
-  m_task_t task = xbt_new0(s_m_task_t, 1);
-  task->simdata = simdata;
-
-  /* Task structure */
-  task->name = xbt_strdup(name);
-  task->data = data;
-
-  /* Simulator Data */
-  simdata->computation_amount = 0;
-  simdata->message_size = 0;
-  simdata->cond = SIMIX_cond_init();
-  simdata->mutex = SIMIX_mutex_init();
-  simdata->compute = NULL;
-  simdata->comm = NULL;
-  simdata->rate = -1.0;
-  simdata->using = 1;
-  simdata->sender = NULL;
-  simdata->receiver = NULL;
-  simdata->source = NULL;
-
-  simdata->host_nb = host_nb;
-  simdata->host_list = xbt_new0(smx_host_t, host_nb);
-  simdata->comp_amount = computation_amount;
-  simdata->comm_amount = communication_amount;
-
-  for (i = 0; i < host_nb; i++)
-    simdata->host_list[i] = host_list[i]->simdata->smx_host;
-
-  return task;
-
+       xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel);
+       
+       CHECK_HOST();
+       
+       return MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_channel(MSG_host_self(), channel),host);     
+       

 }
 
 }
 

-
-MSG_error_t MSG_parallel_task_execute(m_task_t task)
+int 
+MSG_task_listen_from_host(const char* alias, m_host_t host)

 {
 {

-  simdata_task_t simdata = NULL;
-  m_process_t self = MSG_process_self();
-  CHECK_HOST();
-
-  simdata = task->simdata;
-  xbt_assert0((!simdata->compute) && (task->simdata->using == 1),
-             "This task is executed somewhere else. Go fix your code!");
-
-  xbt_assert0(simdata->host_nb,
-             "This is not a parallel task. Go to hell.");
-
-  DEBUG1("Computing on %s", MSG_process_self()->simdata->m_host->name);
-  simdata->using++;
-  SIMIX_mutex_lock(simdata->mutex);
-  simdata->compute =
-      SIMIX_action_parallel_execute(task->name, simdata->host_nb,
-                                   simdata->host_list,
-                                   simdata->comp_amount,
-                                   simdata->comm_amount, 1.0, -1.0);
-
-  self->simdata->waiting_task = task;
-  SIMIX_register_action_to_condition(simdata->compute, simdata->cond);
-  SIMIX_cond_wait(simdata->cond, simdata->mutex);
-  SIMIX_unregister_action_to_condition(simdata->compute, simdata->cond);
-  self->simdata->waiting_task = NULL;
-
-
-  SIMIX_mutex_unlock(simdata->mutex);
-  simdata->using--;
-
-  if (SIMIX_action_get_state(task->simdata->compute) == SURF_ACTION_DONE) {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->computation_amount = 0.0;
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_OK);
-  } else if (SIMIX_host_get_state(SIMIX_host_self()) == 0) {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_HOST_FAILURE);
-  } else {
-    /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
-    SIMIX_action_destroy(task->simdata->compute);
-    simdata->comm = NULL;
-    simdata->compute = NULL;
-    MSG_RETURN(MSG_TASK_CANCELLED);
-  }
-
+       CHECK_HOST();
+       
+       return MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias(alias),host);          

 }
 
 }
 

-

 /** \ingroup msg_gos_functions
 /** \ingroup msg_gos_functions

- * \brief Sleep for the specified number of seconds
- *
- * Makes the current process sleep until \a time seconds have elapsed.
+ * \brief Test whether there is a pending communication on a channel, and who sent it.

  *
  *

- * \param nb_sec a number of second
+ * It takes one parameter.
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal
+   number of channels fixed with MSG_set_channel_number().
+ * \return -1 if there is no pending communication and the PID of the process who sent it otherwise

  */
  */

-MSG_error_t MSG_process_sleep(double nb_sec)
+int 
+MSG_task_probe_from(m_channel_t channel)

 {
 {

-  smx_action_t act_sleep;
-  m_process_t proc = MSG_process_self();
-  smx_mutex_t mutex;
-  smx_cond_t cond;
-  /* create action to sleep */
-  act_sleep =
-      SIMIX_action_sleep(SIMIX_process_get_host(proc->simdata->s_process),
-                        nb_sec);
+       m_task_t task;

 
 

-  mutex = SIMIX_mutex_init();
-  SIMIX_mutex_lock(mutex);
-  /* create conditional and register action to it */
-  cond = SIMIX_cond_init();
+       CHECK_HOST();
+       
+       xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel);

 
 

-  SIMIX_register_action_to_condition(act_sleep, cond);
-  SIMIX_cond_wait(cond, mutex);
-  SIMIX_unregister_action_to_condition(act_sleep, cond);
-  SIMIX_mutex_unlock(mutex);
+       if(NULL == (task = MSG_mailbox_get_head(MSG_mailbox_get_by_channel(MSG_host_self(), channel))))
+               return -1;

 
 

-  /* remove variables */
-  SIMIX_cond_destroy(cond);
-  SIMIX_mutex_destroy(mutex);
+       return MSG_process_get_PID(task->simdata->sender);
+}

 
 

-  if (SIMIX_action_get_state(act_sleep) == SURF_ACTION_DONE) {
-    if (SIMIX_host_get_state(SIMIX_host_self()) == SURF_CPU_OFF) {
-      SIMIX_action_destroy(act_sleep);
-      MSG_RETURN(MSG_HOST_FAILURE);
-    }
-  } else {
-    SIMIX_action_destroy(act_sleep);
-    MSG_RETURN(MSG_HOST_FAILURE);
-  }
+int
+MSG_task_listen_from(const char* alias)
+{
+       m_task_t task;

 
 

+       CHECK_HOST();

 
 

-  MSG_RETURN(MSG_OK);
-}
+       if(NULL == (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
+               return -1;

 
 

-/** \ingroup msg_gos_functions
- * \brief Return the number of MSG tasks currently running on
- * the host of the current running process.
- */
-static int MSG_get_msgload(void)
-{
-  xbt_die("not implemented yet");
-  return 0;
+       return MSG_process_get_PID(task->simdata->sender);

 }
 
 /** \ingroup msg_gos_functions
 }
 
 /** \ingroup msg_gos_functions

+ * \brief Wait for at most \a max_duration second for a task reception
+   on \a channel. 
+ 
+ * \a PID is updated with the PID of the first process that triggered this event if any.

  *
  *

- * \brief Return the last value returned by a MSG function (except
- * MSG_get_errno...).
+ * It takes three parameters:
+ * \param channel the channel on which the agent should be
+   listening. This value has to be >=0 and < than the maximal.
+   number of channels fixed with MSG_set_channel_number().
+ * \param PID a memory location for storing an int.
+ * \param max_duration the maximum time to wait for a task before
+    giving up. In the case of a reception, *\a PID will be updated
+    with the PID of the first process to send a task.
+ * \return #MSG_HOST_FAILURE if the host is shut down in the meantime
+   and #MSG_OK otherwise.

  */
  */

-MSG_error_t MSG_get_errno(void)
-{
-  return PROCESS_GET_ERRNO();
-}
-

 MSG_error_t 
 MSG_error_t 

-MSG_task_receive_ext(m_task_t* task, const char* alias, double timeout, m_host_t host)
+MSG_channel_select_from(m_channel_t channel,double timeout, int *PID)

 {
 {

-       m_process_t process = MSG_process_self();
-       m_task_t t = NULL;

        m_host_t h = NULL;
        m_host_t h = NULL;

-       simdata_task_t t_simdata = NULL;

        simdata_host_t h_simdata = NULL;
        simdata_host_t h_simdata = NULL;

+       m_task_t t;

        int first_time = 1;
        int first_time = 1;

+       smx_cond_t cond;
+       msg_mailbox_t mailbox;

        
        

-       smx_cond_t cond = NULL; //conditional wait if the task isn't on the channel yet
-       
-       /* get the mailbox from the alias (if the mailbox doesn't exist, create it) */
-       msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
-       
-       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;
-       
-       DEBUG2("Waiting for a task on channel aliased by %s (%s)", alias, h->name);
+       xbt_assert1((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d",channel);

        
        

-       SIMIX_mutex_lock(h->simdata->mutex);
+       if(PID) 
+       {
+               *PID = -1;
+       }

        
        

-       while (1) 
+       if (timeout == 0.0) 
+       {
+               *PID = MSG_task_probe_from(channel);
+               MSG_RETURN(MSG_OK);
+       } 
+       else 

        {
        {

-               /* if the mailbox is empty (has no task */
-               if(!MSG_mailbox_is_empty(mailbox))
+               CHECK_HOST();
+               h = MSG_host_self();
+               h_simdata = h->simdata;
+               
+               mailbox = MSG_mailbox_get_by_channel(MSG_host_self(), channel); 
+               
+               while(MSG_mailbox_is_empty(mailbox))

                {
                {

-                       if(!host) 
+                       if(timeout > 0) 
+                       {
+                               if (!first_time) 
+                               {
+                                       MSG_RETURN(MSG_OK);
+                               }
+                       }
+                       
+                       SIMIX_mutex_lock(h_simdata->mutex);
+                       
+                       xbt_assert1(!MSG_mailbox_get_cond(mailbox),"A process is already blocked on this channel %d",channel);
+                       
+                       cond = SIMIX_cond_init();
+                       
+                       MSG_mailbox_set_cond(mailbox, cond);
+                       
+                       if (timeout > 0) 

                        {
                        {

-                               /* pop the head of the mailbox */
-                               t = MSG_mailbox_pop_head(mailbox);
-                               break;
+                               SIMIX_cond_wait_timeout(cond, h_simdata->mutex, timeout);

                        } 
                        else 
                        {
                        } 
                        else 
                        {

-                               /* get the first task of the host */
-                               if(NULL != (t = MSG_mailbox_get_first_host_task(mailbox,host)))
-                                       break;
+                               SIMIX_cond_wait(cond, h_simdata->mutex);

                        }
                        }

-               }
-       
-               if(timeout > 0) 
-               {
-                       if (!first_time) 
+                       
+                       SIMIX_cond_destroy(cond);
+                       SIMIX_mutex_unlock(h_simdata->mutex);
+                       
+                       if (SIMIX_host_get_state(h_simdata->smx_host) == 0) 

                        {
                        {

-                               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);
+                               MSG_RETURN(MSG_HOST_FAILURE);

                        }
                        }

+                       
+                       MSG_mailbox_set_cond(mailbox,NULL);
+                       first_time = 0;

                }
                
                }
                

-               xbt_assert1(!MSG_mailbox_get_cond(mailbox),"A process is already blocked on the channel aliased by %s", alias);
-               
-               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);
+               if(NULL == (t = MSG_mailbox_get_head(mailbox)))
+                       MSG_RETURN(MSG_OK);
+                               

                
                

-               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 (PID) 
+               {
+                       *PID = MSG_process_get_PID(t->simdata->sender);
+               }

                
                

-               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);
                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_task_receive_with_time_out(m_task_t * task, const char* alias, double timeout)
-{
-       return MSG_task_receive_ext(task, alias, timeout, NULL);                
-}
-                            
-MSG_error_t 
-MSG_task_receive(m_task_t * task, const char* alias)
-{
-       return MSG_task_receive_with_time_out(task, alias, -1); 
-}
-
-int 
-MSG_task_listen(const char* alias)
-{
-       CHECK_HOST();
-       
-       DEBUG2("Probing on channel aliased by %s (%s)", alias, MSG_host_self()->name);
-       
-       return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
-}
-
-int 
-MSG_task_listen_from_host(const char* alias, m_host_t host)
-{
-
-       return MSG_mailbox_get_count_host_tasks(MSG_mailbox_get_by_alias(alias),host);
-                       
-}

 
 MSG_error_t 
 MSG_alias_select_from(const char* alias, double timeout, int* PID)
 
 MSG_error_t 
 MSG_alias_select_from(const char* alias, double timeout, int* PID)


@@ -1105,179 +751,8 @@ MSG_alias_select_from(const char* alias, double timeout, int* PID)
                MSG_RETURN(MSG_OK);
        }
 }
                MSG_RETURN(MSG_OK);
        }
 }

-                                   
-MSG_error_t 
-MSG_task_send_with_timeout(m_task_t task, const char* alias, 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;
-       
-       /* get the mailbox from the alias (if the mailbox doesn't exist, create it) */
-       msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
-
-       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);
-       }
-}
-
-MSG_error_t 
-MSG_task_send(m_task_t task,const char* alias)
-{
-       return MSG_task_send_with_timeout(task, alias, -1);
-}

 
 
 
 

-MSG_error_t 
-MSG_task_send_bounded(m_task_t task, const char* alias, double rate)
-{
-       task->simdata->rate = rate;
-       return MSG_task_send(task, alias);
-}
-
-int
-MSG_task_listen_from(const char* alias)
-{
-       m_host_t h = NULL;
-       m_task_t t;
-
-       CHECK_HOST();

 
 

-       h = MSG_host_self();

 
 

-       DEBUG2("Probing on alias %s(%s)", alias, h->name);
-
-       if(NULL == (t = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
-               return -1;
-
-       return MSG_process_get_PID(t->simdata->sender);
-}

                              
                              

diff --git a/src/msg/host.c b/src/msg/host.c
index 9866873..9c28630 100644 (file)
--- a/src/msg/host.c
+++ b/src/msg/host.c
@@ -10,7 +10,7 @@
 #include "msg/private.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
 #include "msg/private.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"

-#include "msg_mailbox.h"
+#include "mailbox.h"

 
 /** \defgroup m_host_management Management functions of Hosts
  *  \brief This section describes the host structure of MSG
 
 /** \defgroup m_host_management Management functions of Hosts
  *  \brief This section describes the host structure of MSG


@@ -37,7 +37,6 @@ m_host_t __MSG_host_create(smx_host_t workstation, void *data)
        int i;
        
        char alias[MAX_ALIAS_NAME +1] = {0}; /* buffer used to build the key of the mailbox */
        int i;
        
        char alias[MAX_ALIAS_NAME +1] = {0}; /* buffer used to build the key of the mailbox */

-       msg_mailbox_t mailbox;

        
        name = SIMIX_host_get_name(workstation);
        /* Host structure */
        
        name = SIMIX_host_get_name(workstation);
        /* Host structure */


@@ -47,21 +46,18 @@ m_host_t __MSG_host_create(smx_host_t workstation, void *data)
        
        simdata->smx_host = workstation;
        
        
        simdata->smx_host = workstation;
        

-       simdata->mbox = xbt_new0(xbt_fifo_t, msg_global->max_channel);
+       simdata->mailboxes = xbt_new0(msg_mailbox_t, msg_global->max_channel);

        
        for (i = 0; i < msg_global->max_channel; i++)
        {
                sprintf(alias,"%s:%d",name,i);
                
                /* the key of the mailbox (in this case) is build from the name of the host and the channel number */
        
        for (i = 0; i < msg_global->max_channel; i++)
        {
                sprintf(alias,"%s:%d",name,i);
                
                /* the key of the mailbox (in this case) is build from the name of the host and the channel number */

-               mailbox = MSG_mailbox_new(alias);
-               MSG_mailbox_set_hostname(mailbox,name);
+               simdata->mailboxes[i] = MSG_mailbox_create(alias);
+               MSG_mailbox_set_hostname(simdata->mailboxes[i],name);

                memset(alias,0,MAX_ALIAS_NAME +1);
                memset(alias,0,MAX_ALIAS_NAME +1);

-               
-               simdata->mbox[i] = xbt_fifo_new();

        }
        
        }
        

-       simdata->sleeping = xbt_new0(smx_cond_t, msg_global->max_channel);

        simdata->mutex = SIMIX_mutex_init();
        SIMIX_host_set_data(workstation, host);
        
        simdata->mutex = SIMIX_mutex_init();
        SIMIX_host_set_data(workstation, host);
        


@@ -138,35 +134,32 @@ m_host_t MSG_host_self(void)
  */
 void __MSG_host_destroy(m_host_t host)
 {
  */
 void __MSG_host_destroy(m_host_t host)
 {

-  simdata_host_t simdata = NULL;
-  int i = 0;
-  char alias[MAX_ALIAS_NAME +1] = {0}; /* buffer used to build the key of the mailbox */
-
-  xbt_assert0((host != NULL), "Invalid parameters");
+       simdata_host_t simdata = NULL;
+       int i = 0;
+       char alias[MAX_ALIAS_NAME +1] = {0}; /* buffer used to build the key of the mailbox */
+       
+       xbt_assert0((host != NULL), "Invalid parameters");
+       
+       /* Clean Simulator data */
+       /* SIMIX host will be cleaned when MSG_clean calls SIMIX_clean */
+       simdata = (host)->simdata;
+       
+       for (i = 0; i < msg_global->max_channel; i++)
+       {
+               sprintf(alias,"%s:%d",host->name,i);
+               MSG_mailbox_free((void*)(simdata->mailboxes[i]));
+               memset(alias,0,MAX_ALIAS_NAME +1);
+       }
+       
+       free(simdata->mailboxes);
+       SIMIX_mutex_destroy(simdata->mutex);
+       free(simdata);
+       
+       /* Clean host structure */
+       free(host->name);
+       free(host);
+       

 
 

-  /* Clean Simulator data */
-  /* SIMIX host will be cleaned when MSG_clean calls SIMIX_clean */
-  simdata = (host)->simdata;
-
-  for (i = 0; i < msg_global->max_channel; i++)
-  {
-       sprintf(alias,"%s:%d",host->name,i);
-       xbt_dict_remove(MSG_get_mailboxes(),alias);
-       memset(alias,0,MAX_ALIAS_NAME +1);
-       
-    xbt_fifo_free(simdata->mbox[i]);
-  }
-
-  free(simdata->mbox);
-  free(simdata->sleeping);
-  SIMIX_mutex_destroy(simdata->mutex);
-  free(simdata);
-
-  /* Clean host structure */
-  free(host->name);
-  free(host);
-
-  return;

 }
 
 /** \ingroup m_host_management
 }
 
 /** \ingroup m_host_management

diff --git a/src/msg/msg_mailbox.c b/src/msg/msg_mailbox.c
index a6556a2..aadc18f 100644 (file)
--- a/src/msg/msg_mailbox.c
+++ b/src/msg/msg_mailbox.c
@@ -1,15 +1,12 @@
-#include "msg_mailbox.h"\r
+#include "mailbox.h"\r

 #include "msg/private.h"\r
 \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
 static xbt_dict_t \r
 msg_mailboxes = NULL;\r
 \r

-xbt_dict_t\r
-MSG_get_mailboxes(void)\r
-{\r
-       return msg_mailboxes;\r
-}\r
-\r

 void\r
 MSG_mailbox_mod_init(void)\r
 {\r
 void\r
 MSG_mailbox_mod_init(void)\r
 {\r


@@ -38,20 +35,30 @@ MSG_mailbox_new(const char *alias)
        return mailbox;\r
 }\r
 \r
        return mailbox;\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 = xbt_strdup(alias);\r
+       mailbox->hostname = NULL;\r
+       \r
+       return mailbox;\r
+}\r
+\r

 void\r
 void\r

-MSG_mailbox_destroy(msg_mailbox_t* mailbox)\r
+MSG_mailbox_free(void* mailbox)\r

 {\r
 {\r

-       xbt_dict_remove(msg_mailboxes,(*mailbox)->alias);\r
+       msg_mailbox_t _mailbox = (msg_mailbox_t)mailbox;\r

 \r
 \r

-       if(NULL != ((*mailbox)->hostname))\r
-               free((*mailbox)->hostname);\r
+       if(NULL != (_mailbox->hostname))\r
+               free(_mailbox->hostname);\r

 \r
 \r

+       free(_mailbox->alias);\r

        \r
        \r

-       free((*mailbox)->alias);\r
-       \r
-       free(*mailbox);\r
-       \r
-       *mailbox = NULL;        \r
+       free(_mailbox);\r

 }\r
 \r
 void\r
 }\r
 \r
 void\r


@@ -114,7 +121,7 @@ MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host)
 }\r
 \r
 int\r
 }\r
 \r
 int\r

-MSG_mailbox_get_count_host_tasks(msg_mailbox_t mailbox, m_host_t host)\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
 {\r
        m_task_t task = NULL;\r
        xbt_fifo_item_t item = NULL;\r


@@ -153,19 +160,6 @@ MSG_mailbox_set_hostname(msg_mailbox_t mailbox, const char* hostname)
        mailbox->hostname = xbt_strdup(hostname);\r
 }\r
 \r
        mailbox->hostname = xbt_strdup(hostname);\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
-       free(__mailbox->alias);\r
-       \r
-       free(__mailbox);\r
-}\r
-\r

 msg_mailbox_t\r
 MSG_mailbox_get_by_alias(const char* alias)\r
 {\r
 msg_mailbox_t\r
 MSG_mailbox_get_by_alias(const char* alias)\r
 {\r


@@ -180,3 +174,310 @@ MSG_mailbox_get_by_alias(const char* alias)
        \r
        return mailbox; \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

diff --git a/src/msg/msg_mailbox.h b/src/msg/msg_mailbox.h
index 94e0c2a..9534f04 100644 (file)
--- a/src/msg/msg_mailbox.h
+++ b/src/msg/msg_mailbox.h
@@ -5,20 +5,12 @@
 #include "simix/private.h"\r
 #include "msg/datatypes.h"\r
 \r
 #include "simix/private.h"\r
 #include "msg/datatypes.h"\r
 \r

-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
+SG_BEGIN_DECL()\r

 \r
 #define MAX_ALIAS_NAME ((size_t)260)\r
 \r
 \r
 #define MAX_ALIAS_NAME ((size_t)260)\r
 \r

-/* this structure represents a mailbox */\r
-typedef struct s_msg_mailbox\r
-{\r
-       char* alias;                    /* the key of the mailbox in the dictionary                             */\r
-       xbt_fifo_t tasks;               /* the list of the tasks in the mailbox                                 */\r
-       smx_cond_t cond;                /* the condition on the mailbox                                                 */\r
-       char* hostname;                 /* the name of the host containing the mailbox                  */\r
-}s_msg_mailbox_t, * msg_mailbox_t;\r
+/* forward declaration */\r
+typedef struct s_msg_mailbox* msg_mailbox_t;\r

 \r
 /*\r
  * Initialization of the mailbox module.\r
 \r
 /*\r
  * Initialization of the mailbox module.\r


@@ -32,21 +24,11 @@ MSG_mailbox_mod_init(void);
 void\r
 MSG_mailbox_mod_exit(void);\r
 \r
 void\r
 MSG_mailbox_mod_exit(void);\r
 \r

-/*! \brief MSG_get_mailboxes - get the dictionary containing all the mailboxes.\r
- * \r
- * The function MSG_get_mailboxes returns the dictionary containing all the mailboxes\r
- * of the simulation. A mailbox allow different processes to communicate using msg tasks.\r
- * It is identified by an alias which is a key of the dictionary containing all of them.\r
- * \r
- * \return     The dictionary containing all the mailboxes of the simulation.\r
- */\r
-xbt_dict_t\r
-MSG_get_mailboxes(void);\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
 \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.\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
  *\r
  * \param alias                The alias of the mailbox to create.\r
  * \r


@@ -55,19 +37,18 @@ MSG_get_mailboxes(void);
 msg_mailbox_t\r
 MSG_mailbox_new(const char *alias);\r
 \r
 msg_mailbox_t\r
 MSG_mailbox_new(const char *alias);\r
 \r

-/* \brief MSG_mailbox_destroy - destroy a mailbox.\r
+/*! \brief MSG_mailbox_create - create a new mailbox.\r

  *\r
  *\r

- * The function MSG_mailbox_destroy removes a mailbox from the dictionary containing\r
- * all the mailbox of the simulation an release it from the memory. This function is\r
- * different to the MSG_mailbox_free which only release a mailbox from the memory but\r
- does not remove it from the dictionary.\r
- *\r
- * \param mailbox      The mailbox to destroy.\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
  *\r

- * \see                                MSG_mailbox_free.\r
+ * \param alias                The alias of the mailbox to create.\r
+ * \r
+ * \return                     The newly created mailbox.\r

  */\r
  */\r

-void\r
-MSG_mailbox_destroy(msg_mailbox_t* mailbox);\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
 \r
 /* \brief MSG_mailbox_free - release a mailbox from the memory.\r
  *\r


@@ -95,6 +76,21 @@ MSG_mailbox_free(void* mailbox);
 msg_mailbox_t\r
 MSG_mailbox_get_by_alias(const char* alias);\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
 /*! \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


@@ -228,8 +224,8 @@ MSG_mailbox_pop_head(msg_mailbox_t mailbox);
 m_task_t\r
 MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t 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_tasks - get the number of msg tasks\r
- * of a specified mailbox, sended by all the process of a specified host.\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
  *\r
  * \param mailbox      The mailbox concerned by the operation.\r
  * \param host         The msg host containing the processes that have sended the\r


@@ -240,12 +236,18 @@ MSG_mailbox_get_first_host_task(msg_mailbox_t mailbox, m_host_t host);
  *                                     on the host specified by the parameter host.\r
  */\r
 int\r
  *                                     on the host specified by the parameter host.\r
  */\r
 int\r

-MSG_mailbox_get_count_host_tasks(msg_mailbox_t mailbox, m_host_t host);\r
+MSG_mailbox_get_count_host_waiting_tasks(msg_mailbox_t mailbox, m_host_t host);\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
+\r
+MSG_error_t \r
+MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, m_task_t task, double timeout);\r

 \r
 \r

+SG_END_DECL()\r

 \r
 \r

-#ifdef __cplusplus\r
-}\r
-#endif\r

 \r
 #endif /* !SMX_MAILBOX_H */\r
 \r
 \r
 #endif /* !SMX_MAILBOX_H */\r
 \r

diff --git a/src/msg/private.h b/src/msg/private.h
index bdaea3c..b7a62ba 100644 (file)
--- a/src/msg/private.h
+++ b/src/msg/private.h
@@ -23,12 +23,21 @@
 
 /**************** datatypes **********************************/
 
 
 /**************** datatypes **********************************/
 

-typedef struct simdata_host {
-  smx_host_t smx_host;                 /* SURF modeling */
-  xbt_fifo_t *mbox;            /* array of FIFOs used as a mailboxes  */
-  smx_cond_t *sleeping;        /* array of conditions on which the processes sleep if they are waiting for a communication on a channel */
-       smx_mutex_t mutex; /* mutex to access the host */
-} s_simdata_host_t;
+/* this structure represents a mailbox */
+typedef struct s_msg_mailbox
+{
+       char* alias;                                            /* the key of the mailbox in the global dictionary                      */
+       xbt_fifo_t tasks;                                       /* the list of the tasks in the mailbox                                         */
+       smx_cond_t cond;                                        /* the condition on the mailbox                                                         */
+       char* hostname;                                         /* the name of the host containing the mailbox                          */
+}s_msg_mailbox_t;
+
+typedef struct simdata_host 
+{
+       smx_host_t smx_host;                            /* SURF modeling                                                                */
+       struct s_msg_mailbox** mailboxes;       /* mailboxes to store msg tasks of of the host  */
+       smx_mutex_t mutex;                                      /* mutex to access the host                                     */
+}s_simdata_host_t;

 
 /********************************* Task **************************************/
 
 
 /********************************* Task **************************************/
 

diff --git a/src/simix/smx_global.c b/src/simix/smx_global.c
index f853c7d..5742d2b 100644 (file)
--- a/src/simix/smx_global.c
+++ b/src/simix/smx_global.c
@@ -11,7 +11,6 @@
 #include "xbt/log.h"
 #include "xbt/str.h"
 #include "xbt/ex.h"            /* ex_backtrace_display */
 #include "xbt/log.h"
 #include "xbt/str.h"
 #include "xbt/ex.h"            /* ex_backtrace_display */

-#include "msg/msg_mailbox.h"

 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_kernel, simix,
                                "Logging specific to SIMIX (kernel)");
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_kernel, simix,
                                "Logging specific to SIMIX (kernel)");
 


@@ -122,9 +121,6 @@ void SIMIX_global_init(int *argc, char **argv)
     simix_global->current_process = NULL;
     simix_global->registered_functions = xbt_dict_new();
        
     simix_global->current_process = NULL;
     simix_global->registered_functions = xbt_dict_new();
        

-       /* initialization of the mailbox module */
-       MSG_mailbox_mod_init();
-       

     simix_global->create_process_function = NULL;
     simix_global->kill_process_function = NULL;
     simix_global->cleanup_process_function = SIMIX_process_cleanup;
     simix_global->create_process_function = NULL;
     simix_global->kill_process_function = NULL;
     simix_global->cleanup_process_function = SIMIX_process_cleanup;


@@ -301,9 +297,6 @@ void SIMIX_clean(void)
   free(simix_global);
   simix_global = NULL;
   
   free(simix_global);
   simix_global = NULL;
   

-  /* cleanup all resources in the mailbox module */
-  MSG_mailbox_mod_exit();
-  

   surf_exit();
 
   return;
   surf_exit();
 
   return;

diff --git a/src/simix/smx_process.c b/src/simix/smx_process.c
index 548c9c6..23935b2 100644 (file)
--- a/src/simix/smx_process.c
+++ b/src/simix/smx_process.c
@@ -9,6 +9,7 @@
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
 #include "xbt/dict.h"
 #include "xbt/sysdep.h"
 #include "xbt/log.h"
 #include "xbt/dict.h"

+#include "msg/mailbox.h"

 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix,
                                "Logging specific to SIMIX (process)");
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_process, simix,
                                "Logging specific to SIMIX (process)");


@@ -61,7 +62,9 @@ smx_process_t SIMIX_process_create(const char *name,
   smx_process_t process = xbt_new0(s_smx_process_t, 1);
   smx_process_t self = NULL;
   smx_host_t host = SIMIX_host_get_by_name(hostname);
   smx_process_t process = xbt_new0(s_smx_process_t, 1);
   smx_process_t self = NULL;
   smx_host_t host = SIMIX_host_get_by_name(hostname);

-
+  char alias[MAX_ALIAS_NAME + 1] = {0};
+  msg_mailbox_t mailbox;
+       

   xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters");
   /* Simulator Data */
 
   xbt_assert0(((code != NULL) && (host != NULL)), "Invalid parameters");
   /* Simulator Data */
 


@@ -93,6 +96,11 @@ smx_process_t SIMIX_process_create(const char *name,
   xbt_swag_insert(process, simix_global->process_list);
   DEBUG2("Inserting %s(%s) in the to_run list", process->name, host->name);
   xbt_swag_insert(process, simix_global->process_to_run);
   xbt_swag_insert(process, simix_global->process_list);
   DEBUG2("Inserting %s(%s) in the to_run list", process->name, host->name);
   xbt_swag_insert(process, simix_global->process_to_run);

+  
+  sprintf(alias,"%s:%s",hostname,process->name);
+
+       mailbox = MSG_mailbox_new(alias);
+       MSG_mailbox_set_hostname(mailbox, hostname);

 
   return process;
 }
 
   return process;
 }