X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e1a94e1131e309dd8cf98bb4bf650f3b23d3c2d5..5faf49cdf3f8ad8751317b857a6d3134fe07eda3:/src/simdag/sd_task.c

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index 1520ead82b..c17bb71ca6 100644
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011. The SimGrid Team.
+/* Copyright (c) 2006 - 2013. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -91,7 +91,7 @@ SD_task_t SD_task_create(const char *name, void *data, double amount)
   sd_global->task_number++;
 
 #ifdef HAVE_TRACING
-  task->category = NULL;
+  TRACE_sd_task_create(task);
 #endif
 
   return task;
@@ -125,6 +125,12 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data,
   SD_task_t res = SD_task_create_sized(name, data, amount, 2);
   res->communication_amount[2] = amount;
   res->kind = SD_TASK_COMM_E2E;
+
+#ifdef HAVE_TRACING
+  TRACE_category("COMM_E2E");
+  TRACE_sd_set_task_category(res, "COMM_E2E");
+#endif
+
   return res;
 }
 
@@ -149,7 +155,13 @@ SD_task_t SD_task_create_comp_seq(const char *name, void *data,
   SD_task_t res = SD_task_create_sized(name, data, amount, 1);
   res->computation_amount[0] = amount;
   res->kind = SD_TASK_COMP_SEQ;
-  return res;
+
+#ifdef HAVE_TRACING
+  TRACE_category("COMP_SEQ");
+  TRACE_sd_set_task_category(res, "COMP_SEQ");
+#endif
+
+return res;
 }
 
 /** @brief create a parallel computation task that can then be auto-scheduled
@@ -178,6 +190,12 @@ SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data,
   SD_task_t res = SD_task_create(name, data, amount);
   res->alpha = alpha;
   res->kind = SD_TASK_COMP_PAR_AMDAHL;
+
+#ifdef HAVE_TRACING
+  TRACE_category("COMP_PAR_AMDAHL");
+  TRACE_sd_set_task_category(res, "COMP_PAR_AMDAHL");
+#endif
+
   return res;
 }
 
@@ -206,6 +224,12 @@ SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data,
   SD_task_t res = SD_task_create(name, data, amount);
   res->workstation_list=NULL;
   res->kind = SD_TASK_COMM_PAR_MXN_1D_BLOCK;
+
+#ifdef HAVE_TRACING
+  TRACE_category("COMM_PAR_MXN_1D_BLOCK");
+  TRACE_sd_set_task_category(res, "COMM_PAR_MXN_1D_BLOCK");
+#endif
+
   return res;
 }
 
@@ -233,14 +257,14 @@ void SD_task_destroy(SD_task_t task)
   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);
 
 #ifdef HAVE_TRACING
-  if (task->category) xbt_free(task->category);
+  TRACE_sd_task_destroy(task);
 #endif
 
   xbt_mallocator_release(sd_global->task_mallocator,task);
@@ -334,13 +358,11 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
     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);
@@ -475,7 +497,7 @@ double SD_task_get_alpha(SD_task_t 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;
 }
@@ -494,16 +516,16 @@ void SD_task_dump(SD_task_t task)
 
   XBT_INFO("Displaying task %s", SD_task_get_name(task));
   statename = bprintf("%s %s %s %s %s %s %s %s",
-                      (task->state & SD_NOT_SCHEDULED ? "not scheduled" :
+                      (task->state == SD_NOT_SCHEDULED ? "not scheduled" :
                        ""),
-                      (task->state & SD_SCHEDULABLE ? "schedulable" : ""),
-                      (task->state & SD_SCHEDULED ? "scheduled" : ""),
-                      (task->state & SD_RUNNABLE ? "runnable" :
+                      (task->state == SD_SCHEDULABLE ? "schedulable" : ""),
+                      (task->state == SD_SCHEDULED ? "scheduled" : ""),
+                      (task->state == SD_RUNNABLE ? "runnable" :
                        "not runnable"),
-                      (task->state & SD_IN_FIFO ? "in fifo" : ""),
-                      (task->state & SD_RUNNING ? "running" : ""),
-                      (task->state & SD_DONE ? "done" : ""),
-                      (task->state & SD_FAILED ? "failed" : ""));
+                      (task->state == SD_IN_FIFO ? "in fifo" : ""),
+                      (task->state == SD_RUNNING ? "running" : ""),
+                      (task->state == SD_DONE ? "done" : ""),
+                      (task->state == SD_FAILED ? "failed" : ""));
   XBT_INFO("  - state: %s", statename);
   free(statename);
 
@@ -525,6 +547,12 @@ void SD_task_dump(SD_task_t task)
       XBT_INFO("  - (unknown kind %d)", task->kind);
     }
   }
+
+#ifdef HAVE_TRACING
+  if (task->category)
+    XBT_INFO("  - tracing category: %s", task->category);
+#endif
+
   XBT_INFO("  - amount: %.0f", SD_task_get_amount(task));
   if (task->kind == SD_TASK_COMP_PAR_AMDAHL)
     XBT_INFO("  - alpha: %.2f", task->alpha);
@@ -591,9 +619,9 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
                             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;
@@ -622,7 +650,7 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
   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));
   }
 
@@ -716,9 +744,9 @@ void SD_task_dependency_remove(SD_task_t src, 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;
 
   /* remove the dependency from src->tasks_after */
@@ -787,9 +815,9 @@ void *SD_task_dependency_get_data(SD_task_t src, 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;
@@ -1011,12 +1039,13 @@ void SD_task_unschedule(SD_task_t task)
       && ((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);
@@ -1096,15 +1125,14 @@ void __SD_task_really_run(SD_task_t task)
     memcpy(communication_amount, task->communication_amount,
            sizeof(double) * workstation_nb * workstation_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_workstation_model_execute_parallel_task((surf_workstation_model_t)surf_workstation_model,
+		                                                     workstation_nb,
+		                                                     surf_workstations,
+		                                                     computation_amount,
+		                                                     communication_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);
 
@@ -1193,7 +1221,7 @@ void __SD_task_just_done(SD_task_t task)
   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");
@@ -1351,8 +1379,7 @@ static void __SD_task_remove_dependencies(SD_task_t task)
 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;
 }
@@ -1371,8 +1398,7 @@ double SD_task_get_start_time(SD_task_t task)
 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;
 }
@@ -1386,9 +1412,9 @@ void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count)
               "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);
+  xbt_free(task->workstation_list);
   task->workstation_nb = ws_count;
   task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
   
@@ -1538,7 +1564,8 @@ void SD_task_schedulev(SD_task_t task, int count,
                task->workstation_list[i];
 
           before->workstation_nb += count;
-
+          xbt_free(before->computation_amount);
+          xbt_free(before->communication_amount);
           before->computation_amount = xbt_new0(double,
                                                 before->workstation_nb);
           before->communication_amount = xbt_new0(double,
@@ -1603,6 +1630,9 @@ void SD_task_schedulev(SD_task_t task, int count,
 
           after->workstation_nb += count;
 
+          xbt_free(after->computation_amount);
+          xbt_free(after->communication_amount);
+
           after->computation_amount = xbt_new0(double, after->workstation_nb);
           after->communication_amount = xbt_new0(double,
                                                  after->workstation_nb*
@@ -1659,50 +1689,3 @@ void SD_task_schedulel(SD_task_t task, int count, ...)
   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
-}