X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/bdaaac614d1bb0ee8e034fa76862068d57e362ee..0a0481f82fc27b7306940b78c411a3d6e5c84d1c:/src/msg/msg_gos.c

diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c
index 90b8c699d8..5cd5b9020e 100644
--- a/src/msg/msg_gos.c
+++ b/src/msg/msg_gos.c
@@ -55,20 +55,20 @@ MSG_error_t MSG_task_execute(m_task_t task)
   p_simdata = SIMIX_process_self_get_data(self);
   simdata->isused=1;
   simdata->compute =
-      SIMIX_req_host_execute(task->name, p_simdata->m_host->simdata->smx_host,
+      simcall_host_execute(task->name, p_simdata->m_host->simdata->smx_host,
                            simdata->computation_amount,
                            simdata->priority);
 #ifdef HAVE_TRACING
-  SIMIX_req_set_category(simdata->compute, task->category);
+  simcall_set_category(simdata->compute, task->category);
 #endif
 
   p_simdata->waiting_action = simdata->compute;
-  comp_state = SIMIX_req_host_execution_wait(simdata->compute);
+  comp_state = simcall_host_execution_wait(simdata->compute);
   p_simdata->waiting_action = NULL;
 
   simdata->isused=0;
 
-  XBT_DEBUG("Execution task '%s' finished in state %d", task->name, comp_state);
+  XBT_DEBUG("Execution task '%s' finished in state %d", task->name, (int)comp_state);
   if (comp_state == SIMIX_DONE) {
     /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
     simdata->computation_amount = 0.0;
@@ -78,7 +78,7 @@ MSG_error_t MSG_task_execute(m_task_t task)
     TRACE_msg_task_execute_end(task);
 #endif
     MSG_RETURN(MSG_OK);
-  } else if (SIMIX_req_host_get_state(SIMIX_host_self()) == 0) {
+  } else if (simcall_host_get_state(SIMIX_host_self()) == 0) {
     /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
     simdata->comm = NULL;
     simdata->compute = NULL;
@@ -175,17 +175,17 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
   simdata->isused=1;
 
   simdata->compute =
-      SIMIX_req_host_parallel_execute(task->name, simdata->host_nb,
+      simcall_host_parallel_execute(task->name, simdata->host_nb,
                                   simdata->host_list,
                                   simdata->comp_amount,
                                   simdata->comm_amount, 1.0, -1.0);
   XBT_DEBUG("Parallel execution action created: %p", simdata->compute);
 
   p_simdata->waiting_action = simdata->compute;
-  comp_state = SIMIX_req_host_execution_wait(simdata->compute);
+  comp_state = simcall_host_execution_wait(simdata->compute);
   p_simdata->waiting_action = NULL;
 
-  XBT_DEBUG("Finished waiting for execution of action %p, state = %d", simdata->compute, comp_state);
+  XBT_DEBUG("Finished waiting for execution of action %p, state = %d", simdata->compute, (int)comp_state);
 
   simdata->isused=0;
 
@@ -195,7 +195,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
     simdata->comm = NULL;
     simdata->compute = NULL;
     MSG_RETURN(MSG_OK);
-  } else if (SIMIX_req_host_get_state(SIMIX_host_self()) == 0) {
+  } else if (simcall_host_get_state(SIMIX_host_self()) == 0) {
     /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
     simdata->comm = NULL;
     simdata->compute = NULL;
@@ -226,7 +226,7 @@ MSG_error_t MSG_process_sleep(double nb_sec)
 #endif
 
   /* create action to sleep */
-  state = SIMIX_req_process_sleep(nb_sec);
+  state = simcall_process_sleep(nb_sec);
 
   /*proc->simdata->waiting_action = act_sleep;
 
@@ -247,91 +247,6 @@ MSG_error_t MSG_process_sleep(double nb_sec)
   }
 }
 
-/** \ingroup msg_gos_functions
- * \brief Listen on \a channel and waits for receiving a task from \a host.
- *
- * 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
- those two condition does not hold, there will be a warning message.
- * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
- */
-MSG_error_t
-MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host)
-{
-  XBT_WARN("DEPRECATED! Now use MSG_task_receive_from_host");
-  return MSG_task_get_ext(task, channel, -1, host);
-}
-
-/** \ingroup msg_gos_functions
- * \brief Listen on a channel and wait for receiving a task.
- *
- * 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
- those two condition does not hold, there will be a warning message.
- * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
- */
-MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel)
-{
-  XBT_WARN("DEPRECATED! Now use MSG_task_receive");
-  return MSG_task_get_with_timeout(task, channel, -1);
-}
-
-/** \ingroup msg_gos_functions
- * \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
- 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
- those two condition does not hold, there will be a warning message.
- * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
- */
-MSG_error_t
-MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel,
-                          double max_duration)
-{
-  XBT_WARN("DEPRECATED! Now use MSG_task_receive_with_timeout");
-  return MSG_task_get_ext(task, channel, max_duration, NULL);
-}
-
-/** \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.
- */
-
-MSG_error_t
-MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout,
-                 m_host_t host)
-{
-  XBT_WARN("DEPRECATED! Now use MSG_task_receive_ext");
-  xbt_assert((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);
-}
-
 MSG_error_t
 MSG_task_receive_from_host(m_task_t * task, const char *alias,
                            m_host_t host)
@@ -385,7 +300,7 @@ msg_comm_t MSG_task_isend(m_task_t task, const char *alias)
  *
  * \param task a #m_task_t to send on another location.
  * \param alias name of the mailbox to sent the task to
- * \param match_fun boolean function taking the #match_data provided by sender (here), and the one of the receiver (if any) and returning whether they match
+ * \param match_fun boolean function taking the match_data provided by sender (here), and the one of the receiver (if any) and returning whether they match
  * \param match_data user provided data passed to match_fun
  * \return the msg_comm_t communication created
  */
@@ -410,6 +325,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
 
   t_simdata->isused = 1;
+  t_simdata->comm = NULL;
   msg_global->sent_msg++;
 
   /* Send it by calling SIMIX network layer */
@@ -418,7 +334,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al
   comm->task_received = NULL;
   comm->status = MSG_OK;
   comm->s_comm =
-    SIMIX_req_comm_isend(mailbox, t_simdata->message_size,
+    simcall_comm_isend(mailbox, t_simdata->message_size,
                          t_simdata->rate, task, sizeof(void *), match_fun, NULL, match_data, 0);
   t_simdata->comm = comm->s_comm; /* FIXME: is the field t_simdata->comm still useful? */
 
@@ -461,10 +377,11 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
               "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
 
   t_simdata->isused = 1;
+  t_simdata->comm = NULL;
   msg_global->sent_msg++;
 
   /* Send it by calling SIMIX network layer */
-  smx_action_t comm = SIMIX_req_comm_isend(mailbox, t_simdata->message_size,
+  smx_action_t comm = simcall_comm_isend(mailbox, t_simdata->message_size,
                        t_simdata->rate, task, sizeof(void *), NULL, cleanup, NULL, 1);
   t_simdata->comm = comm;
 }
@@ -485,7 +402,7 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name)
 
   CHECK_HOST();
 
-  /* FIXME: these functions are not tracable */
+  /* FIXME: these functions are not traceable */
 
   /* Sanity check */
   xbt_assert(task, "Null pointer for the task storage");
@@ -499,7 +416,7 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name)
   comm->task_sent = NULL;
   comm->task_received = task;
   comm->status = MSG_OK;
