}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Executes a parallel task and waits for its termination.
*
- * \param task
- * \return
+ * \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)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Receives a task from a mailbox from a specific host.
+ *
+ * This is a blocking function, the execution flow will be blocked
+ * until the task is received. See #MSG_task_irecv
+ * for receiving tasks asynchronously.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task from
+ * \param host a #m_host_t host from where the task was sent
*
- * \param task
- * \param alias
- * \param host
- * \return
+ * \return Returns
+ * #MSG_OK if the task was successfully received,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
*/
MSG_error_t
MSG_task_receive_from_host(m_task_t * task, const char *alias,
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Receives a task from a mailbox.
*
- * \param task
- * \param alias
- * \return
+ * This is a blocking function, the execution flow will be blocked
+ * until the task is received. See #MSG_task_irecv
+ * for receiving tasks asynchronously.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task from
+ *
+ * \return Returns
+ * #MSG_OK if the task was successfully received,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
*/
MSG_error_t MSG_task_receive(m_task_t * task, const char *alias)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Receives a task from a mailbox with a given timeout.
*
- * \param task
- * \param alias
- * \param timeout
- * \return
+ * This is a blocking function with a timeout, the execution flow will be blocked
+ * until the task is received or the timeout is achieved. See #MSG_task_irecv
+ * for receiving tasks asynchronously. You can provide a -1 timeout
+ * to obtain an infinite timeout.
+ *
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task from
+ * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_receive)
+ *
+ * \return Returns
+ * #MSG_OK if the task was successfully received,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
*/
MSG_error_t
MSG_task_receive_with_timeout(m_task_t * task, const char *alias,
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Receives a task from a mailbox from a specific host with a given timeout.
+ *
+ * This is a blocking function with a timeout, the execution flow will be blocked
+ * until the task is received or the timeout is achieved. See #MSG_task_irecv
+ * for receiving tasks asynchronously. You can provide a -1 timeout
+ * to obtain an infinite timeout.
*
- * \param task
- * \param alias
- * \param timeout
- * \param host
- * \return
+ * \param task a memory location for storing a #m_task_t.
+ * \param alias name of the mailbox to receive the task from
+ * \param timeout is the maximum wait time for completion (provide -1 for no timeout)
+ * \param host a #m_host_t host from where the task was sent
+ *
+ * \return Returns
+ * #MSG_OK if the task was successfully received,
+* #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
*/
MSG_error_t
MSG_task_receive_ext(m_task_t * task, const char *alias, double timeout,
* \ingroup msg_gos_functions
* \brief Returns the error (if any) that occured during a finished communication.
* \param comm a finished communication
- * \return the status of the communication, or MSG_OK if no error occured
+ * \return the status of the communication, or #MSG_OK if no error occured
* during the communication
*/
MSG_error_t MSG_comm_get_status(msg_comm_t comm) {
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Get a task (#m_task_t) from a communication
*
- * \param comm
- * \return
+ * \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)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Sends a task to a mailbox
+ *
+ * This is a blocking function, the execution flow will be blocked
+ * until the task is sent (and received in the other side if #MSG_task_receive is used).
+ * See #MSG_task_isend for sending tasks asynchronously.
*
- * \param task
- * \param alias
- * \return
+ * \param task the task to be sent
+ * \param alias the mailbox name to where the task is sent
+ *
+ * \return Returns #MSG_OK if the task was successfully sent,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
*/
MSG_error_t MSG_task_send(m_task_t task, const char *alias)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Sends a task to a mailbox with a maximum rate
+ *
+ * This is a blocking function, the execution flow will be blocked
+ * until the task is sent. The maxrate parameter allows the application
+ * to limit the bandwidth utilization of network links when sending the task.
+ *
+ * \param task the task to be sent
+ * \param alias the mailbox name to where the task is sent
+ * \param maxrate the maximum communication rate for sending this task
*
- * \param task
- * \param alias
- * \param maxrate
- * \return
+ * \return Returns #MSG_OK if the task was successfully sent,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
*/
MSG_error_t
MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate)
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Sends a task to a mailbox with a timeout
+ *
+ * This is a blocking function, the execution flow will be blocked
+ * until the task is sent or the timeout is achieved.
+ *
+ * \param task the task to be sent
+ * \param alias the mailbox name to where the task is sent
+ * \param timeout is the maximum wait time for completion (if -1, this call is the same as #MSG_task_send)
*
- * \param task
- * \param alias
- * \param timeout
- * \return
+ * \return Returns #MSG_OK if the task was successfully sent,
+ * #MSG_HOST_FAILURE, or #MSG_TRANSFER_FAILURE, or #MSG_TIMEOUT otherwise.
*/
MSG_error_t
MSG_task_send_with_timeout(m_task_t task, const char *alias,
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Look if there is a communication on a mailbox
*
- * \param alias
- * \return
+ * \param alias the mailbox to listen
+ * \return return 1 if there is a communication or 0
*/
int MSG_task_listen(const char *alias)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Look if there is a communication on a mailbox from
+ * a given host
*
- * \param alias
- * \param host
- * \return
+ * \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)
{
}
/** \ingroup msg_gos_functions
- * \brief Description forthcoming (FIXME)
+ * \brief Look if there is a communication on a mailbox and return the
+ * PID from sender process
*
- * \param alias
- * \return
+ * \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)
{
