X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/80701915842efacf5a40397675b83cd87c9b0184..d9cad55dcc546b3936c278258e7f463ac70066df:/src/msg/msg_gos.c diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c index 45e9dd460f..a5839c38e5 100644 --- a/src/msg/msg_gos.c +++ b/src/msg/msg_gos.c @@ -1,4 +1,4 @@ -/* 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. */ @@ -12,210 +12,111 @@ 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 an agent. It + * 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 - agent is running. + * \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_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; + 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 #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) +{ + 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->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; + 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->smx_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]->simdata->smx_host; + simdata->isused=0; - return task; -} - -/** \ingroup msg_gos_functions - * \brief Executes a parallel task and waits for its termination. - * - * \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) -{ - 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); } -/** \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. @@ -224,41 +125,51 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) */ 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_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 @@ -275,7 +186,7 @@ MSG_task_receive_from_host(m_task_t * task, const char *alias, 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 @@ -294,7 +205,7 @@ MSG_error_t MSG_task_receive(m_task_t * task, const char *alias) 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 @@ -317,7 +228,7 @@ MSG_task_receive_with_timeout(m_task_t * task, const char *alias, 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 @@ -345,7 +256,7 @@ MSG_task_receive_ext(m_task_t * task, const char *alias, double timeout, 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() @@ -360,7 +271,7 @@ msg_comm_t MSG_task_isend(m_task_t task, const char *alias) 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() @@ -368,16 +279,19 @@ msg_comm_t MSG_task_isend(m_task_t task, const char *alias) * * \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; - 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 */ @@ -407,7 +321,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al 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. @@ -427,7 +341,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al 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 */ @@ -450,13 +364,13 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup) 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 */ @@ -483,7 +397,7 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name) 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 @@ -505,12 +419,6 @@ int MSG_comm_test(msg_comm_t 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; @@ -530,7 +438,7 @@ int MSG_comm_test(msg_comm_t comm) 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 @@ -556,12 +464,6 @@ int MSG_comm_testany(xbt_dynar_t 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; @@ -593,7 +495,7 @@ int MSG_comm_testany(xbt_dynar_t comms) return finished_index; } -/** \ingroup msg_gos_functions +/** \ingroup msg_task_usage * \brief Destroys a communication. * \param comm the communication to destroy. */ @@ -602,12 +504,13 @@ void MSG_comm_destroy(msg_comm_t comm) 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) @@ -625,9 +528,6 @@ 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; @@ -643,7 +543,7 @@ MSG_error_t MSG_comm_wait(msg_comm_t comm, double timeout) 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 @@ -658,7 +558,7 @@ void MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout) } } -/** \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 @@ -683,12 +583,6 @@ int MSG_comm_waitany(xbt_dynar_t 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; @@ -721,7 +615,7 @@ int MSG_comm_waitany(xbt_dynar_t comms) } /** - * \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 @@ -732,7 +626,7 @@ MSG_error_t MSG_comm_get_status(msg_comm_t comm) { 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 @@ -764,7 +658,7 @@ void MSG_comm_copy_data_from_SIMIX(smx_action_t comm, void* buff, size_t buff_si } } -/** \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 @@ -783,7 +677,7 @@ MSG_error_t MSG_task_send(m_task_t task, const char *alias) 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 @@ -804,7 +698,7 @@ MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate) 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 @@ -825,7 +719,7 @@ MSG_task_send_with_timeout(m_task_t task, const char *alias, 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 @@ -837,7 +731,7 @@ int MSG_task_listen(const char *alias) 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 @@ -854,7 +748,7 @@ int MSG_task_listen_from_host(const char *alias, m_host_t host) (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. * @@ -874,7 +768,7 @@ int MSG_task_listen_from(const char *alias) 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 @@ -900,7 +794,7 @@ void MSG_task_set_category (m_task_t task, const char *category) #endif } -/** \ingroup msg_gos_functions +/** \ingroup msg_task_usage * * \brief Gets the current tracing category of a task. * @@ -934,7 +828,7 @@ MSG_error_t MSG_get_errno(void) * \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 + * 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 will not be usable anymore when the function will return. There is @@ -947,7 +841,7 @@ MSG_error_t MSG_get_errno(void) 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 + * \param channel the channel on which the process 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_HOST_FAILURE if the host on which @@ -982,7 +876,7 @@ MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, * host (with a timeout on the waiting of the destination host) and * waits for the end of the transmission. * - * This function is used for describing the behavior of an agent. It + * 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 will not be usable anymore when the function will return. There is @@ -995,7 +889,7 @@ MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, 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 + * \param channel the channel on which the process should put this task. This value has to be >=0 and < than the maximal number of channels fixed with MSG_set_channel_number(). * \param timeout the maximum time to wait for a task before giving @@ -1015,7 +909,7 @@ MSG_task_put_with_timeout(m_task_t task, m_host_t dest, && (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); @@ -1025,7 +919,7 @@ MSG_task_put_with_timeout(m_task_t task, m_host_t dest, * \brief Test whether there is a pending communication on a channel, and who sent it. * * It takes one parameter. - * \param channel the channel on which the agent should be + * \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 -1 if there is no pending communication and the PID of the process who sent it otherwise @@ -1052,7 +946,7 @@ int MSG_task_probe_from(m_channel_t channel) * \brief Test whether there is a pending communication on a channel. * * It takes one parameter. - * \param channel the channel on which the agent should be + * \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 1 if there is a pending communication and 0 otherwise @@ -1075,7 +969,7 @@ int MSG_task_Iprobe(m_channel_t channel) channel and sent by \a host. * * It takes two parameters. - * \param channel the channel on which the agent should be + * \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(). * \param host the host that is to be watched. @@ -1104,7 +998,7 @@ int MSG_task_probe_from_host(int channel, m_host_t host) 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 agent should be + * \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(). * \param host the host that is to be watched. @@ -1125,7 +1019,7 @@ MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host) 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 agent should be + * \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. @@ -1144,7 +1038,7 @@ MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel) 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 agent should be + * \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(). * \param max_duration the maximum time to wait for a task before giving