X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d9cad55dcc546b3936c278258e7f463ac70066df..d947ff7466b473eeec602007934f8336a9b17f3c:/src/msg/msg_task.c diff --git a/src/msg/msg_task.c b/src/msg/msg_task.c index 1462a8279c..013c4f12e3 100644 --- a/src/msg/msg_task.c +++ b/src/msg/msg_task.c @@ -24,9 +24,9 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, /********************************* Task **************************************/ /** \ingroup m_task_management - * \brief Creates a new #m_task_t. + * \brief Creates a new #msg_task_t. * - * A constructor for #m_task_t taking four arguments and returning the + * A constructor for #msg_task_t taking four arguments and returning the corresponding object. * \param name a name for the object. It is for user-level information and can be NULL. @@ -39,13 +39,13 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_task, msg, * \param data a pointer to any data may want to attach to the new object. It is for user-level information and can be NULL. It can be retrieved with the function \ref MSG_task_get_data. - * \see m_task_t + * \see msg_task_t * \return The new corresponding object. */ -m_task_t MSG_task_create(const char *name, double compute_duration, +msg_task_t MSG_task_create(const char *name, double compute_duration, double message_size, void *data) { - m_task_t task = xbt_new(s_m_task_t, 1); + msg_task_t task = xbt_new(s_msg_task_t, 1); simdata_task_t simdata = xbt_new(s_simdata_task_t, 1); task->simdata = simdata; @@ -77,14 +77,14 @@ m_task_t MSG_task_create(const char *name, double compute_duration, } /** \ingroup m_task_management - * \brief Creates a new #m_task_t (a parallel one....). + * \brief Creates a new #msg_task_t (a parallel one....). * - * A constructor for #m_task_t taking six arguments and returning the + * A constructor for #msg_task_t taking six arguments and returning the corresponding object. * \param name a name for the object. It is for user-level information and can be NULL. * \param host_nb the number of hosts implied in the parallel task. - * \param host_list an array of \p host_nb m_host_t. + * \param host_list an array of \p host_nb msg_host_t. * \param computation_amount an array of \p host_nb doubles. computation_amount[i] is the total number of operations that have to be performed on host_list[i]. @@ -92,16 +92,16 @@ m_task_t MSG_task_create(const char *name, double compute_duration, * \param data a pointer to any data may want to attach to the new object. It is for user-level information and can be NULL. It can be retrieved with the function \ref MSG_task_get_data. - * \see m_task_t + * \see msg_task_t * \return The new corresponding object. */ -m_task_t +msg_task_t MSG_parallel_task_create(const char *name, int host_nb, - const m_host_t * host_list, + const msg_host_t * host_list, double *computation_amount, double *communication_amount, void *data) { - m_task_t task = MSG_task_create(name, 0, 0, data); + msg_task_t task = MSG_task_create(name, 0, 0, data); simdata_task_t simdata = task->simdata; int i; @@ -119,9 +119,9 @@ MSG_parallel_task_create(const char *name, int host_nb, /*************** Begin GPU ***************/ /** \ingroup m_task_management - * \brief Creates a new #m_gpu_task_t. + * \brief Creates a new #msg_gpu_task_t. - * A constructor for #m_gpu_task_t taking four arguments and returning + * A constructor for #msg_gpu_task_t taking four arguments and returning a pointer to the new created GPU task. * \param name a name for the object. It is for user-level information @@ -136,13 +136,13 @@ MSG_parallel_task_create(const char *name, int host_nb, * \param collect_latency time in seconds to transfer result from the GPU back to the CPU (host) when done - * \see m_gpu_task_t + * \see msg_gpu_task_t * \return The new corresponding object. */ -m_gpu_task_t MSG_gpu_task_create(const char *name, double compute_duration, +msg_gpu_task_t MSG_gpu_task_create(const char *name, double compute_duration, double dispatch_latency, double collect_latency) { - m_gpu_task_t task = xbt_new(s_m_gpu_task_t, 1); + msg_gpu_task_t task = xbt_new(s_msg_gpu_task_t, 1); simdata_gpu_task_t simdata = xbt_new(s_simdata_gpu_task_t, 1); task->simdata = simdata; /* Task structure */ @@ -163,12 +163,12 @@ m_gpu_task_t MSG_gpu_task_create(const char *name, double compute_duration, /*************** End GPU ***************/ /** \ingroup m_task_management - * \brief Return the user data of a #m_task_t. + * \brief Return the user data of a #msg_task_t. * * 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) +void *MSG_task_get_data(msg_task_t task) { xbt_assert((task != NULL), "Invalid parameter"); @@ -176,12 +176,12 @@ void *MSG_task_get_data(m_task_t task) } /** \ingroup m_task_management - * \brief Sets the user data of a #m_task_t. + * \brief Sets the user data of a #msg_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) +void MSG_task_set_data(msg_task_t task, void *data) { xbt_assert((task != NULL), "Invalid parameter"); @@ -193,7 +193,7 @@ void MSG_task_set_data(m_task_t task, void *data) * \param callback a callback function */ void MSG_task_set_copy_callback(void (*callback) - (m_task_t task, msg_process_t sender, msg_process_t receiver)) { + (msg_task_t task, msg_process_t sender, msg_process_t receiver)) { msg_global->task_copy_callback = callback; @@ -206,53 +206,53 @@ void MSG_task_set_copy_callback(void (*callback) } /** \ingroup m_task_management - * \brief Return the sender of a #m_task_t. + * \brief Return the sender of a #msg_task_t. * * This functions returns the #msg_process_t which sent this task */ -msg_process_t MSG_task_get_sender(m_task_t task) +msg_process_t MSG_task_get_sender(msg_task_t task) { xbt_assert(task, "Invalid parameters"); return ((simdata_task_t) task->simdata)->sender; } /** \ingroup m_task_management - * \brief Return the source of a #m_task_t. + * \brief Return the source of a #msg_task_t. * - * This functions returns the #m_host_t from which this task was sent + * This functions returns the #msg_host_t from which this task was sent */ -m_host_t MSG_task_get_source(m_task_t task) +msg_host_t MSG_task_get_source(msg_task_t task) { xbt_assert(task, "Invalid parameters"); return ((simdata_task_t) task->simdata)->source; } /** \ingroup m_task_management - * \brief Return the name of a #m_task_t. + * \brief Return the name of a #msg_task_t. * - * This functions returns the name of a #m_task_t as specified on creation + * This functions returns the name of a #msg_task_t as specified on creation */ -const char *MSG_task_get_name(m_task_t task) +const char *MSG_task_get_name(msg_task_t task) { xbt_assert(task, "Invalid parameters"); return task->name; } /** \ingroup m_task_management - * \brief Sets the name of a #m_task_t. + * \brief Sets the name of a #msg_task_t. * * This functions allows to associate a name to a task */ -void MSG_task_set_name(m_task_t task, const char *name) +void MSG_task_set_name(msg_task_t task, const char *name) { xbt_assert(task, "Invalid parameters"); task->name = xbt_strdup(name); } /** \ingroup m_task_management - * \brief Destroy a #m_task_t. + * \brief Destroy a #msg_task_t. * - * Destructor for #m_task_t. Note that you should free user data, if any, \b + * Destructor for #msg_task_t. Note that you should free user data, if any, \b * before calling this function. * * Only the process that owns the task can destroy it. @@ -261,7 +261,7 @@ void MSG_task_set_name(m_task_t task, const char *name) * supposed to destroy it. The sender should not use it anymore. * If the task failed to be sent, the sender remains the owner of the task. */ -MSG_error_t MSG_task_destroy(m_task_t task) +msg_error_t MSG_task_destroy(msg_task_t task) { smx_action_t action = NULL; xbt_assert((task != NULL), "Invalid parameter"); @@ -292,13 +292,13 @@ MSG_error_t MSG_task_destroy(m_task_t task) /** \ingroup m_task_usage - * \brief Cancel a #m_task_t. + * \brief Cancel a #msg_task_t. * \param task the task 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) +msg_error_t MSG_task_cancel(msg_task_t task) { - xbt_assert((task != NULL), "Invalid parameter"); + xbt_assert((task != NULL), "Cannot cancel a NULL task"); if (task->simdata->compute) { simcall_host_execution_cancel(task->simdata->compute); @@ -311,10 +311,12 @@ MSG_error_t MSG_task_cancel(m_task_t task) } /** \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... + * \brief Returns the computation amount needed to process a task #msg_task_t. + * + * Once a task has been processed, this amount is set to 0. If you want, you + * can reset this value with #MSG_task_set_compute_duration before restarting the task. */ -double MSG_task_get_compute_duration(m_task_t task) +double MSG_task_get_compute_duration(msg_task_t task) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter"); @@ -324,10 +326,15 @@ double MSG_task_get_compute_duration(m_task_t task) /** \ingroup m_task_management - * \brief set the computation amount needed to process a task #m_task_t. + * \brief set the computation amount needed to process a task #msg_task_t. + * + * \warning If the computation is ongoing (already started and not finished), + * it is not modified by this call. And the termination of the ongoing task with + * set the computation_amount to zero, overriding any value set during the + * execution. */ -void MSG_task_set_compute_duration(m_task_t task, +void MSG_task_set_compute_duration(msg_task_t task, double computation_amount) { xbt_assert(task, "Invalid parameter"); @@ -336,10 +343,13 @@ void MSG_task_set_compute_duration(m_task_t task, } /** \ingroup m_task_management - * \brief Returns the remaining computation amount of a task #m_task_t. + * \brief Returns the remaining computation amount of a task #msg_task_t. * + * If the task is ongoing, this call retrieves the remaining amount of work. + * If it is not ongoing, it returns the total amount of work that will be + * executed when the task starts. */ -double MSG_task_get_remaining_computation(m_task_t task) +double MSG_task_get_remaining_computation(msg_task_t task) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter"); @@ -352,12 +362,12 @@ double MSG_task_get_remaining_computation(m_task_t task) } /** \ingroup m_task_management - * \brief Returns the total amount received by a task #m_task_t. + * \brief Returns the total amount received by a task #msg_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) +double MSG_task_get_remaining_communication(msg_task_t task) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter"); @@ -371,7 +381,7 @@ double MSG_task_get_remaining_communication(m_task_t task) * \brief Return 1 if communication task is limited by latency, 0 otherwise * */ -int MSG_task_is_latency_bounded(m_task_t task) +int MSG_task_is_latency_bounded(msg_task_t task) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter"); @@ -382,10 +392,10 @@ int MSG_task_is_latency_bounded(m_task_t task) #endif /** \ingroup m_task_management - * \brief Returns the size of the data attached to a task #m_task_t. + * \brief Returns the size of the data attached to a task #msg_task_t. * */ -double MSG_task_get_data_size(m_task_t task) +double MSG_task_get_data_size(msg_task_t task) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter"); @@ -401,7 +411,7 @@ double MSG_task_get_data_size(m_task_t task) * cpu power than the other ones. * */ -void MSG_task_set_priority(m_task_t task, double priority) +void MSG_task_set_priority(msg_task_t task, double priority) { xbt_assert((task != NULL) && (task->simdata != NULL), "Invalid parameter");