X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/012e8850b96760b97bee7f40ce87b4093866153e..c6eefaa5a3198ebff98651ac72501367e4195ded:/src/msg/task.c diff --git a/src/msg/task.c b/src/msg/task.c index af973f05ec..3479e4703b 100644 --- a/src/msg/task.c +++ b/src/msg/task.c @@ -1,17 +1,27 @@ -/* $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 (task)"); +#include "msg/private.h" +#include "xbt/sysdep.h" +#include "xbt/log.h" -static char sprint_buffer[64]; +/** \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. + */ /********************************* Task **************************************/ /** \ingroup m_task_management @@ -21,10 +31,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,23 +43,36 @@ 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) { - simdata_task_t simdata = xbt_new0(s_simdata_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 = simdata; task->data = data; /* Simulator Data */ - simdata->sleeping = xbt_dynar_new(sizeof(m_process_t),NULL); + simdata->host_nb = 0; simdata->computation_amount = compute_duration; simdata->message_size = message_size; - simdata->using = 1; + simdata->rate = -1.0; + simdata->priority = 1.0; + simdata->refcount = 1; simdata->sender = NULL; + simdata->receiver = NULL; + simdata->cond = SIMIX_cond_init(); + simdata->mutex = SIMIX_mutex_init(); + 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; } @@ -57,7 +80,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) @@ -67,6 +90,19 @@ 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. * @@ -74,10 +110,36 @@ void *MSG_task_get_data(m_task_t task) */ m_process_t MSG_task_get_sender(m_task_t task) { - xbt_assert0(task, "Invalid parameters"); - return ((simdata_task_t) task->simdata)->sender; + 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; } +void MSG_task_refcount_dec(m_task_t task) +{ + task->simdata->refcount--; +} /** \ingroup m_task_management * \brief Destroy a #m_task_t. @@ -87,100 +149,130 @@ m_process_t MSG_task_get_sender(m_task_t task) */ MSG_error_t MSG_task_destroy(m_task_t task) { - simdata_task_t simdata = NULL; - surf_action_t action = NULL; - int i; - + smx_action_t action = NULL; xbt_assert0((task != NULL), "Invalid parameter"); - task->simdata->using--; - if(task->simdata->using>0) return MSG_OK; + /* 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_assert0((xbt_dynar_length(task->simdata->sleeping)==0), - "Task still used. There is a problem. Cannot destroy it now!"); + if (task->name) + free(task->name); - if(task->name) xbt_free(task->name); - - xbt_dynar_free(&(task->simdata->sleeping)); + SIMIX_cond_destroy(task->simdata->cond); + SIMIX_mutex_destroy(task->simdata->mutex); 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_action_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) */ -/* { */ -/* simdata_task_t simdata = NULL; */ -/* int warning = 0; */ - -/* if (task == NULL) { /\* Fatal *\/ */ -/* WARNING("Task uninitialized"); */ -/* return MSG_FATAL; */ -/* } */ -/* simdata = task->simdata; */ - -/* if (simdata == NULL) { /\* Fatal *\/ */ -/* WARNING("Simulator Data uninitialized"); */ -/* return MSG_FATAL; */ -/* } */ - -/* if (simdata->compute == NULL) { /\* Fatal if execute ... *\/ */ -/* WARNING("No duration set for this task"); */ -/* warning++; */ -/* } */ - -/* if (simdata->message_size == 0) { /\* Fatal if transfered ... *\/ */ -/* WARNING("No message_size set for this task"); */ -/* warning++; */ -/* } */ - -/* /\* if (task->data == NULL) { *\/ */ -/* /\* WARNING("User Data uninitialized"); *\/ */ -/* /\* warning++; *\/ */ -/* /\* } *\/ */ - -/* if (warning) */ -/* return MSG_WARNING; */ -/* return MSG_OK; */ -/* } */ - -/* static m_task_t __MSG_task_copy(m_task_t src) */ -/* { */ -/* m_task_t copy = NULL; */ -/* simdata_task_t simdata = NULL; */ - -/* __MSG_task_check(src); */ - -/* simdata = src->simdata; */ -/* copy = MSG_task_create(src->name, SG_getTaskCost(simdata->compute), */ -/* simdata->message_size, MSG_task_get_data(src)); */ - -/* return (copy); */ -/* } */ - -MSG_error_t __MSG_task_wait_event(m_process_t process, m_task_t task) + +/** \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 (task->simdata->compute) { + SIMIX_action_cancel(task->simdata->compute); + return MSG_OK; + } + if (task->simdata->comm) { + SIMIX_communication_cancel(task->simdata->comm); + return MSG_OK; + } + THROW_IMPOSSIBLE; +} + +/** \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"); + + return task->simdata->computation_amount; +} + +/** \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) { - int _cursor; - m_process_t proc = NULL; - - xbt_assert0(((task != NULL) - && (task->simdata != NULL)), "Invalid parameters"); - - xbt_dynar_push(task->simdata->sleeping, &process); - process->simdata->waiting_task = task; - xbt_context_yield(); - process->simdata->waiting_task = NULL; - xbt_dynar_foreach(task->simdata->sleeping,_cursor,proc) { - if(proc==process) - xbt_dynar_remove_at(task->simdata->sleeping,_cursor,&proc); + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); + + if (task->simdata->compute) { + return SIMIX_action_get_remains(task->simdata->compute); + } else { + return task->simdata->computation_amount; } +} - return MSG_OK; + + +/** \ingroup m_task_management + * \brief Returns the total amount received by a task #m_task_t. + * + */ +double MSG_task_get_remaining_communication(m_task_t task) +{ + xbt_assert0((task != NULL) + && (task->simdata != NULL), "Invalid parameter"); + + return SIMIX_communication_get_remains(task->simdata->comm); +} + +/** \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 parameter"); + + return task->simdata->message_size; +} + + + +/** \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_action_set_priority(task->simdata->compute, + task->simdata->priority); } + +