return MSG_parallel_task_execute(task);
}
-/** \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->compute = NULL;
- simdata->comm = NULL;
- simdata->rate = -1.0;
- simdata->isused = 0;
- 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]->smx_host;
-
- return task;
-}
-
/** \ingroup msg_task_usage
* \brief Executes a parallel task and waits for its termination.
*
MSG_error_t MSG_parallel_task_execute(m_task_t task)
{
xbt_ex_t e;
- simdata_task_t simdata = NULL;
- simdata_process_t p_simdata;
+ simdata_task_t simdata = task->simdata;
+ msg_process_t self = SIMIX_process_self();
+ simdata_process_t p_simdata = SIMIX_process_self_get_data(self);
e_smx_state_t comp_state;
MSG_error_t status = MSG_OK;
- simdata = task->simdata;
- m_process_t self = SIMIX_process_self();
- p_simdata = SIMIX_process_self_get_data(self);
-
- #ifdef HAVE_TRACING
- TRACE_msg_task_execute_start(task);
- #endif
+#ifdef HAVE_TRACING
+ TRACE_msg_task_execute_start(task);
+#endif
xbt_assert((!simdata->compute) && (task->simdata->isused == 0),
- "This task is executed somewhere else. Go fix your code! %d",
- task->simdata->isused);
+ "This task is executed somewhere else. Go fix your code! %d",
+ task->simdata->isused);
XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
if (simdata->computation_amount == 0 && !simdata->host_nb) {
- #ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
- #endif
+#ifdef HAVE_TRACING
+ TRACE_msg_task_execute_end(task);
+#endif
return MSG_OK;
}
TRY {
- #ifdef HAVE_TRACING
- simcall_set_category(simdata->compute, task->category);
- #endif
simdata->isused=1;
if (simdata->host_nb > 0) {
- simdata->compute = simcall_host_parallel_execute(task->name, simdata->host_nb,
- simdata->host_list,
- simdata->comp_amount,
- simdata->comm_amount, 1.0, -1.0);
+ simdata->compute = 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);
- }
- else {
- simdata->compute =
- simcall_host_execute(task->name, p_simdata->m_host->smx_host,
- simdata->computation_amount,
- simdata->priority);
+ } else {
+ simdata->compute = simcall_host_execute(task->name,
+ p_simdata->m_host->smx_host,
+ simdata->computation_amount,
+ simdata->priority);
}
+#ifdef HAVE_TRACING
+ simcall_set_category(simdata->compute, task->category);
+#endif
p_simdata->waiting_action = simdata->compute;
comp_state = simcall_host_execution_wait(simdata->compute);
simdata->isused=0;
- XBT_DEBUG("Execution task '%s' finished in state %d", task->name, (int)comp_state);
+ XBT_DEBUG("Execution task '%s' finished in state %d",
+ task->name, (int)comp_state);
}
CATCH(e) {
switch (e.category) {
- case host_error:
- status = MSG_HOST_FAILURE;
- break;
- case cancel_error:
- #ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
- #endif
- status = MSG_TASK_CANCELED;
+ case cancel_error:
+ status = MSG_TASK_CANCELED;
break;
- default:
- RETHROW;
+ default:
+ RETHROW;
}
xbt_ex_free(e);
}
- /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
+ /* action ended, set comm and compute = NULL, the actions is already destroyed
+ * in the main function */
simdata->computation_amount = 0.0;
simdata->comm = NULL;
simdata->compute = NULL;
- #ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
- #endif
+#ifdef HAVE_TRACING
+ TRACE_msg_task_execute_end(task);
+#endif
MSG_RETURN(status);
}
*/
MSG_error_t MSG_process_sleep(double nb_sec)
{
- xbt_ex_t e;
MSG_error_t status = MSG_OK;
- /*m_process_t proc = MSG_process_self();*/
+ /*msg_process_t proc = MSG_process_self();*/
#ifdef HAVE_TRACING
TRACE_msg_process_sleep_in(MSG_process_self());
proc->simdata->waiting_action = NULL;*/
- TRY {
- simcall_process_sleep(nb_sec);
- }
- CATCH(e) {
- switch (e.category) {
- case host_error:
- #ifdef HAVE_TRACING
- TRACE_msg_process_sleep_out(MSG_process_self());
- #endif
- status = MSG_HOST_FAILURE;
- break;
- default:
- RETHROW;
- }
- xbt_ex_free(e);
- }
+ simcall_process_sleep(nb_sec);
#ifdef HAVE_TRACING
TRACE_msg_process_sleep_out(MSG_process_self());
*
* \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 host a #msg_host_t host from where the task was sent
*
* \return Returns
* #MSG_OK if the task was successfully received,
*/
MSG_error_t
MSG_task_receive_from_host(m_task_t * task, const char *alias,
- m_host_t host)
+ msg_host_t host)
{
return MSG_task_receive_ext(task, alias, -1, host);
}
* \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
+ * \param host a #msg_host_t host from where the task was sent
*
* \return Returns
* #MSG_OK if the task was successfully received,
*/
MSG_error_t
MSG_task_receive_ext(m_task_t * task, const char *alias, double timeout,
- m_host_t host)
+ msg_host_t host)
{
XBT_DEBUG
("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'",
void *match_data)
{
simdata_task_t t_simdata = NULL;
- m_process_t process = MSG_process_self();
+ msg_process_t process = MSG_process_self();
msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
/* FIXME: these functions are not traceable */
void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
{
simdata_task_t t_simdata = NULL;
- m_process_t process = MSG_process_self();
+ msg_process_t process = MSG_process_self();
msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
/* FIXME: these functions are not traceable */
}
CATCH(e) {
switch (e.category) {
-
- case host_error:
- comm->status = MSG_HOST_FAILURE;
- finished = 1;
- break;
-
case network_error:
comm->status = MSG_TRANSFER_FAILURE;
finished = 1;
}
CATCH(e) {
switch (e.category) {
-
- case host_error:
- finished_index = e.value;
- status = MSG_HOST_FAILURE;
- break;
-
case network_error:
finished_index = e.value;
status = MSG_TRANSFER_FAILURE;
}
CATCH(e) {
switch (e.category) {
- case host_error:
- comm->status = MSG_HOST_FAILURE;
- break;
case network_error:
comm->status = MSG_TRANSFER_FAILURE;
break;
}
CATCH(e) {
switch (e.category) {
-
- case host_error:
- finished_index = e.value;
- status = MSG_HOST_FAILURE;
- break;
-
case network_error:
finished_index = e.value;
status = MSG_TRANSFER_FAILURE;
* given mailbox, 0 if there is no pending communication actions.
*
*/
-int MSG_task_listen_from_host(const char *alias, m_host_t host)
+int MSG_task_listen_from_host(const char *alias, msg_host_t host)
{
return
MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias
* #MSG_TRANSFER_FAILURE if the transfer could not be properly done
* (network failure, dest failure) or #MSG_OK if it succeeded.
*/
-MSG_error_t MSG_task_put(m_task_t task, m_host_t dest, m_channel_t channel)
+MSG_error_t MSG_task_put(m_task_t task, msg_host_t dest, m_channel_t channel)
{
XBT_WARN("DEPRECATED! Now use MSG_task_send");
return MSG_task_put_with_timeout(task, dest, channel, -1.0);
* \sa MSG_task_put
*/
MSG_error_t
-MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel,
+MSG_task_put_bounded(m_task_t task, msg_host_t dest, m_channel_t channel,
double maxrate)
{
XBT_WARN("DEPRECATED! Now use MSG_task_send_bounded");
(network failure, dest failure, timeout...) or #MSG_OK if the communication succeeded.
*/
MSG_error_t
-MSG_task_put_with_timeout(m_task_t task, m_host_t dest,
+MSG_task_put_with_timeout(m_task_t task, msg_host_t dest,
m_channel_t channel, double timeout)
{
XBT_WARN("DEPRECATED! Now use MSG_task_send_with_timeout");
* \return the number of tasks waiting to be received on \a channel
and sent by \a host.
*/
-int MSG_task_probe_from_host(int channel, m_host_t host)
+int MSG_task_probe_from_host(int channel, msg_host_t host)
{
XBT_WARN("DEPRECATED! Now use MSG_task_listen_from_host");
xbt_assert((channel >= 0)
* \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)
+MSG_task_get_from_host(m_task_t * task, m_channel_t channel, msg_host_t host)
{
XBT_WARN("DEPRECATED! Now use MSG_task_receive_from_host");
return MSG_task_get_ext(task, channel, -1, host);
MSG_error_t
MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout,
- m_host_t host)
+ msg_host_t host)
{
XBT_WARN("DEPRECATED! Now use MSG_task_receive_ext");
xbt_assert((channel >= 0)