-/* Copyright (c) 2004-2011. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2012. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg,
"Logging specific to MSG (gos)");
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Executes a task and waits for its termination.
*
* This function is used for describing the behavior of a process. It
*/
MSG_error_t MSG_task_execute(m_task_t task)
{
- simdata_task_t simdata = NULL;
- simdata_process_t p_simdata;
- e_smx_state_t comp_state;
-
- simdata = task->simdata;
-
- xbt_assert(simdata->host_nb == 0,
- "This is a parallel task. Go to hell.");
-
-#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);
-
- XBT_DEBUG("Computing on %s", MSG_process_get_name(MSG_process_self()));
-
- if (simdata->computation_amount == 0) {
-#ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
-#endif
- return MSG_OK;
- }
-
- m_process_t self = SIMIX_process_self();
- p_simdata = SIMIX_process_self_get_data(self);
- simdata->isused=1;
- simdata->compute =
- simcall_host_execute(task->name, p_simdata->m_host->simdata->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);
- p_simdata->waiting_action = NULL;
-
- simdata->isused=0;
-
- 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;
- simdata->comm = NULL;
- simdata->compute = NULL;
-#ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
-#endif
- MSG_RETURN(MSG_OK);
- } 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;
-#ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
-#endif
- MSG_RETURN(MSG_HOST_FAILURE);
- } else {
- /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
- simdata->comm = NULL;
- simdata->compute = NULL;
-#ifdef HAVE_TRACING
- TRACE_msg_task_execute_end(task);
-#endif
- MSG_RETURN(MSG_TASK_CANCELED);
- }
+ return MSG_parallel_task_execute(task);
}
/** \ingroup m_task_management
simdata->comm_amount = communication_amount;
for (i = 0; i < host_nb; i++)
- simdata->host_list[i] = host_list[i]->simdata->smx_host;
+ simdata->host_list[i] = host_list[i]->smx_host;
return task;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Executes a parallel task and waits for its termination.
*
* \param task a #m_task_t to execute on the location on which the process is running.
*/
MSG_error_t MSG_parallel_task_execute(m_task_t task)
{
- simdata_task_t simdata = NULL;
+ xbt_ex_t e;
+ simdata_task_t simdata = task->simdata;
+ m_process_t self = SIMIX_process_self();
+ simdata_process_t p_simdata = SIMIX_process_self_get_data(self);
e_smx_state_t comp_state;
- simdata_process_t p_simdata;
-
- simdata = task->simdata;
- p_simdata = SIMIX_process_self_get_data(SIMIX_process_self());
-
- xbt_assert((!simdata->compute)
- && (task->simdata->isused == 0),
- "This task is executed somewhere else. Go fix your code!");
-
- xbt_assert(simdata->host_nb,
- "This is not a parallel task. Go to hell.");
-
- XBT_DEBUG("Parallel computing on %s", p_simdata->m_host->name);
-
- simdata->isused=1;
-
- 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);
-
- p_simdata->waiting_action = 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, (int)comp_state);
-
- simdata->isused=0;
-
- 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;
- simdata->comm = NULL;
- simdata->compute = NULL;
- MSG_RETURN(MSG_OK);
- } 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;
- MSG_RETURN(MSG_HOST_FAILURE);
- } else {
- /* action ended, set comm and compute = NULL, the actions is already destroyed in the main function */
- simdata->comm = NULL;
- simdata->compute = NULL;
- MSG_RETURN(MSG_TASK_CANCELED);
+ MSG_error_t status = MSG_OK;
+
+#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);
+
+ 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
+ return MSG_OK;
}
+
+
+ TRY {
+
+ 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);
+ 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);
+
+ }
+#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);
+
+ p_simdata->waiting_action = NULL;
+
+ simdata->isused=0;
+
+ XBT_DEBUG("Execution task '%s' finished in state %d",
+ task->name, (int)comp_state);
+ }
+ CATCH(e) {
+ switch (e.category) {
+ case cancel_error:
+ status = MSG_TASK_CANCELED;
+ break;
+ default:
+ RETHROW;
+ }
+ xbt_ex_free(e);
+ }
+ /* 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
+
+ MSG_RETURN(status);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sleep for the specified number of seconds
*
* Makes the current process sleep until \a time seconds have elapsed.
*/
MSG_error_t MSG_process_sleep(double nb_sec)
{
- e_smx_state_t state;
+ MSG_error_t status = MSG_OK;
/*m_process_t proc = MSG_process_self();*/
#ifdef HAVE_TRACING
#endif
/* create action to sleep */
- state = simcall_process_sleep(nb_sec);
/*proc->simdata->waiting_action = act_sleep;
FIXME: check if not setting the waiting_action breaks something on msg
proc->simdata->waiting_action = NULL;*/
-
- if (state == SIMIX_DONE) {
-#ifdef HAVE_TRACING
- TRACE_msg_process_sleep_out(MSG_process_self());
-#endif
- MSG_RETURN(MSG_OK);
- } else {
-#ifdef HAVE_TRACING
+
+ simcall_process_sleep(nb_sec);
+
+ #ifdef HAVE_TRACING
TRACE_msg_process_sleep_out(MSG_process_self());
-#endif
- MSG_RETURN(MSG_HOST_FAILURE);
- }
+ #endif
+ MSG_RETURN(status);
}
-/** \ingroup msg_gos_functions
- * \brief Receives a task from a mailbox from a specific host.
+/** \ingroup msg_task_usage
+ * \brief Deprecated function that used to receive 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.
+ * Sorry, this function is not supported anymore. That wouldn't be
+ * impossible to reimplement it, but we are lacking the time to do so ourselves.
+ * If you need this functionality, you can either:
+ *
+ * - implement the buffering mechanism on the user-level by queuing all messages
+ * received in the mailbox that do not match your expectation
+ * - change your application logic to leverage the mailboxes features. For example,
+ * if you have A receiving messages from B and C, you could have A waiting on
+ * mailbox "A" most of the time, but on "A#B" when it's waiting for specific
+ * messages from B and "A#C" when waiting for messages from C. You could even get A
+ * sometime waiting on all these mailboxes using @ref MSG_comm_waitany. You can find
+ * an example of use of this function in the @ref MSG_examples section.
+ * - Provide a proper patch to implement this functionality back in MSG. That wouldn't be
+ * very difficult actually. Check the function @ref MSG_mailbox_get_task_ext. During its call to
+ * simcall_comm_recv(), the 5th argument, match_fun, is NULL. Create a function that filters
+ * messages according to the host (that you will pass as sixth argument to simcall_comm_recv()
+ * and that your filtering function will receive as first parameter, and then, the filter could
+ * simply compare the host names, for example. After sufficient testing, provide an example that
+ * we could add to the distribution, and your first contribution to SimGrid is ready. Thanks in advance.
*
* \param task a memory location for storing a #m_task_t.
* \param alias name of the mailbox to receive the task from
return MSG_task_receive_ext(task, alias, -1, host);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Receives a task from a mailbox.
*
* This is a blocking function, the execution flow will be blocked
return MSG_task_receive_with_timeout(task, alias, -1);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Receives a task from a mailbox with a given timeout.
*
* This is a blocking function with a timeout, the execution flow will be blocked
return MSG_task_receive_ext(task, alias, timeout, NULL);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \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
host, timeout);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task on a mailbox.
*
* This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
return MSG_task_isend_with_matching(task,alias,NULL,NULL);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task on a mailbox, with support for matching requests
*
* This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
*
* \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 which parameters are:
+ * - match_data_provided_here
+ * - match_data_provided_by_other_side_if_any
+ * - the_smx_action_describing_the_other_side
* \param match_data user provided data passed to match_fun
* \return the msg_comm_t communication created
*/
XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *alias,
- int (*match_fun)(void*,void*),
+ int (*match_fun)(void*,void*, smx_action_t),
void *match_data)
{
simdata_task_t t_simdata = NULL;
return comm;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task on a mailbox.
*
* This is a non blocking detached send function.
t_simdata->comm = comm;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Starts listening for receiving a task from an asynchronous communication.
*
* This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
* to end the communication.
- *
- * \param task a memory location for storing a #m_task_t.
+ *
+ * \param task a memory location for storing a #m_task_t. has to be valid until the end of the communication.
* \param name of the mailbox to receive the task on
* \return the msg_comm_t communication created
*/
return comm;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Checks whether a communication is done, and if yes, finalizes it.
* \param comm the communication to test
* \return TRUE if the communication is finished
}
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;
return finished;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief This function checks if a communication is finished.
* \param comms a vector of communications
* \return the position of the finished communication if any
}
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;
return finished_index;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Destroys a communication.
* \param comm the communication to destroy.
*/
xbt_free(comm);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \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
+ * \param timeout Wait until the communication terminates or the timeout
+ * occurs. You can provide a -1 timeout to obtain an infinite timeout.
* \return MSG_error_t
*/
MSG_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
}
CATCH(e) {
switch (e.category) {
- case host_error:
- comm->status = MSG_HOST_FAILURE;
- break;
case network_error:
comm->status = MSG_TRANSFER_FAILURE;
break;
return comm->status;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief This function is called by a sender and permit to wait for each communication
*
* \param comm a vector of communication
}
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief This function waits for the first communication finished in a list.
* \param comms a vector of communications
* \return the position of the first finished communication
}
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;
}
/**
- * \ingroup msg_gos_functions
+ * \ingroup msg_task_usage
* \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 comm->status;
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Get a task (#m_task_t) from a communication
*
* \param comm the communication where to get the task
}
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task to a mailbox
*
* This is a blocking function, the execution flow will be blocked
return MSG_task_send_with_timeout(task, alias, -1);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task to a mailbox with a maximum rate
*
* This is a blocking function, the execution flow will be blocked
return MSG_task_send(task, alias);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sends a task to a mailbox with a timeout
*
* This is a blocking function, the execution flow will be blocked
task, timeout);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Check if there is a communication going on in a mailbox.
*
* \param alias the name of the mailbox to be considered
return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias));
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Check the number of communication actions of a given host pending in a mailbox.
*
* \param alias the name of the mailbox to be considered
(alias), host);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Look if there is a communication on a mailbox and return the
* PID of the sender process.
*
return MSG_process_get_PID(task->simdata->sender);
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
* \brief Sets the tracing category of a task.
*
* This function should be called after the creation of
#endif
}
-/** \ingroup msg_gos_functions
+/** \ingroup msg_task_usage
*
* \brief Gets the current tracing category of a task.
*
&& (channel < msg_global->max_channel), "Invalid channel %d",
channel);
- XBT_DEBUG("MSG_task_put_with_timout: Trying to send a task to '%s'", dest->name);
+ XBT_DEBUG("MSG_task_put_with_timout: Trying to send a task to '%s'", SIMIX_host_get_name(dest->smx_host));
return
MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_channel
(dest, channel), task, timeout);