X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/edde8f7fbc1b74a81551bf9eb7bac1935b999296..b8ba0bc2f48c6b9b96dfedd8fd383b941d5fdd0b:/src/msg/msg_gos.c diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c index c41dc38d4b..c97b980396 100644 --- a/src/msg/msg_gos.c +++ b/src/msg/msg_gos.c @@ -1,5 +1,4 @@ -/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2004-2011. 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. */ @@ -10,7 +9,6 @@ #include "xbt/log.h" #include "xbt/sysdep.h" - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg, "Logging specific to MSG (gos)"); @@ -57,15 +55,15 @@ 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; @@ -80,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; @@ -177,14 +175,14 @@ 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); @@ -197,7 +195,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; @@ -228,7 +226,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; @@ -261,12 +259,12 @@ MSG_error_t MSG_process_sleep(double nb_sec) 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 #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING - if \a *task is not equal to \c NULL, and #MSG_OK 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) { + XBT_WARN("DEPRECATED! Now use MSG_task_receive_from_host"); return MSG_task_get_ext(task, channel, -1, host); } @@ -281,11 +279,11 @@ MSG_task_get_from_host(m_task_t * task, m_channel_t channel, m_host_t host) * \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 #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING - * if \a *task is not equal to \c NULL, and #MSG_OK 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) { + XBT_WARN("DEPRECATED! Now use MSG_task_receive"); return MSG_task_get_with_timeout(task, channel, -1); } @@ -304,13 +302,13 @@ MSG_error_t MSG_task_get(m_task_t * task, m_channel_t channel) 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 #MSG_FATAL if \a task is equal to \c NULL, #MSG_WARNING - if \a *task is not equal to \c NULL, and #MSG_OK 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, double max_duration) { + XBT_WARN("DEPRECATED! Now use MSG_task_receive_with_timeout"); return MSG_task_get_ext(task, channel, max_duration, NULL); } @@ -323,6 +321,7 @@ 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); @@ -419,8 +418,8 @@ 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, - t_simdata->rate, task, sizeof(void *), match_fun, match_data, 0); + 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? */ return comm; @@ -440,8 +439,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) { @@ -451,10 +450,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 */ @@ -469,8 +464,9 @@ void MSG_task_dsend(m_task_t task, const char *alias, void_f_pvoid_t cleanup) msg_global->sent_msg++; /* Send it by calling SIMIX network layer */ - SIMIX_req_comm_isend(mailbox, t_simdata->message_size, - t_simdata->rate, task, sizeof(void *), NULL, cleanup, 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; } /** \ingroup msg_gos_functions @@ -496,14 +492,14 @@ msg_comm_t MSG_task_irecv(m_task_t *task, const char *name) if (*task) XBT_CRITICAL - ("MSG_task_get() was asked to write in a non empty task struct."); + ("MSG_task_irecv() was asked to write in a non empty task struct."); /* Try to receive it by calling SIMIX network layer */ msg_comm_t comm = xbt_new0(s_msg_comm_t, 1); 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; } @@ -521,7 +517,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 */ @@ -577,7 +573,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) { @@ -624,12 +620,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); } @@ -645,7 +635,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 */ @@ -710,7 +700,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) { @@ -743,6 +733,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; } @@ -765,6 +760,25 @@ 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 Put a task on a channel of an host and waits for the end of the * transmission. @@ -785,14 +799,14 @@ m_task_t MSG_comm_get_task(msg_comm_t comm) * \param channel the channel on which the agent 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_FATAL if \a task is not properly initialized and - * #MSG_OK otherwise. Returns #MSG_HOST_FAILURE if the host on which - * this function was called was shut down. Returns + * \return #MSG_HOST_FAILURE if the host on which + * this function was called was shut down, * #MSG_TRANSFER_FAILURE if the transfer could not be properly done - * (network failure, dest failure) + * (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) { + XBT_WARN("DEPRECATED! Now use MSG_task_send"); return MSG_task_put_with_timeout(task, dest, channel, -1.0); } @@ -806,6 +820,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); } @@ -833,16 +848,16 @@ MSG_task_put_bounded(m_task_t task, m_host_t dest, m_channel_t channel, * \param timeout 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 - * \return #MSG_FATAL if \a task is not properly initialized and -#MSG_OK otherwise. Returns #MSG_HOST_FAILURE if the host on which -this function was called was shut down. Returns + * \return #MSG_HOST_FAILURE if the host on which +this function was called was shut down, #MSG_TRANSFER_FAILURE if the transfer could not be properly done -(network failure, dest failure, timeout...) +(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, 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); @@ -894,6 +909,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); @@ -920,6 +936,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); @@ -953,6 +970,7 @@ int MSG_task_listen_from_host(const char *alias, m_host_t host) */ int MSG_task_probe_from(m_channel_t channel) { + XBT_WARN("DEPRECATED! Now use MSG_task_listen_from"); m_task_t task; CHECK_HOST();