X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/ba9a4cfeba4eb00e84cd17603fc9654e81445655..a15797ea55151ddfdbae48147e74159efe01b411:/src/msg/msg_gos.cpp diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp index 426f25aa5f..becc04b412 100644 --- a/src/msg/msg_gos.cpp +++ b/src/msg/msg_gos.cpp @@ -1,9 +1,9 @@ -/* Copyright (c) 2004-2015. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2004-2016. 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. */ +#include "src/simix/smx_private.h" /* MSG_task_listen looks inside the rdv directly. Not clean. */ #include "msg_private.h" #include "mc/mc.h" #include "xbt/log.h" @@ -44,8 +44,7 @@ msg_error_t MSG_parallel_task_execute(msg_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 = (simdata_process_t) SIMIX_process_self_get_data(self); + simdata_process_t p_simdata = (simdata_process_t) SIMIX_process_self_get_data(); e_smx_state_t comp_state; msg_error_t status = MSG_OK; @@ -68,9 +67,10 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) simdata->isused = (void*)1; if (simdata->host_nb > 0) { - simdata->compute = simcall_execution_parallel_start(task->name, simdata->host_nb,simdata->host_list, + simdata->compute = static_cast( + simcall_execution_parallel_start(task->name, simdata->host_nb,simdata->host_list, simdata->flops_parallel_amount, simdata->bytes_parallel_amount, - 1.0, -1.0); + 1.0, -1.0)); XBT_DEBUG("Parallel execution action created: %p", simdata->compute); } else { unsigned long affinity_mask = @@ -79,8 +79,9 @@ msg_error_t MSG_parallel_task_execute(msg_task_t task) XBT_DEBUG("execute %s@%s with affinity(0x%04lx)", MSG_task_get_name(task), MSG_host_get_name(p_simdata->m_host), affinity_mask); - simdata->compute = simcall_execution_start(task->name, simdata->flops_amount, simdata->priority, - simdata->bound, affinity_mask); + simdata->compute = static_cast( + simcall_execution_start(task->name, simdata->flops_amount, simdata->priority, + simdata->bound, affinity_mask)); } simcall_set_category(simdata->compute, task->category); p_simdata->waiting_action = simdata->compute; @@ -285,7 +286,7 @@ msg_error_t MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, d } /* Internal function used to factorize code between MSG_task_isend_with_matching() and MSG_task_dsend(). */ -static XBT_INLINE msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *alias, +static inline msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *alias, int (*match_fun)(void*,void*, smx_synchro_t), void *match_data, void_f_pvoid_t cleanup, int detached) { @@ -297,7 +298,7 @@ static XBT_INLINE msg_comm_t MSG_task_isend_internal(msg_task_t task, const char /* Prepare the task to send */ t_simdata = task->simdata; t_simdata->sender = process; - t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host; + t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data())->m_host; if (t_simdata->isused != 0) { if (msg_global->debug_multiple_use){ @@ -308,7 +309,7 @@ static XBT_INLINE msg_comm_t MSG_task_isend_internal(msg_task_t task, const char } else { xbt_assert(t_simdata->isused == 0, "This task is still being used somewhere else. You cannot send it now. Go fix your code!" - "(use --cfg=msg/debug_multiple_use:on to get the backtrace of the other process)"); + "(use --cfg=msg/debug-multiple-use:on to get the backtrace of the other process)"); } } @@ -322,7 +323,7 @@ static XBT_INLINE msg_comm_t MSG_task_isend_internal(msg_task_t task, const char /* Send it by calling SIMIX network layer */ smx_synchro_t act = simcall_comm_isend(SIMIX_process_self(), mailbox, t_simdata->bytes_amount, t_simdata->rate, task, sizeof(void *), match_fun, cleanup, NULL, match_data,detached); - t_simdata->comm = act; /* FIXME: is the field t_simdata->comm still useful? */ + t_simdata->comm = static_cast(act); /* FIXME: is the field t_simdata->comm still useful? */ msg_comm_t comm; if (detached) { @@ -462,7 +463,7 @@ msg_comm_t MSG_task_irecv(msg_task_t *task, const char *name) */ msg_comm_t MSG_task_irecv_bounded(msg_task_t *task, const char *name, double rate) { - smx_rdv_t rdv = MSG_mailbox_get_by_alias(name); + smx_mailbox_t rdv = MSG_mailbox_get_by_alias(name); /* FIXME: these functions are not traceable */ /* Sanity check */ @@ -703,9 +704,9 @@ int MSG_comm_waitany(xbt_dynar_t comms) /** * \ingroup msg_task_usage - * \brief Returns the error (if any) that occured during a finished communication. + * \brief Returns the error (if any) that occurred 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 occurred * during the communication */ msg_error_t MSG_comm_get_status(msg_comm_t comm) { @@ -732,14 +733,16 @@ msg_task_t MSG_comm_get_task(msg_comm_t comm) * \param buff the data copied * \param buff_size size of the buffer */ -void MSG_comm_copy_data_from_SIMIX(smx_synchro_t comm, void* buff, size_t buff_size) { - // copy the task +void MSG_comm_copy_data_from_SIMIX(smx_synchro_t synchro, void* buff, size_t buff_size) +{ + simgrid::simix::Comm *comm = static_cast(synchro); + SIMIX_comm_copy_pointer_callback(comm, buff, buff_size); // notify the user callback if any if (msg_global->task_copy_callback) { msg_task_t task = (msg_task_t) buff; - msg_global->task_copy_callback(task, simcall_comm_get_src_proc(comm), simcall_comm_get_dst_proc(comm)); + msg_global->task_copy_callback(task, comm->src_proc, comm->dst_proc); } } @@ -795,7 +798,79 @@ msg_error_t MSG_task_send_bounded(msg_task_t task, const char *alias, double max */ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout) { - return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias), task, timeout); + msg_error_t ret = MSG_OK; + simdata_task_t t_simdata = NULL; + msg_process_t process = MSG_process_self(); + simdata_process_t p_simdata = (simdata_process_t) SIMIX_process_self_get_data(); + msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias); + + int call_end = TRACE_msg_task_put_start(task); //must be after CHECK_HOST() + + /* Prepare the task to send */ + t_simdata = task->simdata; + t_simdata->sender = process; + t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data())->m_host; + + if (t_simdata->isused != 0) { + if (msg_global->debug_multiple_use){ + XBT_ERROR("This task is already used in there:"); + xbt_backtrace_display((xbt_ex_t*) t_simdata->isused); + XBT_ERROR("And you try to reuse it from here:"); + xbt_backtrace_display_current(); + } else { + xbt_assert(t_simdata->isused == 0, + "This task is still being used somewhere else. You cannot send it now. Go fix your code!" + " (use --cfg=msg/debug-multiple-use:on to get the backtrace of the other process)"); + } + } + + if (msg_global->debug_multiple_use) + MSG_BT(t_simdata->isused, "Using Backtrace"); + else + t_simdata->isused = (void*)1; + t_simdata->comm = NULL; + msg_global->sent_msg++; + + p_simdata->waiting_task = task; + + xbt_ex_t e; + /* Try to send it by calling SIMIX network layer */ + TRY { + smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simix call */ + comm = simcall_comm_isend(SIMIX_process_self(), mailbox,t_simdata->bytes_amount, + t_simdata->rate, task, sizeof(void *), NULL, NULL, NULL, task, 0); + if (TRACE_is_enabled()) + simcall_set_category(comm, task->category); + t_simdata->comm = static_cast(comm); + simcall_comm_wait(comm, timeout); + } + + CATCH(e) { + switch (e.category) { + case cancel_error: + ret = MSG_HOST_FAILURE; + break; + case network_error: + ret = MSG_TRANSFER_FAILURE; + break; + case timeout_error: + ret = MSG_TIMEOUT; + break; + default: + RETHROW; + } + xbt_ex_free(e); + + /* If the send failed, it is not used anymore */ + if (msg_global->debug_multiple_use && t_simdata->isused!=0) + xbt_ex_free(*(xbt_ex_t*)t_simdata->isused); + t_simdata->isused = 0; + } + + p_simdata->waiting_task = NULL; + if (call_end) + TRACE_msg_task_put_end(); + MSG_RETURN(ret); } /** \ingroup msg_task_usage @@ -814,7 +889,7 @@ msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char *alias, doubl msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate) { task->simdata->rate = maxrate; - return MSG_mailbox_put_with_timeout(MSG_mailbox_get_by_alias(alias), task, timeout); + return MSG_task_send_with_timeout(task, alias, timeout); } /** \ingroup msg_task_usage @@ -826,21 +901,8 @@ msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alia */ int MSG_task_listen(const char *alias) { - return !MSG_mailbox_is_empty(MSG_mailbox_get_by_alias(alias)); -} - -/** \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. - */ -int MSG_task_listen_from_host(const char *alias, msg_host_t host) -{ - return MSG_mailbox_get_count_host_waiting_tasks(MSG_mailbox_get_by_alias(alias), host); + smx_mailbox_t mbox = MSG_mailbox_get_by_alias(alias); + return !MSG_mailbox_is_empty(mbox) || (mbox->permanent_receiver && !mbox->done_comm_queue->empty()); } /** \ingroup msg_task_usage @@ -855,7 +917,7 @@ int MSG_task_listen_from(const char *alias) { msg_task_t task; - if (NULL == (task = MSG_mailbox_get_head(MSG_mailbox_get_by_alias(alias)))) + if (NULL == (task = MSG_mailbox_front(MSG_mailbox_get_by_alias(alias)))) return -1; return MSG_process_get_PID(task->simdata->sender); @@ -869,7 +931,7 @@ int MSG_task_listen_from(const char *alias) * parameter category must contain a category that was previously declared with the function #TRACE_category * (or with #TRACE_category_with_color). * - * See \ref tracing for details on how to trace the (categorized) resource utilization. + * See \ref outcomes_vizu 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