-/* 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. */
*
* This function is used for describing the behavior of a process. It
* takes only one parameter.
- * \param task a #m_task_t to execute on the location on which the process is running.
+ * \param task a #msg_task_t to execute on the location on which the process is running.
* \return #MSG_OK if the task was successfully completed, #MSG_TASK_CANCELED
* or #MSG_HOST_FAILURE otherwise
*/
-MSG_error_t MSG_task_execute(m_task_t task)
+msg_error_t MSG_task_execute(msg_task_t task)
{
- simdata_task_t simdata = NULL;
- simdata_process_t p_simdata;
- e_smx_state_t comp_state;
-
- simdata = task->simdata;
+ return MSG_parallel_task_execute(task);
+}
- xbt_assert(simdata->host_nb == 0,
- "This is a parallel task. Go to hell.");
+/** \ingroup msg_task_usage
+ * \brief Executes a parallel task and waits for its termination.
+ *
+ * \param task a #msg_task_t to execute on the location on which the process 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(msg_task_t task)
+{
+ xbt_ex_t e;
+ 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;
#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) {
+ if (simdata->computation_amount == 0 && !simdata->host_nb) {
#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->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;
+ TRY {
- simdata->isused=0;
+ 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,
+ simdata->computation_amount,
+ simdata->priority);
- 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);
+ simcall_set_category(simdata->compute, task->category);
#endif
- MSG_RETURN(MSG_TASK_CANCELED);
- }
-}
-
-/** \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;
+ p_simdata->waiting_action = simdata->compute;
+ comp_state = simcall_host_execution_wait(simdata->compute);
- 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;
+ p_simdata->waiting_action = NULL;
- for (i = 0; i < host_nb; i++)
- simdata->host_list[i] = host_list[i]->smx_host;
+ simdata->isused=0;
- return task;
-}
-
-/** \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.
- *
- * \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;
- 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);
+ 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);
}
*
* \param nb_sec a number of second
*/
-MSG_error_t MSG_process_sleep(double nb_sec)
+msg_error_t MSG_process_sleep(double nb_sec)
{
- e_smx_state_t state;
- /*m_process_t proc = MSG_process_self();*/
+ msg_error_t status = MSG_OK;
+ /*msg_process_t proc = MSG_process_self();*/
#ifdef HAVE_TRACING
TRACE_msg_process_sleep_in(MSG_process_self());
#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_task_usage
* 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 task a memory location for storing a #msg_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_HOST_FAILURE, or #MSG_TRANSFER_FAILURE otherwise.
*/
-MSG_error_t
-MSG_task_receive_from_host(m_task_t * task, const char *alias,
- m_host_t host)
+msg_error_t
+MSG_task_receive_from_host(msg_task_t * task, const char *alias,
+ msg_host_t host)
{
return MSG_task_receive_ext(task, alias, -1, host);
}
* 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 task a memory location for storing a #msg_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)
+msg_error_t MSG_task_receive(msg_task_t * task, const char *alias)
{
return MSG_task_receive_with_timeout(task, alias, -1);
}
* 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 task a memory location for storing a #msg_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)
*
* #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,
+msg_error_t
+MSG_task_receive_with_timeout(msg_task_t * task, const char *alias,
double timeout)
{
return MSG_task_receive_ext(task, alias, timeout, NULL);
* 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 task a memory location for storing a #msg_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_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,
- m_host_t host)
+msg_error_t
+MSG_task_receive_ext(msg_task_t * task, const char *alias, double timeout,
+ msg_host_t host)
{
XBT_DEBUG
("MSG_task_receive_ext: Trying to receive a message on mailbox '%s'",
* This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
* to end the communication.
*
- * \param task a #m_task_t to send on another location.
+ * \param task a #msg_task_t to send on another location.
* \param alias name of the mailbox to sent the task to
* \return the msg_comm_t communication created
*/
-msg_comm_t MSG_task_isend(m_task_t task, const char *alias)
+msg_comm_t MSG_task_isend(msg_task_t task, const char *alias)
{
return MSG_task_isend_with_matching(task,alias,NULL,NULL);
}
+/** \ingroup msg_task_usage
+ * \brief Sends a task on a mailbox with a maximum rate
+ *
+ * This is a non blocking function: use MSG_comm_wait() or MSG_comm_test()
+ * to end the communication. The maxrate parameter allows the application
+ * to limit the bandwidth utilization of network links when sending the task.
+ *
+ * \param task a #msg_task_t to send on another location.
+ * \param alias name of the mailbox to sent the task to
+ * \param maxrate the maximum communication rate for sending this task .
+ * \return the msg_comm_t communication created
+ */
+msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate)
+{
+ task->simdata->rate = maxrate;
+ return MSG_task_isend_with_matching(task,alias,NULL,NULL);
+}
+
+
/** \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()
* to end the communication.
*
- * \param task a #m_task_t to send on another location.
+ * \param task a #msg_task_t to send on another location.
* \param alias name of the mailbox to sent the task to
* \param match_fun boolean function which parameters are:
* - match_data_provided_here
* \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,
+XBT_INLINE msg_comm_t MSG_task_isend_with_matching(msg_task_t task, const char *alias,
int (*match_fun)(void*,void*, smx_action_t),
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 */
+#ifdef HAVE_TRACING
+ int call_end = TRACE_msg_task_put_start(task);
+#endif
/* Prepare the task to send */
t_simdata = task->simdata;
simcall_comm_isend(mailbox, t_simdata->message_size,
t_simdata->rate, task, sizeof(void *), match_fun, NULL, match_data, 0);
t_simdata->comm = comm->s_comm; /* FIXME: is the field t_simdata->comm still useful? */
+#ifdef HAVE_TRACING
+ if (TRACE_is_enabled()) {
+ simcall_set_category(comm->s_comm, task->category);
+ }
+#endif
+
+#ifdef HAVE_TRACING
+ if (call_end)
+ TRACE_msg_task_put_end();
+#endif
return comm;
}
* <a href="http://lists.gforge.inria.fr/pipermail/simgrid-user/2011-November/002649.html">this thread</a>
* in the SimGrid-user mailing list archive.
*
- * \param task a #m_task_t to send on another location.
+ * \param task a #msg_task_t to send on another location.
* \param alias name of the mailbox to sent the task to
* \param cleanup a function to destroy the task if the
* communication fails, e.g. MSG_task_destroy
* (if NULL, no function will be called)
*/
-void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup)
+void MSG_task_dsend(msg_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 */
+ /* Prepare the task to send */
+ t_simdata = task->simdata;
+ t_simdata->sender = process;
+ t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;
+
+ xbt_assert(t_simdata->isused == 0,
+ "This task is still being used somewhere else. You cannot send it now. Go fix your code!");
+
+ t_simdata->isused = 1;
+ t_simdata->comm = NULL;
+ msg_global->sent_msg++;
+
+#ifdef HAVE_TRACING
+ int call_end = TRACE_msg_task_put_start(task);
+#endif
+
+ /* Send it by calling SIMIX network layer */
+ smx_action_t comm = simcall_comm_isend(mailbox, t_simdata->message_size,
+ t_simdata->rate, task, sizeof(void *), NULL, cleanup, NULL, 1);
+ t_simdata->comm = comm;
+#ifdef HAVE_TRACING
+ if (TRACE_is_enabled()) {
+ simcall_set_category(comm, task->category);
+ }
+#endif
+
+#ifdef HAVE_TRACING
+ if (call_end)
+ TRACE_msg_task_put_end();
+#endif
+}
+
+
+/** \ingroup msg_task_usage
+ * \brief Sends a task on a mailbox with a maximal rate.
+ *
+ * This is a non blocking detached send function.
+ * Think of it as a best effort send. Keep in mind that the third parameter
+ * is only called if the communication fails. If the communication does work,
+ * it is responsibility of the receiver code to free anything related to
+ * the task, as usual. More details on this can be obtained on
+ * <a href="http://lists.gforge.inria.fr/pipermail/simgrid-user/2011-November/002649.html">this thread</a>
+ * in the SimGrid-user mailing list archive.
+ *
+ * \param task a #msg_task_t to send on another location.
+ * \param alias name of the mailbox to sent the task to
+ * \param cleanup a function to destroy the task if the
+ * communication fails, e.g. MSG_task_destroy
+ * (if NULL, no function will be called)
+ * \param maxrate the maximum communication rate for sending this task
+ *
+ */
+void MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate)
+{
+ task->simdata->rate = maxrate;
+
+ simdata_task_t t_simdata = NULL;
+ msg_process_t process = MSG_process_self();
+ msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
/* Prepare the task to send */
t_simdata = task->simdata;
t_simdata->comm = NULL;
msg_global->sent_msg++;
+#ifdef HAVE_TRACING
+ int call_end = TRACE_msg_task_put_start(task);
+#endif
+
/* Send it by calling SIMIX network layer */
smx_action_t comm = simcall_comm_isend(mailbox, t_simdata->message_size,
t_simdata->rate, task, sizeof(void *), NULL, cleanup, NULL, 1);
t_simdata->comm = comm;
+#ifdef HAVE_TRACING
+ if (TRACE_is_enabled()) {
+ simcall_set_category(comm, task->category);
+ }
+#endif
+
+#ifdef HAVE_TRACING
+ if (call_end)
+ TRACE_msg_task_put_end();
+#endif
}
/** \ingroup msg_task_usage
*
* 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 #msg_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
*/
-msg_comm_t MSG_task_irecv(m_task_t *task, const char *name)
+msg_comm_t MSG_task_irecv(msg_task_t *task, const char *name)
{
smx_rdv_t rdv = MSG_mailbox_get_by_alias(name);
{
xbt_ex_t e;
int finished = 0;
+
TRY {
finished = simcall_comm_test(comm->s_comm);
}
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;
xbt_dynar_push(s_comms, &comm->s_comm);
}
- MSG_error_t status = MSG_OK;
+ msg_error_t status = MSG_OK;
TRY {
finished_index = simcall_comm_testany(s_comms);
}
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;
*
* 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
+ * \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)
+msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout)
{
xbt_ex_t e;
TRY {
}
CATCH(e) {
switch (e.category) {
- case host_error:
- comm->status = MSG_HOST_FAILURE;
- break;
case network_error:
comm->status = MSG_TRANSFER_FAILURE;
break;
xbt_dynar_push(s_comms, &comm->s_comm);
}
- MSG_error_t status = MSG_OK;
+ msg_error_t status = MSG_OK;
TRY {
finished_index = simcall_comm_waitany(s_comms);
}
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 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) {
+msg_error_t MSG_comm_get_status(msg_comm_t comm) {
return comm->status;
}
/** \ingroup msg_task_usage
- * \brief Get a task (#m_task_t) from a communication
+ * \brief Get a task (#msg_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)
+msg_task_t MSG_comm_get_task(msg_comm_t comm)
{
xbt_assert(comm, "Invalid parameter");
}
/**
- * \brief This function is called by SIMIX to copy the data of a comm.
+ * \brief This function is called by SIMIX in kernel mode to copy the data of a comm.
* \param comm the comm
* \param buff the data copied
* \param buff_size size of the buffer
// notify the user callback if any
if (msg_global->task_copy_callback) {
- m_task_t task = buff;
+ msg_task_t task = buff;
msg_global->task_copy_callback(task,
simcall_comm_get_src_proc(comm), simcall_comm_get_dst_proc(comm));
}
* \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)
+msg_error_t MSG_task_send(msg_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);
* \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)
+msg_error_t
+MSG_task_send_bounded(msg_task_t task, const char *alias, double maxrate)
{
task->simdata->rate = maxrate;
return MSG_task_send(task, alias);
* \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,
+msg_error_t
+MSG_task_send_with_timeout(msg_task_t task, const char *alias,
double timeout)
{
return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
task, timeout);
}
+/** \ingroup msg_task_usage
+ * \brief Sends a task to a mailbox with a timeout and with a maximum rate
+ *
+ * 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 maxrate the maximum communication rate for sending this task
+ *
+ * \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_bounded(msg_task_t task, const char *alias,
+ double timeout, double maxrate)
+{
+ task->simdata->rate = maxrate;
+ return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias),
+ task, timeout);
+}
+
/** \ingroup msg_task_usage
* \brief Check if there is a communication going on in a mailbox.
*
* 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
*/
int MSG_task_listen_from(const char *alias)
{
- m_task_t task;
+ msg_task_t task;
if (NULL ==
(task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias))))
* previously declared with the function #TRACE_category
* (or with #TRACE_category_with_color).
*
- * See \ref tracing_tracing for details on how to trace
+ * See \ref tracing for details on how to trace
* the (categorized) resource utilization.
*
* \param task the task that is going to be categorized
*
* \see MSG_task_get_category, TRACE_category, TRACE_category_with_color
*/
-void MSG_task_set_category (m_task_t task, const char *category)
+void MSG_task_set_category (msg_task_t task, const char *category)
{
#ifdef HAVE_TRACING
TRACE_msg_set_task_category (task, category);
*
* \return Returns the name of the tracing category of the given task, NULL otherwise
*/
-const char *MSG_task_get_category (m_task_t task)
+const char *MSG_task_get_category (msg_task_t task)
{
#ifdef HAVE_TRACING
return task->category;
#endif
}
+/**
+ * \brief Returns the value of a given AS or router property
+ *
+ * \param asr the name of a router or AS
+ * \param name a property name
+ * \return value of a property (or NULL if property not set)
+ */
+const char *MSG_as_router_get_property_value(const char* asr, const char *name)
+{
+ return xbt_dict_get_or_null(MSG_as_router_get_properties(asr), name);
+}
+
+/**
+ * \brief Returns a xbt_dict_t consisting of the list of properties assigned to
+ * a the AS or router
+ *
+ * \param asr the name of a router or AS
+ * \return a dict containing the properties
+ */
+xbt_dict_t MSG_as_router_get_properties(const char* asr)
+{
+ return (simcall_asr_get_properties(asr));
+}
+
+/**
+ * \brief Change the value of a given AS or router
+ *
+ * \param asr the name of a router or AS
+ * \param name a property name
+ * \param value what to change the property to
+ * \param free_ctn the freeing function to use to kill the value on need
+ */
+void MSG_as_router_set_property_value(const char* asr, const char *name, char *value,void_f_pvoid_t free_ctn) {
+ xbt_dict_set(MSG_as_router_get_properties(asr), name, value,free_ctn);
+}
+
#ifdef MSG_USE_DEPRECATED
/** \ingroup msg_deprecated_functions
*
* \brief Return the last value returned by a MSG function (except
* MSG_get_errno...).
*/
-MSG_error_t MSG_get_errno(void)
+msg_error_t MSG_get_errno(void)
{
return PROCESS_GET_ERRNO();
}
*
* This function is used for describing the behavior of a process. It
* takes three parameter.
- * \param task a #m_task_t to send on another location. This task
+ * \param task a #msg_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
* #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(msg_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_error_t
+MSG_task_put_bounded(msg_task_t task, msg_host_t dest, m_channel_t channel,
double maxrate)
{
XBT_WARN("DEPRECATED! Now use MSG_task_send_bounded");
*
* This function is used for describing the behavior of a process. It
* takes four parameter.
- * \param task a #m_task_t to send on another location. This task
+ * \param task a #msg_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
#MSG_TRANSFER_FAILURE if the transfer could not be properly done
(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_error_t
+MSG_task_put_with_timeout(msg_task_t task, msg_host_t dest,
m_channel_t channel, double timeout)
{
XBT_WARN("DEPRECATED! Now use MSG_task_send_with_timeout");
&& (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);
int MSG_task_probe_from(m_channel_t channel)
{
XBT_WARN("DEPRECATED! Now use MSG_task_listen_from");
- m_task_t task;
+ msg_task_t task;
xbt_assert((channel >= 0)
&& (channel < msg_global->max_channel), "Invalid channel %d",
* \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)
* \brief Listen on \a channel and waits for receiving a task from \a host.
*
* It takes three parameters.
- * \param task a memory location for storing a #m_task_t. It will
+ * \param task a memory location for storing a #msg_task_t. It will
hold a task when this function will return. Thus \a task should not
be equal to \c NULL and \a *task should be equal to \c NULL. If one of
those two condition does not hold, there will be a warning message.
listening. This value has to be >=0 and < than the maximal
number of channels fixed with MSG_set_channel_number().
* \param host the host that is to be watched.
- * \return a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
+ * \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_error_t
+MSG_task_get_from_host(msg_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);
* \brief Listen on a channel and wait for receiving a task.
*
* It takes two parameters.
- * \param task a memory location for storing a #m_task_t. It will
+ * \param task a memory location for storing a #msg_task_t. It will
hold a task when this function will return. Thus \a task should not
be equal to \c NULL and \a *task should be equal to \c NULL. If one of
those two condition does not hold, there will be a warning message.
* \param channel the channel on which the process should be
listening. This value has to be >=0 and < than the maximal
number of channels fixed with MSG_set_channel_number().
- * \return a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
+ * \return a #msg_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
*/
-MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel)
+msg_error_t MSG_task_get(msg_task_t * task, m_channel_t channel)
{
XBT_WARN("DEPRECATED! Now use MSG_task_receive");
return MSG_task_get_with_timeout(task, channel, -1);
* \brief Listen on a channel and wait for receiving a task with a timeout.
*
* It takes three parameters.
- * \param task a memory location for storing a #m_task_t. It will
+ * \param task a memory location for storing a #msg_task_t. It will
hold a task when this function will return. Thus \a task should not
be equal to \c NULL and \a *task should be equal to \c NULL. If one of
those two condition does not hold, there will be a warning message.
up. In such a case, #MSG_TRANSFER_FAILURE will be returned, \a task
will not be modified and will still be
equal to \c NULL when returning.
- * \return a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
+ * \return a #msg_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise.
*/
-MSG_error_t
-MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel,
+msg_error_t
+MSG_task_get_with_timeout(msg_task_t * task, m_channel_t channel,
double max_duration)
{
XBT_WARN("DEPRECATED! Now use MSG_task_receive_with_timeout");
return MSG_task_get_ext(task, channel, max_duration, NULL);
}
-MSG_error_t
-MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout,
- m_host_t host)
+msg_error_t
+MSG_task_get_ext(msg_task_t * task, m_channel_t channel, double timeout,
+ msg_host_t host)
{
XBT_WARN("DEPRECATED! Now use MSG_task_receive_ext");
xbt_assert((channel >= 0)