-  comm->s_comm = SIMIX_req_comm_irecv(rdv, task, NULL, NULL, NULL);
+  comm->s_comm = simcall_comm_irecv(rdv, task, NULL, NULL, NULL);
 
   return comm;
 }
@@ -517,7 +434,7 @@ int MSG_comm_test(msg_comm_t comm)
   xbt_ex_t e;
   int finished = 0;
   TRY {
-    finished = SIMIX_req_comm_test(comm->s_comm);
+    finished = simcall_comm_test(comm->s_comm);
 
     if (finished && comm->task_received != NULL) {
       /* I am the receiver */
@@ -573,7 +490,7 @@ int MSG_comm_testany(xbt_dynar_t comms)
 
   MSG_error_t status = MSG_OK;
   TRY {
-    finished_index = SIMIX_req_comm_testany(s_comms);
+    finished_index = simcall_comm_testany(s_comms);
   }
   CATCH(e) {
     switch (e.category) {
@@ -635,7 +552,7 @@ MSG_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
 {
   xbt_ex_t e;
   TRY {
-    SIMIX_req_comm_wait(comm->s_comm, timeout);
+    simcall_comm_wait(comm->s_comm, timeout);
 
     if (comm->task_received != NULL) {
       /* I am the receiver */
@@ -700,7 +617,7 @@ int MSG_comm_waitany(xbt_dynar_t comms)
 
   MSG_error_t status = MSG_OK;
   TRY {
-    finished_index = SIMIX_req_comm_waitany(s_comms);
+    finished_index = simcall_comm_waitany(s_comms);
   }
   CATCH(e) {
     switch (e.category) {
@@ -775,10 +692,73 @@ void MSG_comm_copy_data_from_SIMIX(smx_action_t comm, void* buff, size_t buff_si
   if (msg_global->task_copy_callback) {
     m_task_t task = buff;
     msg_global->task_copy_callback(task,
-        SIMIX_req_comm_get_src_proc(comm), SIMIX_req_comm_get_dst_proc(comm));
+        simcall_comm_get_src_proc(comm), simcall_comm_get_dst_proc(comm));
   }
 }
 
+MSG_error_t MSG_task_send(m_task_t task, const char *alias)
+{
+  XBT_DEBUG("MSG_task_send: Trying to send a message on mailbox '%s'", 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 maxrate)
+{
+  task->simdata->rate = maxrate;
+  return MSG_task_send(task, alias);
+}
+
+
+MSG_error_t
+MSG_task_send_with_timeout(m_task_t task, const char *alias,
+                           double timeout)
+{
+  return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
+                                      task, timeout);
+}
+
+int MSG_task_listen(const char *alias)
+{
+  CHECK_HOST();
+
+  return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
+}
+
+int MSG_task_listen_from_host(const char *alias, m_host_t host)
+{
+  CHECK_HOST();
+
+  return
+      MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias
+                                               (alias), host);
+}
+
+int MSG_task_listen_from(const char *alias)
+{
+  m_task_t task;
+
+  CHECK_HOST();
+
+  if (NULL ==
+      (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
+    return -1;
+
+  return MSG_process_get_PID(task->simdata->sender);
+}
+
+#ifdef MSG_USE_DEPRECATED
+/** \ingroup msg_gos_functions
+ *
+ * \brief Return the last value returned by a MSG function (except
+ * MSG_get_errno...).
+ */
+MSG_error_t MSG_get_errno(void)
+{
+  return PROCESS_GET_ERRNO();
+}
+
 /** \ingroup msg_gos_functions
  * \brief Put a task on a channel of an host and waits for the end of the
  * transmission.
@@ -868,34 +848,33 @@ MSG_task_put_with_timeout(m_task_t task, m_host_t dest,
                                    (dest, channel), task, timeout);
 }
 
-MSG_error_t MSG_task_send(m_task_t task, const char *alias)
-{
-  XBT_DEBUG("MSG_task_send: Trying to send a message on mailbox '%s'", 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 maxrate)
+/** \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)
 {
-  task->simdata->rate = maxrate;
-  return MSG_task_send(task, alias);
-}
+  XBT_WARN("DEPRECATED! Now use MSG_task_listen_from");
+  m_task_t task;
 
+  CHECK_HOST();
 
-MSG_error_t
-MSG_task_send_with_timeout(m_task_t task, const char *alias,
-                           double timeout)
-{
-  return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
-                                      task, timeout);
-}
+  xbt_assert((channel >= 0)
+              && (channel < msg_global->max_channel), "Invalid channel %d",
+              channel);
 
-int MSG_task_listen(const char *alias)
-{
-  CHECK_HOST();
+  if (NULL ==
+      (task =
+       MSG_mailbox_get_head(MSG_mailbox_get_by_channel
+                            (MSG_host_self(), channel))))
+    return -1;
 
-  return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
+  return MSG_process_get_PID(task->simdata->sender);
 }
 
 /** \ingroup msg_gos_functions
@@ -950,65 +929,89 @@ int MSG_task_probe_from_host(int channel, m_host_t host)
 
 }
 
-int MSG_task_listen_from_host(const char *alias, m_host_t host)
+/** \ingroup msg_gos_functions
+ * \brief Listen on \a channel and waits for receiving a task from \a host.
+ *
+ * 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
+ those two condition does not hold, there will be a warning message.
+ * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
+ */
+MSG_error_t
+MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host)
 {
-  CHECK_HOST();
+  XBT_WARN("DEPRECATED! Now use MSG_task_receive_from_host");
+  return MSG_task_get_ext(task, channel, -1, host);
+}
 
-  return
-      MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias
-                                               (alias), host);
+/** \ingroup msg_gos_functions
+ * \brief Listen on a channel and wait for receiving a task.
+ *
+ * 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
+ those two condition does not hold, there will be a warning message.
+ * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
+ */
+MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel)
+{
+  XBT_WARN("DEPRECATED! Now use MSG_task_receive");
+  return MSG_task_get_with_timeout(task, channel, -1);
 }
 
 /** \ingroup msg_gos_functions
- * \brief Test whether there is a pending communication on a channel, and who sent it.
+ * \brief Listen on a channel and wait for receiving a task with a timeout.
  *
- * It takes one parameter.
+ * 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
+ those two condition does not hold, there will be a warning message.
  * \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
+ * \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 a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
  */
-int MSG_task_probe_from(m_channel_t channel)
+MSG_error_t
+MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel,
+                          double max_duration)
 {
-  XBT_WARN("DEPRECATED! Now use MSG_task_listen_from");
-  m_task_t task;
+  XBT_WARN("DEPRECATED! Now use MSG_task_receive_with_timeout");
+  return MSG_task_get_ext(task, channel, max_duration, NULL);
+}
 
-  CHECK_HOST();
+/** \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.
+ */
 
+MSG_error_t
+MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout,
+                 m_host_t host)
+{
+  XBT_WARN("DEPRECATED! Now use MSG_task_receive_ext");
   xbt_assert((channel >= 0)
               && (channel < msg_global->max_channel), "Invalid channel %d",
               channel);
 
-  if (NULL ==
-      (task =
-       MSG_mailbox_get_head(MSG_mailbox_get_by_channel
-                            (MSG_host_self(), channel))))
-    return -1;
-
-  return MSG_process_get_PID(task->simdata->sender);
-}
-
-int MSG_task_listen_from(const char *alias)
-{
-  m_task_t task;
-
-  CHECK_HOST();
-
-  if (NULL ==
-      (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
-    return -1;
-
-  return MSG_process_get_PID(task->simdata->sender);
+  return
+      MSG_mailbox_get_task_ext(MSG_mailbox_get_by_channel
+                               (MSG_host_self(), channel), task, host,
+                               timeout);
 }
 
-#ifdef MSG_USE_DEPRECATED
-/** \ingroup msg_gos_functions
- *
- * \brief Return the last value returned by a MSG function (except
- * MSG_get_errno...).
- */
-MSG_error_t MSG_get_errno(void)
-{
-  return PROCESS_GET_ERRNO();
-}
 #endif