X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ae8140f19db6cb86f753e32499eab49190846d1f..0e8f25088a5fcac96419b8243a2838acd637fa88:/src/msg/msg_gos.c diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c index 513882c2b9..0ce5b3ef84 100644 --- a/src/msg/msg_gos.c +++ b/src/msg/msg_gos.c @@ -12,13 +12,12 @@ 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 */ @@ -27,7 +26,6 @@ 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; - CHECK_HOST(); simdata = task->simdata; @@ -55,7 +53,7 @@ MSG_error_t MSG_task_execute(m_task_t task) 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, + simcall_host_execute(task->name, p_simdata->m_host->smx_host, simdata->computation_amount, simdata->priority); #ifdef HAVE_TRACING @@ -148,23 +146,24 @@ MSG_parallel_task_create(const char *name, int host_nb, 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 - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Executes a parallel task and waits for its termination. * - * \param task - * \return + * \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; - CHECK_HOST(); simdata = task->simdata; p_simdata = SIMIX_process_self_get_data(SIMIX_process_self()); @@ -176,7 +175,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) 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); + XBT_DEBUG("Parallel computing on %s", SIMIX_host_get_name(p_simdata->m_host->smx_host)); simdata->isused=1; @@ -215,7 +214,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) } -/** \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. @@ -253,13 +252,36 @@ MSG_error_t MSG_process_sleep(double nb_sec) } } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Deprecated function that used to receive a task from a mailbox from a specific host. + * + * 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: * - * \param task - * \param alias - * \param host - * \return + * - 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 + * \param host a #m_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, @@ -268,25 +290,40 @@ 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 - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Receives a task from a mailbox. + * + * This is a blocking function, the execution flow will be blocked + * until the task is received. See #MSG_task_irecv + * for receiving tasks asynchronously. * - * \param task - * \param alias - * \return + * \param task a memory location for storing a #m_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) { return MSG_task_receive_with_timeout(task, alias, -1); } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Receives a task from a mailbox with a given timeout. * - * \param task - * \param alias - * \param timeout - * \return + * This is a blocking function with a timeout, the execution flow will be blocked + * until the task is received or the timeout is achieved. See #MSG_task_irecv + * 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 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) + * + * \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_with_timeout(m_task_t * task, const char *alias, @@ -295,14 +332,22 @@ 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 - * \brief Description forthcoming (FIXME) +/** \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 + * until the task is received or the timeout is achieved. See #MSG_task_irecv + * for receiving tasks asynchronously. You can provide a -1 timeout + * to obtain an infinite timeout. * - * \param task - * \param alias - * \param timeout - * \param host - * \return + * \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 + * + * \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, @@ -315,7 +360,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() @@ -330,7 +375,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() @@ -338,20 +383,21 @@ 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_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); - CHECK_HOST(); - /* FIXME: these functions are not traceable */ /* Prepare the task to send */ @@ -379,7 +425,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. @@ -402,8 +448,6 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup) m_process_t process = MSG_process_self(); msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); - CHECK_HOST(); - /* FIXME: these functions are not traceable */ /* Prepare the task to send */ @@ -424,13 +468,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 */ @@ -438,8 +482,6 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name) { smx_rdv_t rdv = MSG_mailbox_get_by_alias(name); - CHECK_HOST(); - /* FIXME: these functions are not traceable */ /* Sanity check */ @@ -459,7 +501,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 @@ -506,7 +548,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 @@ -569,7 +611,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. */ @@ -578,12 +620,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) @@ -619,7 +662,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 @@ -634,7 +677,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 @@ -697,10 +740,10 @@ 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 + * \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) { @@ -708,11 +751,11 @@ MSG_error_t MSG_comm_get_status(msg_comm_t comm) { return comm->status; } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Get a task (#m_task_t) from a communication * - * \param comm - * \return + * \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) { @@ -740,12 +783,18 @@ void MSG_comm_copy_data_from_SIMIX(smx_action_t comm, void* buff, size_t buff_si } } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Sends a task to a mailbox + * + * This is a blocking function, the execution flow will be blocked + * until the task is sent (and received in the other side if #MSG_task_receive is used). + * See #MSG_task_isend for sending tasks asynchronously. * - * \param task - * \param alias - * \return + * \param task the task to be sent + * \param alias the mailbox name to where the task is sent + * + * \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) { @@ -753,13 +802,19 @@ 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 - * \brief Description forthcoming (FIXME) +/** \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 + * until the task is sent. The maxrate parameter allows the application + * to limit the bandwidth utilization of network links when sending the task. * - * \param task - * \param alias - * \param maxrate - * \return + * \param task the task to be sent + * \param alias the mailbox name to where the task is sent + * \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 otherwise. */ MSG_error_t MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate) @@ -768,13 +823,18 @@ MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate) return MSG_task_send(task, alias); } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \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 + * until the task is sent or the timeout is achieved. * - * \param task - * \param alias - * \param timeout - * \return + * \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) + * + * \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, @@ -784,47 +844,48 @@ MSG_task_send_with_timeout(m_task_t task, const char *alias, task, timeout); } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \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 * - * \param alias - * \return + * \return Returns 1 if there is a communication, 0 otherwise */ int MSG_task_listen(const char *alias) { - CHECK_HOST(); - return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias)); } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \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 + * \param host the host to check for communication + * + * \return Returns the number of pending communication actions of the host in the + * given mailbox, 0 if there is no pending communication actions. * - * \param alias - * \param host - * \return */ int MSG_task_listen_from_host(const char *alias, m_host_t host) { - CHECK_HOST(); - return MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias (alias), host); } -/** \ingroup msg_gos_functions - * \brief Description forthcoming (FIXME) +/** \ingroup msg_task_usage + * \brief Look if there is a communication on a mailbox and return the + * PID of the sender process. + * + * \param alias the name of the mailbox to be considered * - * \param alias - * \return + * \return Returns the PID of sender process, + * -1 if there is no communication in the mailbox. */ int MSG_task_listen_from(const char *alias) { m_task_t task; - CHECK_HOST(); - if (NULL == (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias)))) return -1; @@ -832,8 +893,53 @@ int MSG_task_listen_from(const char *alias) return MSG_process_get_PID(task->simdata->sender); } +/** \ingroup msg_task_usage + * \brief Sets the tracing category of a task. + * + * This function should be called after the creation of + * a MSG task, to define the category of that task. The + * first parameter task must contain a task that was + * created with the function #MSG_task_create. The second + * parameter category must contain a category that was + * previously declared with the function #TRACE_category + * (or with #TRACE_category_with_color). + * + * See \ref tracing_tracing for details on how to trace + * the (categorized) resource utilization. + * + * \param task the task that is going to be categorized + * \param category the name of the category to be associated to the task + * + * \see MSG_task_get_category, TRACE_category, TRACE_category_with_color + */ +void MSG_task_set_category (m_task_t task, const char *category) +{ +#ifdef HAVE_TRACING + TRACE_msg_set_task_category (task, category); +#endif +} + +/** \ingroup msg_task_usage + * + * \brief Gets the current tracing category of a task. + * + * \param task the task to be considered + * + * \see MSG_task_set_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) +{ +#ifdef HAVE_TRACING + return task->category; +#else + return NULL; +#endif +} + #ifdef MSG_USE_DEPRECATED -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * * \brief Return the last value returned by a MSG function (except * MSG_get_errno...). @@ -843,11 +949,11 @@ MSG_error_t MSG_get_errno(void) return PROCESS_GET_ERRNO(); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_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 + * 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 @@ -860,7 +966,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 @@ -874,7 +980,7 @@ 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); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \brief Does exactly the same as MSG_task_put but with a bounded transmition * rate. * @@ -889,11 +995,13 @@ MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, return MSG_task_put(task, dest, channel); } -/** \ingroup msg_gos_functions \brief Put a task on a channel of an +/** \ingroup msg_deprecated_functions + * + * \brief Put a task on a channel of an * 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 @@ -906,7 +1014,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 @@ -926,17 +1034,17 @@ 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); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \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 @@ -946,8 +1054,6 @@ int MSG_task_probe_from(m_channel_t channel) XBT_WARN("DEPRECATED! Now use MSG_task_listen_from"); m_task_t task; - CHECK_HOST(); - xbt_assert((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel); @@ -961,11 +1067,11 @@ int MSG_task_probe_from(m_channel_t channel) return MSG_process_get_PID(task->simdata->sender); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \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 @@ -977,20 +1083,18 @@ int MSG_task_Iprobe(m_channel_t channel) && (channel < msg_global->max_channel), "Invalid channel %d", channel); - CHECK_HOST(); - return !MSG_mailbox_is_empty(MSG_mailbox_get_by_channel (MSG_host_self(), channel)); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \brief Return the number of tasks waiting to be received on a \a 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. @@ -1004,8 +1108,6 @@ int MSG_task_probe_from_host(int channel, m_host_t host) && (channel < msg_global->max_channel), "Invalid channel %d", channel); - CHECK_HOST(); - return MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_channel (MSG_host_self(), channel), @@ -1013,7 +1115,7 @@ int MSG_task_probe_from_host(int channel, m_host_t host) } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \brief Listen on \a channel and waits for receiving a task from \a host. * * It takes three parameters. @@ -1021,7 +1123,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. @@ -1034,7 +1136,7 @@ MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host) return MSG_task_get_ext(task, channel, -1, host); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \brief Listen on a channel and wait for receiving a task. * * It takes two parameters. @@ -1042,7 +1144,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. @@ -1053,7 +1155,7 @@ MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel) return MSG_task_get_with_timeout(task, channel, -1); } -/** \ingroup msg_gos_functions +/** \ingroup msg_deprecated_functions * \brief Listen on a channel and wait for receiving a task with a timeout. * * It takes three parameters. @@ -1061,7 +1163,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