X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5265dc224e69f1d3094f04f86b97bb0d1308d80e..6929a75e852513610503d5c01bf928e1331e0d43:/src/msg/msg_gos.c diff --git a/src/msg/msg_gos.c b/src/msg/msg_gos.c index aa91522a9a..d02ffa72cf 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,20 +9,9 @@ #include "xbt/log.h" #include "xbt/sysdep.h" - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_gos, msg, "Logging specific to MSG (gos)"); -/** \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 Executes a task and waits for its termination. * @@ -62,18 +50,20 @@ MSG_error_t MSG_task_execute(m_task_t 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 = - SIMIX_req_host_execute(task->name, SIMIX_host_self(), + 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 = SIMIX_process_self_get_data(); 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; @@ -88,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; @@ -171,7 +161,7 @@ MSG_error_t MSG_parallel_task_execute(m_task_t task) CHECK_HOST(); simdata = task->simdata; - p_simdata = SIMIX_process_self_get_data(); + p_simdata = SIMIX_process_self_get_data(SIMIX_process_self()); xbt_assert((!simdata->compute) && (task->simdata->isused == 0), @@ -185,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); @@ -205,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; @@ -236,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; @@ -269,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); } @@ -289,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); } @@ -312,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); } @@ -331,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); @@ -385,6 +376,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 * \brief Sends a task on a mailbox, with support for matching requests * @@ -412,12 +404,13 @@ XBT_INLINE msg_comm_t MSG_task_isend_with_matching(m_task_t task, const char *al /* Prepare the task to send */ t_simdata = task->simdata; t_simdata->sender = process; - t_simdata->source = MSG_host_self(); + t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host; xbt_assert(t_simdata->isused == 0, "This task is still being used somewhere else. You cannot send it now. Go fix your code!"); t_simdata->isused = 1; + t_simdata->comm = NULL; msg_global->sent_msg++; /* Send it by calling SIMIX network layer */ @@ -426,8 +419,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; @@ -447,8 +440,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) { @@ -458,26 +451,24 @@ 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 */ t_simdata = task->simdata; t_simdata->sender = process; - t_simdata->source = MSG_host_self(); + t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host; xbt_assert(t_simdata->isused == 0, "This task is still being used somewhere else. You cannot send it now. Go fix your code!"); t_simdata->isused = 1; + t_simdata->comm = NULL; msg_global->sent_msg++; /* 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 @@ -503,14 +494,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; } @@ -528,7 +519,12 @@ 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 */ + (*comm->task_received)->simdata->isused = 0; + } } CATCH(e) { switch (e.category) { @@ -579,7 +575,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) { @@ -610,6 +606,11 @@ int MSG_comm_testany(xbt_dynar_t comms) comm = xbt_dynar_get_as(comms, finished_index, msg_comm_t); /* the communication is finished */ comm->status = status; + + if (status == MSG_OK && comm->task_received != NULL) { + /* I am the receiver */ + (*comm->task_received)->simdata->isused = 0; + } } return finished_index; @@ -621,12 +622,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 +637,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 +702,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 +735,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; } @@ -762,6 +762,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. @@ -782,14 +801,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); } @@ -803,6 +822,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); } @@ -830,16 +850,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); @@ -891,6 +911,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); @@ -917,6 +938,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); @@ -950,6 +972,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(); @@ -979,3 +1002,15 @@ int MSG_task_listen_from(const char *alias) 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(); +} +#endif