-/* Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011. The SimGrid Team.
+/* Copyright (c) 2006-2015. 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 "simdag/simdag.h"
+#include "simgrid/simdag.h"
#include "xbt/sysdep.h"
#include "xbt/dynar.h"
#include "instr/instr_private.h"
/* scheduling parameters */
task->workstation_nb = 0;
task->workstation_list = NULL;
- task->computation_amount = NULL;
- task->communication_amount = NULL;
+ task->flops_amount = NULL;
+ task->bytes_amount = NULL;
task->rate = -1;
}
sd_global->task_number++;
-#ifdef HAVE_TRACING
- task->category = NULL;
-#endif
+ TRACE_sd_task_create(task);
return task;
}
int ws_count)
{
SD_task_t task = SD_task_create(name, data, amount);
- task->communication_amount = xbt_new0(double, ws_count * ws_count);
- task->computation_amount = xbt_new0(double, ws_count);
+ task->bytes_amount = xbt_new0(double, ws_count * ws_count);
+ task->flops_amount = xbt_new0(double, ws_count);
task->workstation_nb = ws_count;
task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
return task;
double amount)
{
SD_task_t res = SD_task_create_sized(name, data, amount, 2);
- res->communication_amount[2] = amount;
+ res->bytes_amount[2] = amount;
res->kind = SD_TASK_COMM_E2E;
+
+ TRACE_category("COMM_E2E");
+ TRACE_sd_set_task_category(res, "COMM_E2E");
+
return res;
}
*
* \param name the name of the task (can be \c NULL)
* \param data the user data you want to associate with the task (can be \c NULL)
- * \param amount amount of compute work to be done by the task
+ * \param flops_amount amount of compute work to be done by the task
* \return the new SD_TASK_COMP_SEQ typed task
*/
SD_task_t SD_task_create_comp_seq(const char *name, void *data,
- double amount)
+ double flops_amount)
{
- SD_task_t res = SD_task_create_sized(name, data, amount, 1);
- res->computation_amount[0] = amount;
+ SD_task_t res = SD_task_create_sized(name, data, flops_amount, 1);
+ res->flops_amount[0] = flops_amount;
res->kind = SD_TASK_COMP_SEQ;
+
+ TRACE_category("COMP_SEQ");
+ TRACE_sd_set_task_category(res, "COMP_SEQ");
+
return res;
}
* mandatory power.
*
* A parallel computation can be scheduled on any number of host.
- * The underlying speedup model is Amdahl's law.
- * To be auto-scheduled, \see SD_task_distribute_comp_amdhal has to be called
+ * The underlying speedup model is Amdahl's law.
+ * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called
* first.
* \param name the name of the task (can be \c NULL)
* \param data the user data you want to associate with the task (can be \c NULL)
- * \param amount amount of compute work to be done by the task
+ * \param flops_amount amount of compute work to be done by the task
* \param alpha purely serial fraction of the work to be done (in [0.;1.[)
* \return the new task
*/
SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data,
- double amount, double alpha)
+ double flops_amount, double alpha)
{
xbt_assert(alpha < 1. && alpha >= 0.,
"Invalid parameter: alpha must be in [0.;1.[");
- SD_task_t res = SD_task_create(name, data, amount);
+ SD_task_t res = SD_task_create(name, data, flops_amount);
res->alpha = alpha;
res->kind = SD_TASK_COMP_PAR_AMDAHL;
+
+ TRACE_category("COMP_PAR_AMDAHL");
+ TRACE_sd_set_task_category(res, "COMP_PAR_AMDAHL");
+
return res;
}
SD_task_t res = SD_task_create(name, data, amount);
res->workstation_list=NULL;
res->kind = SD_TASK_COMM_PAR_MXN_1D_BLOCK;
+
+ TRACE_category("COMM_PAR_MXN_1D_BLOCK");
+ TRACE_sd_set_task_category(res, "COMM_PAR_MXN_1D_BLOCK");
+
return res;
}
xbt_free(task->name);
if (task->surf_action != NULL)
- surf_workstation_model->action_unref(task->surf_action);
+ surf_action_unref(task->surf_action);
xbt_free(task->workstation_list);
- xbt_free(task->communication_amount);
- xbt_free(task->computation_amount);
+ xbt_free(task->bytes_amount);
+ xbt_free(task->flops_amount);
-#ifdef HAVE_TRACING
- if (task->category) xbt_free(task->category);
-#endif
+ TRACE_sd_task_destroy(task);
xbt_mallocator_release(sd_global->task_mallocator,task);
sd_global->task_number--;
* \brief Sets the rate of a task
*
* This will change the network bandwidth a task can use. This rate
- * depends on both the nominal bandwidth on the route onto which the task is
- * scheduled (\see SD_task_get_current_bandwidth) and the amount of data to
- * transfer.
+ * cannot be dynamically changed. Once the task has started, this call
+ * is ineffective. This rate depends on both the nominal bandwidth on
+ * the route onto which the task is scheduled (\see
+ * SD_task_get_current_bandwidth) and the amount of data to transfer.
*
* To divide the nominal bandwidth by 2, the rate then has to be :
* rate = bandwidth/(2*amount)
{
xbt_assert(task->kind == SD_TASK_COMM_E2E,
"The rate can be modified for end-to-end communications only.");
-
- task->rate = rate;
+ if(task->start_time<0) {
+ task->rate = rate;
+ } else {
+ XBT_WARN("Task %p has started. Changing rate is ineffective.", task);
+ }
}
/**
break;
case SD_RUNNING:
task->state_set = sd_global->running_task_set;
- task->start_time =
- surf_workstation_model->action_get_start_time(task->surf_action);
+ task->start_time = surf_action_get_start_time(task->surf_action);
break;
case SD_DONE:
task->state_set = sd_global->done_task_set;
- task->finish_time =
- surf_workstation_model->action_get_finish_time(task->surf_action);
+ task->finish_time = surf_action_get_finish_time(task->surf_action);
task->remains = 0;
#ifdef HAVE_JEDULE
jedule_log_sd_event(task);
}
/**
- * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAH task
+ * \brief Sets the total amount of work of a task
+ * For sequential typed tasks (COMP_SEQ and COMM_E2E), it also sets the
+ * appropriate values in the flops_amount and bytes_amount arrays
+ * respectively. Nothing more than modifying task->amount is done for paralle
+ * typed tasks (COMP_PAR_AMDAHL and COMM_PAR_MXN_1D_BLOCK) as the distribution
+ * of the amount of work is done at scheduling time.
+ *
+ * \param task a task
+ * \param amount the new amount of work to execute
+ */
+void SD_task_set_amount(SD_task_t task, double amount)
+{
+ task->amount = amount;
+ if (task->kind == SD_TASK_COMP_SEQ)
+ task->flops_amount[0] = amount;
+ if (task->kind == SD_TASK_COMM_E2E)
+ task->bytes_amount[2] = amount;
+}
+
+/**
+ * \brief Returns the alpha parameter of a SD_TASK_COMP_PAR_AMDAHL task
*
* \param task a parallel task assuming Amdahl's law as speedup model
* \return the alpha parameter (serial part of a task in percent) for this task
double SD_task_get_remaining_amount(SD_task_t task)
{
if (task->surf_action)
- return surf_workstation_model->get_remains(task->surf_action);
+ return surf_action_get_remains(task->surf_action);
else
return task->remains;
}
XBT_INFO(" - (unknown kind %d)", task->kind);
}
}
+
+ if (task->category)
+ XBT_INFO(" - tracing category: %s", task->category);
+
XBT_INFO(" - amount: %.0f", SD_task_get_amount(task));
if (task->kind == SD_TASK_COMP_PAR_AMDAHL)
XBT_INFO(" - alpha: %.2f", task->alpha);
SD_task_t dst)
{
xbt_dynar_t dynar;
- int length;
+ unsigned long length;
int found = 0;
- int i;
+ unsigned long i;
SD_dependency_t dependency;
dynar = src->tasks_after;
for (i = 0; i < length && !found; i++) {
xbt_dynar_get_cpy(dynar, i, &dependency);
found = (dependency->dst == dst);
- XBT_DEBUG("Dependency %d: dependency->dst = %s", i,
+ XBT_DEBUG("Dependency %lu: dependency->dst = %s", i,
SD_task_get_name(dependency->dst));
}
{
xbt_dynar_t dynar;
- int length;
+ unsigned long length;
int found = 0;
- int i;
+ unsigned long i;
SD_dependency_t dependency;
/* remove the dependency from src->tasks_after */
{
xbt_dynar_t dynar;
- int length;
+ unsigned long length;
int found = 0;
- int i;
+ unsigned long i;
SD_dependency_t dependency;
dynar = src->tasks_after;
* \param task the task to evaluate
* \param workstation_nb number of workstations on which the task would be executed
* \param workstation_list the workstations on which the task would be executed
- * \param computation_amount computation amount for each workstation
- * \param communication_amount communication amount between each pair of workstations
+ * \param flops_amount computation amount for each workstation
+ * \param bytes_amount communication amount between each pair of workstations
* \see SD_schedule()
*/
double SD_task_get_execution_time(SD_task_t task,
int workstation_nb,
const SD_workstation_t *
workstation_list,
- const double *computation_amount,
- const double *communication_amount)
+ const double *flops_amount,
+ const double *bytes_amount)
{
double time, max_time = 0.0;
int i, j;
for (i = 0; i < workstation_nb; i++) {
time = 0.0;
- if (computation_amount != NULL)
+ if (flops_amount != NULL)
time =
SD_workstation_get_computation_time(workstation_list[i],
- computation_amount[i]);
+ flops_amount[i]);
- if (communication_amount != NULL)
+ if (bytes_amount != NULL)
for (j = 0; j < workstation_nb; j++) {
time +=
SD_route_get_communication_time(workstation_list[i],
workstation_list[j],
- communication_amount[i *
+ bytes_amount[i *
workstation_nb
+ j]);
}
* \param task the task you want to schedule
* \param workstation_count number of workstations on which the task will be executed
* \param workstation_list the workstations on which the task will be executed
- * \param computation_amount computation amount for each workstation
- * \param communication_amount communication amount between each pair of workstations
+ * \param flops_amount computation amount for each workstation
+ * \param bytes_amount communication amount between each pair of workstations
* \param rate task execution speed rate
* \see SD_task_unschedule()
*/
void SD_task_schedule(SD_task_t task, int workstation_count,
const SD_workstation_t * workstation_list,
- const double *computation_amount,
- const double *communication_amount, double rate)
+ const double *flops_amount,
+ const double *bytes_amount, double rate)
{
int communication_nb;
task->workstation_nb = 0;
task->workstation_nb = workstation_count;
task->rate = rate;
- if (computation_amount) {
- task->computation_amount = xbt_realloc(task->computation_amount,
+ if (flops_amount) {
+ task->flops_amount = xbt_realloc(task->flops_amount,
sizeof(double) * workstation_count);
- memcpy(task->computation_amount, computation_amount,
+ memcpy(task->flops_amount, flops_amount,
sizeof(double) * workstation_count);
} else {
- xbt_free(task->computation_amount);
- task->computation_amount = NULL;
+ xbt_free(task->flops_amount);
+ task->flops_amount = NULL;
}
communication_nb = workstation_count * workstation_count;
- if (communication_amount) {
- task->communication_amount = xbt_realloc(task->communication_amount,
+ if (bytes_amount) {
+ task->bytes_amount = xbt_realloc(task->bytes_amount,
sizeof(double) * communication_nb);
- memcpy(task->communication_amount, communication_amount,
+ memcpy(task->bytes_amount, bytes_amount,
sizeof(double) * communication_nb);
} else {
- xbt_free(task->communication_amount);
- task->communication_amount = NULL;
+ xbt_free(task->bytes_amount);
+ task->bytes_amount = NULL;
}
task->workstation_list =
&& ((task->kind == SD_TASK_COMP_PAR_AMDAHL) ||
(task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) { /* Don't free scheduling data for typed tasks */
__SD_task_destroy_scheduling_data(task);
+ xbt_free(task->workstation_list);
task->workstation_list=NULL;
task->workstation_nb = 0;
}
if (__SD_task_is_running(task)) /* the task should become SD_FAILED */
- surf_workstation_model->action_cancel(task->surf_action);
+ surf_action_cancel(task->surf_action);
else {
if (task->unsatisfied_dependencies == 0)
__SD_task_set_state(task, SD_SCHEDULABLE);
"Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
SD_task_get_name(task));
- xbt_free(task->computation_amount);
- xbt_free(task->communication_amount);
- task->computation_amount = task->communication_amount = NULL;
+ xbt_free(task->flops_amount);
+ xbt_free(task->bytes_amount);
+ task->flops_amount = task->bytes_amount = NULL;
}
/* Runs a task. This function is directly called by __SD_task_try_to_run if
{
int i;
- void **surf_workstations;
+ sg_host_t *hosts;
xbt_assert(__SD_task_is_runnable_or_in_fifo(task),
"Task '%s' is not runnable or in a fifo! Task state: %d",
SD_task_get_name(task));
XBT_DEBUG("Really running task '%s'", SD_task_get_name(task));
- int workstation_nb = task->workstation_nb;
+ int host_nb = task->workstation_nb;
/* set this task as current task for the workstations in sequential mode */
- for (i = 0; i < workstation_nb; i++) {
+ for (i = 0; i < host_nb; i++) {
if (SD_workstation_get_access_mode(task->workstation_list[i]) ==
SD_WORKSTATION_SEQUENTIAL_ACCESS) {
- SD_workstation_priv(task->workstation_list[i])->current_task = task;
+ sg_host_sd(task->workstation_list[i])->current_task = task;
xbt_assert(__SD_workstation_is_busy(task->workstation_list[i]),
"The workstation should be busy now");
}
/* start the task */
- /* we have to create a Surf workstation array instead of the SimDag
- * workstation array */
- surf_workstations = xbt_new(void *, workstation_nb);
+ /* Copy the elements of the task into the action */
+ hosts = xbt_new(sg_host_t, host_nb);
- for (i = 0; i < workstation_nb; i++)
- surf_workstations[i] = task->workstation_list[i];
+ for (i = 0; i < host_nb; i++)
+ hosts[i] = task->workstation_list[i];
- double *computation_amount = xbt_new0(double, workstation_nb);
- double *communication_amount = xbt_new0(double, workstation_nb * workstation_nb);
+ double *flops_amount = xbt_new0(double, host_nb);
+ double *bytes_amount = xbt_new0(double, host_nb * host_nb);
- if(task->computation_amount)
- memcpy(computation_amount, task->computation_amount, sizeof(double) *
- workstation_nb);
- if(task->communication_amount)
- memcpy(communication_amount, task->communication_amount,
- sizeof(double) * workstation_nb * workstation_nb);
+ if(task->flops_amount)
+ memcpy(flops_amount, task->flops_amount, sizeof(double) *
+ host_nb);
+ if(task->bytes_amount)
+ memcpy(bytes_amount, task->bytes_amount,
+ sizeof(double) * host_nb * host_nb);
- task->surf_action =
- surf_workstation_model->extension.
- workstation.execute_parallel_task(workstation_nb,
- surf_workstations,
- computation_amount,
- communication_amount,
- task->rate);
+ task->surf_action = surf_host_model_execute_parallel_task((surf_host_model_t)surf_host_model,
+ host_nb,
+ hosts,
+ flops_amount,
+ bytes_amount,
+ task->rate);
- surf_workstation_model->action_data_set(task->surf_action, task);
+ surf_action_set_data(task->surf_action, task);
XBT_DEBUG("surf_action = %p", task->surf_action);
-#ifdef HAVE_TRACING
if (task->category)
TRACE_surf_action(task->surf_action, task->category);
-#endif
__SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
__SD_task_set_state(task, SD_RUNNING);
if (!can_start) { /* if the task cannot start and is not in the FIFOs yet */
for (i = 0; i < task->workstation_nb; i++) {
workstation = task->workstation_list[i];
- if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
XBT_DEBUG("Pushing task '%s' in the FIFO of workstation '%s'",
SD_task_get_name(task),
SD_workstation_get_name(workstation));
- xbt_fifo_push(SD_workstation_priv(workstation)->task_fifo, task);
+ xbt_fifo_push(sg_host_sd(workstation)->task_fifo, task);
}
}
__SD_task_set_state(task, SD_IN_FIFO);
candidates = xbt_new(SD_task_t, 8);
__SD_task_set_state(task, SD_DONE);
- surf_workstation_model->action_unref(task->surf_action);
+ surf_action_unref(task->surf_action);
task->surf_action = NULL;
XBT_DEBUG("Looking for candidates");
for (i = 0; i < task->workstation_nb; i++) {
workstation = task->workstation_list[i];
XBT_DEBUG("Workstation '%s': access_mode = %d",
- SD_workstation_get_name(workstation), (int)SD_workstation_priv(workstation)->access_mode);
- if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
- xbt_assert(SD_workstation_priv(workstation)->task_fifo != NULL,
+ SD_workstation_get_name(workstation), (int)sg_host_sd(workstation)->access_mode);
+ if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ xbt_assert(sg_host_sd(workstation)->task_fifo != NULL,
"Workstation '%s' has sequential access but no FIFO!",
SD_workstation_get_name(workstation));
- xbt_assert(SD_workstation_priv(workstation)->current_task =
+ xbt_assert(sg_host_sd(workstation)->current_task =
task, "Workstation '%s': current task should be '%s'",
SD_workstation_get_name(workstation),
SD_task_get_name(task));
/* the task is over so we can release the workstation */
- SD_workstation_priv(workstation)->current_task = NULL;
+ sg_host_sd(workstation)->current_task = NULL;
XBT_DEBUG("Getting candidate in FIFO");
candidate =
xbt_fifo_get_item_content(xbt_fifo_get_first_item
- (SD_workstation_priv(workstation)->task_fifo));
+ (sg_host_sd(workstation)->task_fifo));
if (candidate != NULL) {
XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate));
/* I can start on this workstation if the workstation is shared
or if I am the first task in the FIFO */
- can_start = SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS
+ can_start = sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS
|| candidate ==
xbt_fifo_get_item_content(xbt_fifo_get_first_item
- (SD_workstation_priv(workstation)->task_fifo));
+ (sg_host_sd(workstation)->task_fifo));
}
XBT_DEBUG("Candidate '%s' can start: %d", SD_task_get_name(candidate),
workstation = candidate->workstation_list[j];
/* update the FIFO */
- if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
- candidate = xbt_fifo_shift(SD_workstation_priv(workstation)->task_fifo); /* the return value is stored just for debugging */
+ if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ candidate = xbt_fifo_shift(sg_host_sd(workstation)->task_fifo); /* the return value is stored just for debugging */
XBT_DEBUG("Head of the FIFO: '%s'",
(candidate !=
NULL) ? SD_task_get_name(candidate) : "NULL");
double SD_task_get_start_time(SD_task_t task)
{
if (task->surf_action)
- return surf_workstation_model->
- action_get_start_time(task->surf_action);
+ return surf_action_get_start_time(task->surf_action);
else
return task->start_time;
}
double SD_task_get_finish_time(SD_task_t task)
{
if (task->surf_action) /* should never happen as actions are destroyed right after their completion */
- return surf_workstation_model->
- action_get_finish_time(task->surf_action);
+ return surf_action_get_finish_time(task->surf_action);
else
return task->finish_time;
}
/** @brief Blah
*
*/
-void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count)
+void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count)
{
int i;
xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL,
"Task %s is not a SD_TASK_COMP_PAR_AMDAHL typed task."
"Cannot use this function.",
SD_task_get_name(task));
- task->computation_amount = xbt_new0(double, ws_count);
- task->communication_amount = xbt_new0(double, ws_count * ws_count);
- if (task->workstation_list)
- xbt_free(task->workstation_list);
+ task->flops_amount = xbt_new0(double, ws_count);
+ task->bytes_amount = xbt_new0(double, ws_count * ws_count);
+ xbt_free(task->workstation_list);
task->workstation_nb = ws_count;
task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
for(i=0;i<ws_count;i++){
- task->computation_amount[i] =
+ task->flops_amount[i] =
(task->alpha + (1 - task->alpha)/ws_count) * task->amount;
}
}
SD_task_get_name(task));
switch (task->kind) {
case SD_TASK_COMP_PAR_AMDAHL:
- SD_task_distribute_comp_amdhal(task, count);
+ SD_task_distribute_comp_amdahl(task, count);
case SD_TASK_COMM_E2E:
case SD_TASK_COMP_SEQ:
xbt_assert(task->workstation_nb == count,
count,task->workstation_nb);
for (i = 0; i < count; i++)
task->workstation_list[i] = list[i];
- if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->computation_amount){
- /*This task has failed and is rescheduled. Reset the computation amount*/
- task->computation_amount = xbt_new0(double, 1);
- task->computation_amount[0] = task->remains;
+ if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->flops_amount){
+ /*This task has failed and is rescheduled. Reset the flops_amount*/
+ task->flops_amount = xbt_new0(double, 1);
+ task->flops_amount[0] = task->remains;
}
SD_task_do_schedule(task);
break;
SD_task_get_name(task),
SD_workstation_get_name(task->workstation_list[0]),
SD_workstation_get_name(task->workstation_list[1]),
- task->communication_amount[2]);
+ task->bytes_amount[2]);
}
XBT_VERB("Schedule computation task %s on %s. It costs %.f flops",
SD_task_get_name(task),
SD_workstation_get_name(task->workstation_list[0]),
- task->computation_amount[0]);
+ task->flops_amount[0]);
xbt_dynar_foreach(task->tasks_before, cpt, dep) {
SD_task_t before = dep->src;
SD_task_get_name(before),
SD_workstation_get_name(before->workstation_list[0]),
SD_workstation_get_name(before->workstation_list[1]),
- before->communication_amount[2]);
+ before->bytes_amount[2]);
}
}
}
SD_task_get_name(after),
SD_workstation_get_name(after->workstation_list[0]),
SD_workstation_get_name(after->workstation_list[1]),
- after->communication_amount[2]);
+ after->bytes_amount[2]);
}
}
* located (and start them if runnable) */
if (task->kind == SD_TASK_COMP_PAR_AMDAHL) {
XBT_VERB("Schedule computation task %s on %d workstations. %.f flops"
- " will be distributed following Amdahl'Law",
+ " will be distributed following Amdahl's Law",
SD_task_get_name(task), task->workstation_nb,
- task->computation_amount[0]);
+ task->flops_amount[0]);
xbt_dynar_foreach(task->tasks_before, cpt, dep) {
SD_task_t before = dep->src;
if (before->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
task->workstation_list[i];
before->workstation_nb += count;
- if (before->computation_amount)
- xbt_free(before->computation_amount);
- if (before->communication_amount)
- xbt_free(before->communication_amount);
-
- before->computation_amount = xbt_new0(double,
+ xbt_free(before->flops_amount);
+ xbt_free(before->bytes_amount);
+ before->flops_amount = xbt_new0(double,
before->workstation_nb);
- before->communication_amount = xbt_new0(double,
+ before->bytes_amount = xbt_new0(double,
before->workstation_nb*
before->workstation_nb);
SD_workstation_get_name(before->workstation_list[src_nb+j]),
src_start, src_end, dst_start, dst_end);
if ((src_end <= dst_start) || (dst_end <= src_start)) {
- before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+ before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
} else {
- before->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+ before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] =
MIN(src_end, dst_end) - MAX(src_start, dst_start);
}
XBT_VERB("==> %.2f",
- before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+ before->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]);
}
}
after->workstation_nb += count;
- if (after->computation_amount)
- xbt_free(after->computation_amount);
- if (after->communication_amount)
- xbt_free(after->communication_amount);
+ xbt_free(after->flops_amount);
+ xbt_free(after->bytes_amount);
- after->computation_amount = xbt_new0(double, after->workstation_nb);
- after->communication_amount = xbt_new0(double,
+ after->flops_amount = xbt_new0(double, after->workstation_nb);
+ after->bytes_amount = xbt_new0(double,
after->workstation_nb*
after->workstation_nb);
XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)",
i, j, src_start, src_end, dst_start, dst_end);
if ((src_end <= dst_start) || (dst_end <= src_start)) {
- after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+ after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
} else {
- after->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+ after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j] =
MIN(src_end, dst_end)- MAX(src_start, dst_start);
}
XBT_VERB("==> %.2f",
- after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+ after->bytes_amount[i*(src_nb+dst_nb)+src_nb+j]);
}
}
SD_task_schedulev(task, count, list);
free(list);
}
-
-/**
- * \brief Sets the tracing category of a task.
- *
- * This function should be called after the creation of a
- * SimDAG task, to define the category of that task. The first
- * parameter must contain a task that was created with the
- * function #SD_task_create. The second parameter must contain
- * a category that was previously declared with the function
- * #TRACE_category.
- *
- * \param task The task to be considered
- * \param category the name of the category to be associated to the task
- *
- * \see SD_task_get_category, TRACE_category, TRACE_category_with_color
- */
-void SD_task_set_category (SD_task_t task, const char *category)
-{
-#ifdef HAVE_TRACING
- if (!TRACE_is_enabled()) return;
- if (task == NULL) return;
- if (category == NULL){
- if (task->category) xbt_free (task->category);
- task->category = NULL;
- }else{
- task->category = xbt_strdup (category);
- }
-#endif
-}
-
-/**
- * \brief Gets the current tracing category of a task.
- *
- * \param task The task to be considered
- *
- * \see SD_task_set_category
- *
- * \return Returns the name of the tracing category of the given task, NULL otherwise
- */
-const char *SD_task_get_category (SD_task_t task)
-{
-#ifdef HAVE_TRACING
- return task->category;
-#else
- return NULL;
-#endif
-}
