X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7f67129dcfc866e6ef4a1b266088a7e7eef1bf9f..fe95cac680e092ba56877fe257ed1056ccab03ff:/src/msg/msg_gos.c

diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c
index dc1b77a96d..755608b4fe 100644
--- a/src/msg/msg_gos.c
+++ b/src/msg/msg_gos.c
@@ -68,7 +68,7 @@ MSG_error_t MSG_task_execute(m_task_t task)
 
   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;
@@ -153,6 +153,14 @@ MSG_parallel_task_create(const char *name, int host_nb,
   return task;
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Executes a parallel task and waits for its termination.
+ *
+ * \param task a #m_task_t to execute on the location on which the agent is running.
+ *
+ * \return #MSG_OK if the task was successfully completed, #MSG_TASK_CANCELED
+ * or #MSG_HOST_FAILURE otherwise
+ */
 MSG_error_t MSG_parallel_task_execute(m_task_t task)
 {
   simdata_task_t simdata = NULL;
@@ -185,7 +193,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task)
   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;
 
@@ -247,6 +255,14 @@ MSG_error_t MSG_process_sleep(double nb_sec)
   }
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Starts listening for receiving a task from an specific host communication.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task to
+ * \param host a #m_host_t host from where task were send
+ * \return return status #MSG_error_t
+ */
 MSG_error_t
 MSG_task_receive_from_host(m_task_t * task, const char *alias,
                            m_host_t host)
@@ -254,11 +270,26 @@ MSG_task_receive_from_host(m_task_t * task, const char *alias,
   return MSG_task_receive_ext(task, alias, -1, host);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Starts listening for receiving a task from a communication.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task to
+ * \return return status #MSG_error_t
+ */
 MSG_error_t MSG_task_receive(m_task_t * task, const char *alias)
 {
   return MSG_task_receive_with_timeout(task, alias, -1);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Starts listening for receiving a task from a communication.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task to
+ * \param timeout is the maximum wait time for completion
+ * \return return status #MSG_error_t
+ */
 MSG_error_t
 MSG_task_receive_with_timeout(m_task_t * task, const char *alias,
                               double timeout)
@@ -266,6 +297,16 @@ MSG_task_receive_with_timeout(m_task_t * task, const char *alias,
   return MSG_task_receive_ext(task, alias, timeout, NULL);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Starts listening for receiving a task from an specific host communication
+ * with a timeout.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task to
+ * \param timeout Maximum time for receiving task
+ * \param host a #m_host_t host from where task were send
+ * \return return status #MSG_error_t
+ */
 MSG_error_t
 MSG_task_receive_ext(m_task_t * task, const char *alias, double timeout,
                      m_host_t host)
@@ -300,7 +341,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
  */
@@ -670,6 +711,12 @@ MSG_error_t MSG_comm_get_status(msg_comm_t comm) {
   return comm->status;
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Get a task (#m_task_t) from a communication
+ *
+ * \param comm the communication where to get the task
+ * \return the task from the communication
+ */
 m_task_t MSG_comm_get_task(msg_comm_t comm)
 {
   xbt_assert(comm, "Invalid parameter");
@@ -696,13 +743,27 @@ void MSG_comm_copy_data_from_SIMIX(smx_action_t comm, void* buff, size_t buff_si
   }
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Send a task into a mailbox
+ *
+ * \param task the task to send
+ * \param alias the mailbox name where the task is send
+ * \return a return code (#MSG_error_t)
+ */
 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);
 }
 
-
+/** \ingroup msg_gos_functions
+ * \brief Send a task into a mailbox with a maximum rate
+ *
+ * \param task the task to send
+ * \param alias the mailbox name where the task is send
+ * \param maxrate the maximum rate for communication
+ * \return a return code (#MSG_error_t)
+ */
 MSG_error_t
 MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate)
 {
@@ -710,7 +771,14 @@ MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate)
   return MSG_task_send(task, alias);
 }
 
-
+/** \ingroup msg_gos_functions
+ * \brief Send a task into a mailbox with a timeout
+ *
+ * \param task the task to send
+ * \param alias the mailbox name where the task is send
+ * \param timeout the time for the timeout
+ * \return a return code (#MSG_error_t)
+ */
 MSG_error_t
 MSG_task_send_with_timeout(m_task_t task, const char *alias,
                            double timeout)
@@ -719,6 +787,12 @@ MSG_task_send_with_timeout(m_task_t task, const char *alias,
                                       task, timeout);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Look if there is a communication on a mailbox
+ *
+ * \param alias the mailbox to listen
+ * \return return 1 if there is a communication or 0
+ */
 int MSG_task_listen(const char *alias)
 {
   CHECK_HOST();
@@ -726,6 +800,14 @@ int MSG_task_listen(const char *alias)
   return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Look if there is a communication on a mailbox from
+ * a given host
+ *
+ * \param alias the mailbox to listen
+ * \param host the host to check for communication
+ * \return return 1 if there is a communication or 0
+ */
 int MSG_task_listen_from_host(const char *alias, m_host_t host)
 {
   CHECK_HOST();
@@ -735,6 +817,13 @@ int MSG_task_listen_from_host(const char *alias, m_host_t host)
                                                (alias), host);
 }
 
+/** \ingroup msg_gos_functions
+ * \brief Look if there is a communication on a mailbox and return the
+ * PID from sender process
+ *
+ * \param alias the mailbox to listen
+ * \return return the PID of process(or 0 in case of problem)
+ */
 int MSG_task_listen_from(const char *alias)
 {
   m_task_t task;
@@ -994,11 +1083,6 @@ MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel,
   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)