+ default:
+ RETHROW;
+ }
+ xbt_ex_free(e);
+ }
+ return finished;
+}
+
+/** \ingroup msg_gos_functions
+ * \brief This function checks if a communication is finished
+ * \param comms a vector of communications
+ * \return the position of the finished communication if any
+ * (but it may have failed, use MSG_comm_get_status() to know its status),
+ * or -1 if none is finished
+ */
+int MSG_comm_testany(xbt_dynar_t comms)
+{
+ xbt_ex_t e;
+ int finished_index = -1;
+ TRY {
+ finished_index = SIMIX_req_comm_testany(comms);
+ }
+ CATCH(e) {
+ switch (e.category) {
+
+ case host_error:
+ case network_error:
+ case timeout_error:
+ finished_index = e.value;
+ break;
+
+ default:
+ RETHROW;
+ }
+ xbt_ex_free(e);
+ }
+ return finished_index;
+}
+
+/** \ingroup msg_gos_functions
+ * \brief After received TRUE to MSG_comm_test(), the communication should be destroyed.
+ *
+ * It takes one parameter.
+ * \param comm the communication to destroy.
+ */
+void MSG_comm_destroy(msg_comm_t comm)
+{
+ if (SIMIX_req_comm_get_src_proc(comm) != SIMIX_process_self()
+ && MSG_comm_get_status(comm) == MSG_OK) {
+ m_task_t task;
+ task = (m_task_t) SIMIX_req_comm_get_src_buff(comm);
+ task->simdata->isused=0;
+ }
+ SIMIX_req_comm_destroy(comm);
+}
+
+/** \ingroup msg_gos_functions
+ * \brief Wait for the completion of a communication.
+ *
+ * It takes two parameters.
+ * \param comm the communication to wait.
+ * \param timeout Wait until the communication terminates or the timeout occurs
+ * \return MSG_error_t
+ */
+MSG_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
+{
+ xbt_ex_t e;
+ MSG_error_t res = MSG_OK;
+ TRY {
+ SIMIX_req_comm_wait(comm, timeout);
+
+ if (SIMIX_req_comm_get_src_proc(comm) != SIMIX_process_self()) {
+ m_task_t task;
+ task = (m_task_t) SIMIX_req_comm_get_src_buff(comm);
+ task->simdata->isused=0;
+ }
+
+ /* FIXME: these functions are not tracable */
+ }
+ CATCH(e) {
+ switch (e.category) {
+ case host_error:
+ res = MSG_HOST_FAILURE;
+ break;
+ case network_error:
+ res = MSG_TRANSFER_FAILURE;
+ break;
+ case timeout_error:
+ res = MSG_TIMEOUT;
+ break;
+ default:
+ RETHROW;
+ }
+ xbt_ex_free(e);
+ }
+ return res;
+}
+
+/** \ingroup msg_gos_functions
+* \brief This function is called by a sender and permit to wait for each communication
+*
+* It takes three parameters.
+* \param comm a vector of communication
+* \param nb_elem is the size of the comm vector
+* \param timeout for each call of MSG_comm_wait
+*/
+void MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout)
+{
+ int i = 0;
+ for (i = 0; i < nb_elem; i++) {
+ MSG_comm_wait(comm[i], timeout);
+ }
+}
+
+/** \ingroup msg_gos_functions
+* \brief This function wait for the first completed communication
+*
+* It takes on parameter.
+* \param comms a vector of communication
+* \return the position of the completed communication from the xbt_dynar_t.
+*/
+int MSG_comm_waitany(xbt_dynar_t comms)
+{
+ xbt_ex_t e;
+ int finished_index = -1;
+ TRY {
+ finished_index = SIMIX_req_comm_waitany(comms);
+ }
+ CATCH(e) {
+ switch (e.category) {
+
+ case host_error:
+ case network_error:
+ case timeout_error:
+ finished_index = e.value;
+ default:
+ RETHROW;
+ }
+ xbt_ex_free(e);
+ }
+ return finished_index;
+}
+
+/**
+ * \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 the communication
+ * was successfully completed
+ */
+MSG_error_t MSG_comm_get_status(msg_comm_t comm) {
+
+ MSG_error_t result;
+ e_smx_state_t smx_state = SIMIX_req_comm_get_state(comm);
+
+ switch (smx_state) {
+
+ case SIMIX_CANCELED:
+ result = MSG_TASK_CANCELLED;
+ break;
+
+ case SIMIX_FAILED:
+ case SIMIX_SRC_HOST_FAILURE:
+ case SIMIX_DST_HOST_FAILURE:
+ result = MSG_HOST_FAILURE;
+ break;
+
+ case SIMIX_LINK_FAILURE:
+ result = MSG_TRANSFER_FAILURE;
+ break;
+
+ case SIMIX_SRC_TIMEOUT:
+ case SIMIX_DST_TIMEOUT:
+ result = MSG_TIMEOUT;
+ break;
+
+ default:
+ result = MSG_OK;
+ break;
+ }
+ return result;
+}
+
+m_task_t MSG_comm_get_task(msg_comm_t comm)
+{
+ xbt_assert0(comm, "Invalid parameters");
+ return (m_task_t) SIMIX_req_comm_get_src_buff(comm);
+}
+
+/** \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)
+{
+ return MSG_task_put_with_timeout(task, dest, channel, -1.0);