X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7d8a6180b3769b53adbe4600df95074763141495..e0d9798ceb9a6a8c73b59c6c3bf5a514c2b02609:/src/msg/msg_gos.c diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c index 5346028394..513882c2b9 100644 --- a/src/msg/msg_gos.c +++ b/src/msg/msg_gos.c @@ -9,7 +9,6 @@ #include "xbt/log.h" #include "xbt/sysdep.h" - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg, "Logging specific to MSG (gos)"); @@ -56,20 +55,20 @@ MSG_error_t MSG_task_execute(m_task_t task) p_simdata = SIMIX_process_self_get_data(self); simdata->isused=1; simdata->compute = - SIMIX_req_host_execute(task->name, p_simdata->m_host->simdata->smx_host, + simcall_host_execute(task->name, p_simdata->m_host->simdata->smx_host, simdata->computation_amount, simdata->priority); #ifdef HAVE_TRACING - SIMIX_req_set_category(simdata->compute, task->category); + simcall_set_category(simdata->compute, task->category); #endif p_simdata->waiting_action = simdata->compute; - comp_state = SIMIX_req_host_execution_wait(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, comp_state); + 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; @@ -79,7 +78,7 @@ MSG_error_t MSG_task_execute(m_task_t task) TRACE_msg_task_execute_end(task); #endif MSG_RETURN(MSG_OK); - } else if (SIMIX_req_host_get_state(SIMIX_host_self()) == 0) { + } 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; @@ -154,6 +153,12 @@ MSG_parallel_task_create(const char *name, int host_nb, return task; } +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param task + * \return + */ MSG_error_t MSG_parallel_task_execute(m_task_t task) { simdata_task_t simdata = NULL; @@ -176,17 +181,17 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) simdata->isused=1; simdata->compute = - SIMIX_req_host_parallel_execute(task->name, simdata->host_nb, + 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 = SIMIX_req_host_execution_wait(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, comp_state); + XBT_DEBUG("Finished waiting for execution of action %p, state = %d", simdata->compute, (int)comp_state); simdata->isused=0; @@ -196,7 +201,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) simdata->comm = NULL; simdata->compute = NULL; MSG_RETURN(MSG_OK); - } else if (SIMIX_req_host_get_state(SIMIX_host_self()) == 0) { + } 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; @@ -227,7 +232,7 @@ MSG_error_t MSG_process_sleep(double nb_sec) #endif /* create action to sleep */ - state = SIMIX_req_process_sleep(nb_sec); + state = simcall_process_sleep(nb_sec); /*proc->simdata->waiting_action = act_sleep; @@ -249,98 +254,40 @@ MSG_error_t MSG_process_sleep(double nb_sec) } /** \ingroup msg_gos_functions - * \brief Listen on \a channel and waits for receiving a task from \a host. + * \brief Description forthcoming (FIXME) * - * It takes three parameters. - * \param task a memory location for storing a #m_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 agent 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. - * \return a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise. + * \param task + * \param alias + * \param host + * \return */ MSG_error_t -MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host) +MSG_task_receive_from_host(m_task_t * task, const char *alias, + m_host_t host) { - return MSG_task_get_ext(task, channel, -1, host); + return MSG_task_receive_ext(task, alias, -1, host); } /** \ingroup msg_gos_functions - * \brief Listen on a channel and wait for receiving a task. + * \brief Description forthcoming (FIXME) * - * It takes two parameters. - * \param task a memory location for storing a #m_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 agent 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. + * \param task + * \param alias + * \return */ -MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel) +MSG_error_t MSG_task_receive(m_task_t * task, const char *alias) { - return MSG_task_get_with_timeout(task, channel, -1); + return MSG_task_receive_with_timeout(task, alias, -1); } /** \ingroup msg_gos_functions - * \brief Listen on a channel and wait for receiving a task with a timeout. + * \brief Description forthcoming (FIXME) * - * It takes three parameters. - * \param task a memory location for storing a #m_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 agent 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 - 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. + * \param task + * \param alias + * \param timeout + * \return */ -MSG_error_t -MSG_task_get_with_timeout(m_task_t * task, m_channel_t channel, - double max_duration) -{ - return MSG_task_get_ext(task, channel, max_duration, NULL); -} - -/** \defgroup msg_gos_functions MSG Operating System Functions - * \brief This section describes the functions that can be used - * by an agent for handling some task. - */ - -MSG_error_t -MSG_task_get_ext(m_task_t * task, m_channel_t channel, double timeout, - m_host_t host) -{ - xbt_assert((channel >= 0) - && (channel < msg_global->max_channel), "Invalid channel %d", - channel); - - return - MSG_mailbox_get_task_ext(MSG_mailbox_get_by_channel - (MSG_host_self(), channel), task, host, - timeout); -} - -MSG_error_t -MSG_task_receive_from_host(m_task_t * task, const char *alias, - m_host_t host) -{ - return MSG_task_receive_ext(task, alias, -1, host); -} - -MSG_error_t MSG_task_receive(m_task_t * task, const char *alias) -{ - return MSG_task_receive_with_timeout(task, alias, -1); -} - MSG_error_t MSG_task_receive_with_timeout(m_task_t * task, const char *alias, double timeout) @@ -348,6 +295,15 @@ 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) + * + * \param task + * \param alias + * \param timeout + * \param host + * \return + */ MSG_error_t MSG_task_receive_ext(m_task_t * task, const char *alias, double timeout, m_host_t host) @@ -382,7 +338,7 @@ 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 taking the match_data provided by sender (here), and the one of the receiver (if any) and returning whether they match * \param match_data user provided data passed to match_fun * \return the msg_comm_t communication created */ @@ -407,6 +363,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al "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++; /* Send it by calling SIMIX network layer */ @@ -415,7 +372,7 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al comm->task_received = NULL; comm->status = MSG_OK; comm->s_comm = - SIMIX_req_comm_isend(mailbox, t_simdata->message_size, + 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? */ @@ -436,8 +393,8 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al * \param task a #m_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 (if NULL, MSG_task_destroy() will - * be used by default) + * 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) { @@ -447,10 +404,6 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup) CHECK_HOST(); - if (cleanup == NULL) { - cleanup = (void_f_pvoid_t) MSG_task_destroy; - } - /* FIXME: these functions are not traceable */ /* Prepare the task to send */ @@ -462,11 +415,12 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup) "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++; /* Send it by calling SIMIX network layer */ - smx_action_t comm = SIMIX_req_comm_isend(mailbox, t_simdata->message_size, - t_simdata->rate, task, sizeof(void *), NULL,cleanup, NULL, 1); + 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; } @@ -486,7 +440,7 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name) CHECK_HOST(); - /* FIXME: these functions are not tracable */ + /* FIXME: these functions are not traceable */ /* Sanity check */ xbt_assert(task, "Null pointer for the task storage"); @@ -500,7 +454,7 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name) comm->task_sent = NULL; comm->task_received = task; comm->status = MSG_OK; - comm->s_comm = SIMIX_req_comm_irecv(rdv, task, NULL, NULL, NULL); + comm->s_comm = simcall_comm_irecv(rdv, task, NULL, NULL, NULL); return comm; } @@ -518,7 +472,7 @@ int MSG_comm_test(msg_comm_t comm) xbt_ex_t e; int finished = 0; TRY { - finished = SIMIX_req_comm_test(comm->s_comm); + finished = simcall_comm_test(comm->s_comm); if (finished && comm->task_received != NULL) { /* I am the receiver */ @@ -574,7 +528,7 @@ int MSG_comm_testany(xbt_dynar_t comms) MSG_error_t status = MSG_OK; TRY { - finished_index = SIMIX_req_comm_testany(s_comms); + finished_index = simcall_comm_testany(s_comms); } CATCH(e) { switch (e.category) { @@ -621,12 +575,6 @@ int MSG_comm_testany(xbt_dynar_t comms) */ void MSG_comm_destroy(msg_comm_t comm) { - if (comm->task_received != NULL - && *comm->task_received != NULL - && MSG_comm_get_status(comm) == MSG_OK) { - (*comm->task_received)->simdata->isused = 0; - } - xbt_free(comm); } @@ -642,7 +590,7 @@ MSG_error_t MSG_comm_wait(msg_comm_t comm, double timeout) { xbt_ex_t e; TRY { - SIMIX_req_comm_wait(comm->s_comm, timeout); + simcall_comm_wait(comm->s_comm, timeout); if (comm->task_received != NULL) { /* I am the receiver */ @@ -707,7 +655,7 @@ int MSG_comm_waitany(xbt_dynar_t comms) MSG_error_t status = MSG_OK; TRY { - finished_index = SIMIX_req_comm_waitany(s_comms); + finished_index = simcall_comm_waitany(s_comms); } CATCH(e) { switch (e.category) { @@ -740,6 +688,11 @@ int MSG_comm_waitany(xbt_dynar_t comms) /* the communication is finished */ comm->status = status; + if (comm->task_received != NULL) { + /* I am the receiver */ + (*comm->task_received)->simdata->isused = 0; + } + return finished_index; } @@ -755,6 +708,12 @@ MSG_error_t MSG_comm_get_status(msg_comm_t comm) { return comm->status; } +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param comm + * \return + */ m_task_t MSG_comm_get_task(msg_comm_t comm) { xbt_assert(comm, "Invalid parameter"); @@ -762,6 +721,128 @@ m_task_t MSG_comm_get_task(msg_comm_t comm) return comm->task_received ? *comm->task_received : comm->task_sent; } +/** + * \brief This function is called by SIMIX to copy the data of a comm. + * \param comm the comm + * \param buff the data copied + * \param buff_size size of the buffer + */ +void MSG_comm_copy_data_from_SIMIX(smx_action_t comm, void* buff, size_t buff_size) { + + // copy the task + SIMIX_comm_copy_pointer_callback(comm, buff, buff_size); + + // notify the user callback if any + if (msg_global->task_copy_callback) { + m_task_t task = buff; + msg_global->task_copy_callback(task, + simcall_comm_get_src_proc(comm), simcall_comm_get_dst_proc(comm)); + } +} + +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param task + * \param alias + * \return + */ +MSG_error_t MSG_task_send(m_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); +} + +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param task + * \param alias + * \param maxrate + * \return + */ +MSG_error_t +MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate) +{ + task->simdata->rate = maxrate; + return MSG_task_send(task, alias); +} + +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param task + * \param alias + * \param timeout + * \return + */ +MSG_error_t +MSG_task_send_with_timeout(m_task_t task, const char *alias, + double timeout) +{ + return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias), + task, timeout); +} + +/** \ingroup msg_gos_functions + * \brief Description forthcoming (FIXME) + * + * \param alias + * \return + */ +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) + * + * \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) + * + * \param alias + * \return + */ +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; + + return MSG_process_get_PID(task->simdata->sender); +} + +#ifdef MSG_USE_DEPRECATED +/** \ingroup msg_gos_functions + * + * \brief Return the last value returned by a MSG function (except + * MSG_get_errno...). + */ +MSG_error_t MSG_get_errno(void) +{ + return PROCESS_GET_ERRNO(); +} + /** \ingroup msg_gos_functions * \brief Put a task on a channel of an host and waits for the end of the * transmission. @@ -789,6 +870,7 @@ m_task_t MSG_comm_get_task(msg_comm_t comm) */ MSG_error_t MSG_task_put(m_task_t task, m_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); } @@ -802,6 +884,7 @@ MSG_error_t MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, double maxrate) { + XBT_WARN("DEPRECATED! Now use MSG_task_send_bounded"); task->simdata->rate = maxrate; return MSG_task_put(task, dest, channel); } @@ -838,6 +921,7 @@ MSG_error_t MSG_task_put_with_timeout(m_task_t task, m_host_t dest, m_channel_t channel, double timeout) { + XBT_WARN("DEPRECATED! Now use MSG_task_send_with_timeout"); xbt_assert((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel); @@ -848,34 +932,33 @@ MSG_task_put_with_timeout(m_task_t task, m_host_t dest, (dest, channel), task, timeout); } -MSG_error_t MSG_task_send(m_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); -} - - -MSG_error_t -MSG_task_send_bounded(m_task_t task, const char *alias, double maxrate) +/** \ingroup msg_gos_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 + 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 + */ +int MSG_task_probe_from(m_channel_t channel) { - task->simdata->rate = maxrate; - return MSG_task_send(task, alias); -} + XBT_WARN("DEPRECATED! Now use MSG_task_listen_from"); + m_task_t task; + CHECK_HOST(); -MSG_error_t -MSG_task_send_with_timeout(m_task_t task, const char *alias, - double timeout) -{ - return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias), - task, timeout); -} + xbt_assert((channel >= 0) + && (channel < msg_global->max_channel), "Invalid channel %d", + channel); -int MSG_task_listen(const char *alias) -{ - CHECK_HOST(); + if (NULL == + (task = + MSG_mailbox_get_head(MSG_mailbox_get_by_channel + (MSG_host_self(), channel)))) + return -1; - return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias)); + return MSG_process_get_PID(task->simdata->sender); } /** \ingroup msg_gos_functions @@ -889,6 +972,7 @@ int MSG_task_listen(const char *alias) */ int MSG_task_Iprobe(m_channel_t channel) { + XBT_WARN("DEPRECATED!"); xbt_assert((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel); @@ -915,6 +999,7 @@ int MSG_task_Iprobe(m_channel_t channel) */ int MSG_task_probe_from_host(int channel, m_host_t host) { + XBT_WARN("DEPRECATED! Now use MSG_task_listen_from_host"); xbt_assert((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel); @@ -928,64 +1013,84 @@ int MSG_task_probe_from_host(int channel, m_host_t host) } -int MSG_task_listen_from_host(const char *alias, m_host_t host) +/** \ingroup msg_gos_functions + * \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 + 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 + 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. + */ +MSG_error_t +MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host) { - CHECK_HOST(); - - return - MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias - (alias), host); + XBT_WARN("DEPRECATED! Now use MSG_task_receive_from_host"); + return MSG_task_get_ext(task, channel, -1, host); } /** \ingroup msg_gos_functions - * \brief Test whether there is a pending communication on a channel, and who sent it. + * \brief Listen on a channel and wait for receiving a task. * - * It takes one parameter. + * It takes two parameters. + * \param task a memory location for storing a #m_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 agent 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 + * \return a #MSG_error_t indicating whether the operation was successful (#MSG_OK), or why it failed otherwise. */ -int MSG_task_probe_from(m_channel_t channel) +MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel) { - m_task_t task; + XBT_WARN("DEPRECATED! Now use MSG_task_receive"); + return MSG_task_get_with_timeout(task, channel, -1); +} - CHECK_HOST(); +/** \ingroup msg_gos_functions + * \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 + 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 + 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 + 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. + */ +MSG_error_t +MSG_task_get_with_timeout(m_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) +{ + XBT_WARN("DEPRECATED! Now use MSG_task_receive_ext"); xbt_assert((channel >= 0) && (channel < msg_global->max_channel), "Invalid channel %d", channel); - if (NULL == - (task = - MSG_mailbox_get_head(MSG_mailbox_get_by_channel - (MSG_host_self(), channel)))) - return -1; - - return MSG_process_get_PID(task->simdata->sender); -} - -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; - - return MSG_process_get_PID(task->simdata->sender); + return + MSG_mailbox_get_task_ext(MSG_mailbox_get_by_channel + (MSG_host_self(), channel), task, host, + timeout); } -#ifdef MSG_USE_DEPRECATED -/** \ingroup msg_gos_functions - * - * \brief Return the last value returned by a MSG function (except - * MSG_get_errno...). - */ -MSG_error_t MSG_get_errno(void) -{ - return PROCESS_GET_ERRNO(); -} #endif