X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6f254a9bcba572207bc1487e0c828edc5f79d52e..094c97e3586d1703f0d01e539b2570b535ccbe2b:/src/msg/task.c diff --git a/src/msg/task.c b/src/msg/task.c index 01e15ef1e4..88c743da21 100644 --- a/src/msg/task.c +++ b/src/msg/task.c @@ -1,17 +1,36 @@ -/* $Id$ */ - -/* Copyright (c) 2002,2003,2004 Arnaud Legrand. All rights reserved. */ +/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. 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"private.h" -#include"xbt/sysdep.h" -#include "xbt/error.h" -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(task, msg, - "Logging specific to MSG module (task)"); +#include "msg/private.h" +#include "xbt/sysdep.h" +#include "xbt/log.h" + +/** \defgroup m_task_management Managing functions of Tasks + * \brief This section describes the task structure of MSG + * (#m_task_t) and the functions for managing it. + */ +/** @addtogroup m_task_management + * \htmlonly \endhtmlonly + * + * Since most scheduling algorithms rely on a concept of task + * that can be either computed locally or + * transferred on another processor, it seems to be the + * right level of abstraction for our purposes. A task + * may then be defined by a computing amount, a + * message size and some private data. + */ + +#ifdef HAVE_RUBY /* FIXME: KILLME */ +XBT_LOG_EXTERNAL_CATEGORY(ruby); +#endif + -static char sprint_buffer[64]; + +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, + "Logging specific to MSG (task)"); /********************************* Task **************************************/ /** \ingroup m_task_management @@ -21,10 +40,10 @@ static char sprint_buffer[64]; corresponding object. * \param name a name for the object. It is for user-level information and can be NULL. - * \param compute_duration a value of the processing amount (in Mflop) + * \param compute_duration a value of the processing amount (in flop) needed to process this new task. If 0, then it cannot be executed with MSG_task_execute(). This value has to be >=0. - * \param message_size a value of the amount of data (in Mb) needed to + * \param message_size a value of the amount of data (in bytes) needed to transfer this new task. If 0, then it cannot be transfered with MSG_task_get() and MSG_task_put(). This value has to be >=0. * \param data a pointer to any data may want to attach to the new @@ -33,21 +52,34 @@ static char sprint_buffer[64]; * \see m_task_t * \return The new corresponding object. */ -m_task_t MSG_task_create(const char *name, long double compute_duration, - long double message_size, void *data) +m_task_t MSG_task_create(const char *name, double compute_duration, + double message_size, void *data) { - sim_data_task_t sim_data = xbt_new0(s_sim_data_task_t,1); - m_task_t task = xbt_new0(s_m_task_t,1); - + m_task_t task = xbt_new(s_m_task_t, 1); + simdata_task_t simdata = xbt_new(s_simdata_task_t, 1); + task->simdata = simdata; /* Task structure */ task->name = xbt_strdup(name); - task->simdata = sim_data; task->data = data; /* Simulator Data */ - sim_data->sleeping = xbt_dynar_new(sizeof(m_process_t),NULL); - sim_data->computation_amount = compute_duration; - sim_data->message_size = message_size; + simdata->host_nb = 0; + simdata->computation_amount = compute_duration; + simdata->message_size = message_size; + simdata->rate = -1.0; + simdata->priority = 1.0; + simdata->refcount = 1; + simdata->sender = NULL; + simdata->receiver = NULL; + simdata->compute = NULL; + simdata->comm = NULL; + + simdata->host_list = NULL; + simdata->comp_amount = NULL; + simdata->comm_amount = NULL; +#ifdef HAVE_TRACING + TRACE_msg_task_create(task); +#endif return task; } @@ -55,7 +87,7 @@ m_task_t MSG_task_create(const char *name, long double compute_duration, /** \ingroup m_task_management * \brief Return the user data of a #m_task_t. * - * This functions checks whether \a task is a valid pointer or not and return + * This function checks whether \a task is a valid pointer or not and return the user data associated to \a task if it is possible. */ void *MSG_task_get_data(m_task_t task) @@ -65,6 +97,63 @@ void *MSG_task_get_data(m_task_t task) return (task->data); } +/** \ingroup m_task_management + * \brief Sets the user data of a #m_task_t. + * + * This function allows to associate a new pointer to + the user data associated of \a task. + */ +void MSG_task_set_data(m_task_t task, void *data) +{ + xbt_assert0((task != NULL), "Invalid parameter"); + + task->data = data; +} + +/** \ingroup m_task_management + * \brief Return the sender of a #m_task_t. + * + * This functions returns the #m_process_t which sent this task + */ +m_process_t MSG_task_get_sender(m_task_t task) +{ + xbt_assert0(task, "Invalid parameters"); + return ((simdata_task_t) task->simdata)->sender; +} + +/** \ingroup m_task_management + * \brief Return the source of a #m_task_t. + * + * This functions returns the #m_host_t from which this task was sent + */ +m_host_t MSG_task_get_source(m_task_t task) +{ + xbt_assert0(task, "Invalid parameters"); + return ((simdata_task_t) task->simdata)->source; +} + +/** \ingroup m_task_management + * \brief Return the name of a #m_task_t. + * + * This functions returns the name of a #m_task_t as specified on creation + */ +const char *MSG_task_get_name(m_task_t task) +{ + xbt_assert0(task, "Invalid parameters"); + return task->name; +} + +/** \ingroup m_task_management + * \brief Return the name of a #m_task_t. + * + * This functions allows to associate a name to a task + */ +void MSG_task_set_name(m_task_t task, const char *name) +{ + xbt_assert0(task, "Invalid parameters"); + task->name = xbt_strdup(name); +} + /** \ingroup m_task_management * \brief Destroy a #m_task_t. * @@ -73,89 +162,154 @@ void *MSG_task_get_data(m_task_t task) */ MSG_error_t MSG_task_destroy(m_task_t task) { - sim_data_task_t sim_data = NULL; - surf_action_t action = NULL; - int i; - + smx_action_t action = NULL; xbt_assert0((task != NULL), "Invalid parameter"); - xbt_assert0((xbt_dynar_length(task->simdata->sleeping)==0), - "Task still used. Cannot destroy it now!"); - if(task->name) xbt_free(task->name); + /* why? if somebody is using, then you can't free! ok... but will return MSG_OK? when this task will be destroyed? isn't the user code wrong? */ + task->simdata->refcount--; + if (task->simdata->refcount > 0) + return MSG_OK; +#ifdef HAVE_TRACING + TRACE_msg_task_destroy(task); +#endif - xbt_dynar_free(&(task->simdata->sleeping)); + if (task->name) + free(task->name); action = task->simdata->compute; - if(action) action->resource_type->common_public->action_free(action); - action = task->simdata->comm; - if(action) action->resource_type->common_public->action_free(action); + if (action) + SIMIX_req_host_execution_destroy(action); + /* parallel tasks only */ + if (task->simdata->host_list) + xbt_free(task->simdata->host_list); + /* free main structures */ xbt_free(task->simdata); xbt_free(task); return MSG_OK; } -/* static MSG_error_t __MSG_task_check(m_task_t task) */ -/* { */ -/* sim_data_task_t sim_data = NULL; */ -/* int warning = 0; */ -/* if (task == NULL) { /\* Fatal *\/ */ -/* WARNING("Task uninitialized"); */ -/* return MSG_FATAL; */ -/* } */ -/* sim_data = task->simdata; */ +/** \ingroup m_task_management + * \brief Cancel a #m_task_t. + * \param task the taskt to cancel. If it was executed or transfered, it + stops the process that were working on it. + */ +MSG_error_t MSG_task_cancel(m_task_t task) +{ + xbt_assert0((task != NULL), "Invalid parameter"); -/* if (sim_data == NULL) { /\* Fatal *\/ */ -/* WARNING("Simulator Data uninitialized"); */ -/* return MSG_FATAL; */ -/* } */ + if (task->simdata->compute) { + SIMIX_req_host_execution_cancel(task->simdata->compute); + return MSG_OK; + } + if (task->simdata->comm) { + SIMIX_req_comm_cancel(task->simdata->comm); + return MSG_OK; + } + THROW_IMPOSSIBLE; +} -/* if (sim_data->compute == NULL) { /\* Fatal if execute ... *\/ */ -/* WARNING("No duration set for this task"); */ -/* warning++; */ -/* } */ +/** \ingroup m_task_management + * \brief Returns the computation amount needed to process a task #m_task_t. + * Once a task has been processed, this amount is thus set to 0... + */ +double MSG_task_get_compute_duration(m_task_t task) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); -/* if (sim_data->message_size == 0) { /\* Fatal if transfered ... *\/ */ -/* WARNING("No message_size set for this task"); */ -/* warning++; */ -/* } */ + return task->simdata->computation_amount; +} -/* /\* if (task->data == NULL) { *\/ */ -/* /\* WARNING("User Data uninitialized"); *\/ */ -/* /\* warning++; *\/ */ -/* /\* } *\/ */ -/* if (warning) */ -/* return MSG_WARNING; */ -/* return MSG_OK; */ -/* } */ +/** \ingroup m_task_management + * \brief set the computation amount needed to process a task #m_task_t. + */ + +void MSG_task_set_compute_duration(m_task_t task, + double computation_amount) +{ + xbt_assert0(task, "Invalid parameter"); + task->simdata->computation_amount = computation_amount; + +} -/* static m_task_t __MSG_task_copy(m_task_t src) */ -/* { */ -/* m_task_t copy = NULL; */ -/* sim_data_task_t sim_data = NULL; */ +/** \ingroup m_task_management + * \brief Returns the remaining computation amount of a task #m_task_t. + * + */ +double MSG_task_get_remaining_computation(m_task_t task) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); -/* __MSG_task_check(src); */ + if (task->simdata->compute) { + return SIMIX_req_host_execution_get_remains(task->simdata->compute); + } else { + return task->simdata->computation_amount; + } +} -/* sim_data = src->simdata; */ -/* copy = MSG_task_create(src->name, SG_getTaskCost(sim_data->compute), */ -/* sim_data->message_size, MSG_task_get_data(src)); */ +/** \ingroup m_task_management + * \brief Returns the total amount received by a task #m_task_t. + * If the communication does not exist it will return 0. + * So, if the communication has FINISHED or FAILED it returns + * zero. + */ +double MSG_task_get_remaining_communication(m_task_t task) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); + DEBUG1("calling SIMIX_req_communication_get_remains(%p)", + task->simdata->comm); + return SIMIX_req_comm_get_remains(task->simdata->comm); +} -/* return (copy); */ -/* } */ +#ifdef HAVE_LATENCY_BOUND_TRACKING +/** \ingroup m_task_management + * \brief Return 1 if communication task is limited by latency, 0 otherwise + * + */ +int MSG_task_is_latency_bounded(m_task_t task) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); + DEBUG1("calling SIMIX_req_communication_is_latency_bounded(%p)", + task->simdata->comm); + return SIMIX_req_comm_is_latency_bounded(task->simdata->comm); +} +#endif -MSG_error_t __MSG_task_wait_event(m_process_t process, m_task_t task) +/** \ingroup m_task_management + * \brief Returns the size of the data attached to a task #m_task_t. + * + */ +double MSG_task_get_data_size(m_task_t task) { - xbt_assert0(((task != NULL) - && (task->simdata != NULL)), "Invalid parameters"); + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); - xbt_dynar_push(task->simdata->sleeping, process); - process->simdata->waiting_task = task; - xbt_context_yield(process->simdata->context); - process->simdata->waiting_task = NULL; + return task->simdata->message_size; +} - return MSG_OK; + + +/** \ingroup m_task_management + * \brief Changes the priority of a computation task. This priority doesn't affect + * the transfer rate. A priority of 2 will make a task receive two times more + * cpu power than the other ones. + * + */ +void MSG_task_set_priority(m_task_t task, double priority) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); + + task->simdata->priority = 1 / priority; + if (task->simdata->compute) + SIMIX_req_host_execution_set_priority(task->simdata->compute, + task->simdata->priority); }