end of simplification of dependencies

no more ugly counters \o/

diff --git a/examples/java/trace/pingpong/trace_pingpong.tesh b/examples/java/trace/pingpong/trace_pingpong.tesh
index a3b011a..17c954a 100644 (file)
--- a/examples/java/trace/pingpong/trace_pingpong.tesh
+++ b/examples/java/trace/pingpong/trace_pingpong.tesh
@@ -36,4 +36,4 @@ $ java -classpath ${classpath:=.} trace/pingpong/Main ${srcdir:=.}/../platforms/
 > [Tremblay:Receiver:(3) 2.957786] [jmsg/INFO]  --- bw 1.1627602630025032E8 ----
 > [Tremblay:Receiver:(3) 3.817809] [jmsg/INFO] goodbye!
 
 > [Tremblay:Receiver:(3) 2.957786] [jmsg/INFO]  --- bw 1.1627602630025032E8 ----
 > [Tremblay:Receiver:(3) 3.817809] [jmsg/INFO] goodbye!
 

-$ rm -rf simulation.trace
+!$ rm -rf simulation.trace

diff --git a/examples/simdag/scheduling/sd_scheduling.c b/examples/simdag/scheduling/sd_scheduling.c
index 7269bc6..e4531aa 100644 (file)
--- a/examples/simdag/scheduling/sd_scheduling.c
+++ b/examples/simdag/scheduling/sd_scheduling.c
@@ -92,24 +92,15 @@ static double finish_on_at(SD_task_t task, sg_host_t host)
     xbt_dynar_foreach(parents, i, parent) {
       /* normal case */
       if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {
     xbt_dynar_foreach(parents, i, parent) {
       /* normal case */
       if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {

-        xbt_dynar_t grand_parents = SD_task_get_parents(parent);
-        SD_task_t grand_parent;
-
-        xbt_assert(xbt_dynar_length(grand_parents) <2, "Error: transfer %s has 2 parents", SD_task_get_name(parent));
-
-        xbt_dynar_get_cpy(grand_parents, 0, &grand_parent);
-
-        sg_host_t * grand_parent_host_list = SD_task_get_workstation_list(grand_parent);
+        sg_host_t * parent_host= SD_task_get_workstation_list(parent);

         /* Estimate the redistribution time from this parent */
         if (SD_task_get_amount(parent) <= 1e-6){
           redist_time= 0;
         } else {
         /* Estimate the redistribution time from this parent */
         if (SD_task_get_amount(parent) <= 1e-6){
           redist_time= 0;
         } else {

-          redist_time = SD_route_get_latency(grand_parent_host_list[0], host) +
-                        SD_task_get_amount(parent) / SD_route_get_bandwidth(grand_parent_host_list[0], host);
+          redist_time = SD_route_get_latency(parent_host[0], host) +
+                        SD_task_get_amount(parent) / SD_route_get_bandwidth(parent_host[0], host);

         }
         }

-        data_available = SD_task_get_finish_time(grand_parent) + redist_time;
-
-        xbt_dynar_free_container(&grand_parents);
+        data_available = SD_task_get_start_time(parent) + redist_time;

       }
 
       /* no transfer, control dependency */
       }
 
       /* no transfer, control dependency */


@@ -134,7 +125,7 @@ static double finish_on_at(SD_task_t task, sg_host_t host)
 
 static sg_host_t SD_task_get_best_host(SD_task_t task)
 {
 
 static sg_host_t SD_task_get_best_host(SD_task_t task)
 {

-  const sg_host_t *hosts = sg_host_list();
+  sg_host_t *hosts = sg_host_list();

   int nhosts = sg_host_count();
   sg_host_t best_host = hosts[0];
   double min_EFT = finish_on_at(task, hosts[0]);
   int nhosts = sg_host_count();
   sg_host_t best_host = hosts[0];
   double min_EFT = finish_on_at(task, hosts[0]);


@@ -148,6 +139,7 @@ static sg_host_t SD_task_get_best_host(SD_task_t task)
       best_host = hosts[i];
     }
   }
       best_host = hosts[i];
     }
   }

+  xbt_free(hosts);

   return best_host;
 }
 
   return best_host;
 }
 


@@ -175,7 +167,7 @@ int main(int argc, char **argv)
 
   /*  Allocating the host attribute */
   int total_nhosts = sg_host_count();
 
   /*  Allocating the host attribute */
   int total_nhosts = sg_host_count();

-  const sg_host_t *hosts = sg_host_list();
+  sg_host_t *hosts = sg_host_list();

 
   for (cursor = 0; cursor < total_nhosts; cursor++)
     sg_host_allocate_attribute(hosts[cursor]);
 
   for (cursor = 0; cursor < total_nhosts; cursor++)
     sg_host_allocate_attribute(hosts[cursor]);


@@ -259,6 +251,7 @@ int main(int argc, char **argv)
   for (cursor = 0; cursor < total_nhosts; cursor++)
     sg_host_free_attribute(hosts[cursor]);
 
   for (cursor = 0; cursor < total_nhosts; cursor++)
     sg_host_free_attribute(hosts[cursor]);
 

+  xbt_free(hosts);

   /* exit */
   SD_exit();
   return 0;
   /* exit */
   SD_exit();
   return 0;

diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp
index 93d7cb6..166f54a 100644 (file)
--- a/src/simdag/sd_global.cpp
+++ b/src/simdag/sd_global.cpp
@@ -170,19 +170,18 @@ xbt_dynar_t SD_simulate(double how_long) {
         /* remove the dependencies after this task */
         for (std::set<SD_task_t>::iterator it=task->successors->begin(); it!=task->successors->end(); ++it){
           dst=*it;
         /* remove the dependencies after this task */
         for (std::set<SD_task_t>::iterator it=task->successors->begin(); it!=task->successors->end(); ++it){
           dst=*it;

-          dst->unsatisfied_dependencies--;
-          if (dst->is_not_ready > 0)
-            dst->is_not_ready--;
-          XBT_DEBUG("Released a dependency on %s: %d remain(s). Became schedulable if %d=0",
-             SD_task_get_name(dst), dst->unsatisfied_dependencies, dst->is_not_ready);
-          if (dst->unsatisfied_dependencies == 0) {
+          dst->predecessors->erase(task);
+          dst->inputs->erase(task);
+          XBT_DEBUG("Released a dependency on %s: %zu remain(s). Became schedulable if %zu=0",
+             SD_task_get_name(dst), dst->predecessors->size()+dst->inputs->size(), dst->predecessors->size());
+          if (dst->predecessors->empty() && dst->inputs->empty()) {

             if (SD_task_get_state(dst) == SD_SCHEDULED)
               SD_task_set_state(dst, SD_RUNNABLE);
             else
               SD_task_set_state(dst, SD_SCHEDULABLE);
           }
 
             if (SD_task_get_state(dst) == SD_SCHEDULED)
               SD_task_set_state(dst, SD_RUNNABLE);
             else
               SD_task_set_state(dst, SD_SCHEDULABLE);
           }
 

-          if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && dst->is_not_ready == 0) {
+          if (SD_task_get_state(dst) == SD_NOT_SCHEDULED && dst->predecessors->empty()){

             SD_task_set_state(dst, SD_SCHEDULABLE);
           }
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
             SD_task_set_state(dst, SD_SCHEDULABLE);
           }
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {


@@ -191,25 +190,21 @@ xbt_dynar_t SD_simulate(double how_long) {
             xbt_dynar_push(sd_global->return_set, &dst);
           }
         }
             xbt_dynar_push(sd_global->return_set, &dst);
           }
         }

+        task->successors->clear();

 
         for (std::set<SD_task_t>::iterator it=task->outputs->begin(); it!=task->outputs->end(); ++it){
           dst=*it;
 
         for (std::set<SD_task_t>::iterator it=task->outputs->begin(); it!=task->outputs->end(); ++it){
           dst=*it;

-          dst->unsatisfied_dependencies = 0;
-          dst->is_not_ready = 0;
+          dst->start_time = task->finish_time;
+          dst->predecessors->erase(task);

           if (SD_task_get_state(dst) == SD_SCHEDULED)
              SD_task_set_state(dst, SD_RUNNABLE);
           else
              SD_task_set_state(dst, SD_SCHEDULABLE);
           SD_task_t comm_dst = *(dst->successors->begin());
           if (SD_task_get_state(dst) == SD_SCHEDULED)
              SD_task_set_state(dst, SD_RUNNABLE);
           else
              SD_task_set_state(dst, SD_SCHEDULABLE);
           SD_task_t comm_dst = *(dst->successors->begin());

-          if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->is_not_ready > 0) {
-            comm_dst->is_not_ready--;
-
-            XBT_DEBUG("%s is a transfer, %s may be ready now if %d=0",
-                SD_task_get_name(dst), SD_task_get_name(comm_dst), comm_dst->is_not_ready);
-
-            if (comm_dst->is_not_ready == 0) {
-              SD_task_set_state(comm_dst, SD_SCHEDULABLE);
-            }
+          if (SD_task_get_state(comm_dst) == SD_NOT_SCHEDULED && comm_dst->predecessors->empty()){
+            XBT_DEBUG("%s is a transfer, %s may be ready now if %zu=0",
+                SD_task_get_name(dst), SD_task_get_name(comm_dst), comm_dst->predecessors->size());
+            SD_task_set_state(comm_dst, SD_SCHEDULABLE);

           }
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
           }
           if (SD_task_get_state(dst) == SD_RUNNABLE && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));


@@ -217,6 +212,7 @@ xbt_dynar_t SD_simulate(double how_long) {
             xbt_dynar_push(sd_global->return_set, &dst);
           }
         }
             xbt_dynar_push(sd_global->return_set, &dst);
           }
         }

+        task->outputs->clear();

       }
 
       /* let's see which tasks have just failed */
       }
 
       /* let's see which tasks have just failed */

diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp
index 9b677f8..49d888f 100644 (file)
--- a/src/simdag/sd_task.cpp
+++ b/src/simdag/sd_task.cpp
@@ -52,9 +52,6 @@ void SD_task_recycle_f(void *t)
   task->watch_points = 0;
 
   /* dependencies */
   task->watch_points = 0;
 
   /* dependencies */

-  task->unsatisfied_dependencies = 0;
-  task->is_not_ready = 0;
-

   task->inputs->clear();
   task->outputs->clear();
   task->predecessors->clear();
   task->inputs->clear();
   task->outputs->clear();
   task->predecessors->clear();


@@ -288,7 +285,7 @@ void SD_task_set_data(SD_task_t task, void *data)
 void SD_task_set_rate(SD_task_t task, double rate)
 {
   xbt_assert(task->kind == SD_TASK_COMM_E2E, "The rate can be modified for end-to-end communications only.");
 void SD_task_set_rate(SD_task_t task, double rate)
 {
   xbt_assert(task->kind == SD_TASK_COMM_E2E, "The rate can be modified for end-to-end communications only.");

-  if(task->start_time<0) {
+  if(task->state < SD_RUNNING) {

     task->rate = rate;
   } else {
     XBT_WARN("Task %p has started. Changing rate is ineffective.", task);
     task->rate = rate;
   } else {
     XBT_WARN("Task %p has started. Changing rate is ineffective.", task);


@@ -313,6 +310,7 @@ e_SD_task_state_t SD_task_get_state(SD_task_t task)
 void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
 {
   std::set<SD_task_t>::iterator idx;
 void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
 {
   std::set<SD_task_t>::iterator idx;

+  XBT_DEBUG("Set state of '%s' to %d", task->name, new_state);

   switch (new_state) {
   case SD_NOT_SCHEDULED:
   case SD_SCHEDULABLE:
   switch (new_state) {
   case SD_NOT_SCHEDULED:
   case SD_SCHEDULABLE:


@@ -531,13 +529,10 @@ void SD_task_dump(SD_task_t task)
     }
   }
 
     }
   }
 

-  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);
   XBT_INFO("  - amount: %.0f", SD_task_get_amount(task));
   if (task->kind == SD_TASK_COMP_PAR_AMDAHL)
     XBT_INFO("  - alpha: %.2f", task->alpha);

-  XBT_INFO("  - Dependencies to satisfy: %d", task->unsatisfied_dependencies);
+  XBT_INFO("  - Dependencies to satisfy: %zu", task->inputs->size()+ task->predecessors->size());

   if ((task->inputs->size()+ task->predecessors->size()) > 0) {
     XBT_INFO("  - pre-dependencies:");
     for (std::set<SD_task_t>::iterator it=task->predecessors->begin(); it!=task->predecessors->end(); ++it)
   if ((task->inputs->size()+ task->predecessors->size()) > 0) {
     XBT_INFO("  - pre-dependencies:");
     for (std::set<SD_task_t>::iterator it=task->predecessors->begin(); it!=task->predecessors->end(); ++it)


@@ -636,9 +631,6 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task
     dst->predecessors->insert(src);
   }
 
     dst->predecessors->insert(src);
   }
 

-  dst->unsatisfied_dependencies++;
-  dst->is_not_ready++;
-

   /* if the task was runnable, the task goes back to SD_SCHEDULED because of the new dependency*/
   if (SD_task_get_state(dst) == SD_RUNNABLE) {
     XBT_DEBUG("SD_task_dependency_add: %s was runnable and becomes scheduled!", SD_task_get_name(dst));
   /* if the task was runnable, the task goes back to SD_SCHEDULED because of the new dependency*/
   if (SD_task_get_state(dst) == SD_RUNNABLE) {
     XBT_DEBUG("SD_task_dependency_add: %s was runnable and becomes scheduled!", SD_task_get_name(dst));


@@ -680,7 +672,6 @@ int SD_task_dependency_exists(SD_task_t src, SD_task_t dst)
  */
 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
 {
  */
 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
 {

-

   XBT_DEBUG("SD_task_dependency_remove: src = %s, dst = %s", SD_task_get_name(src), SD_task_get_name(dst));
 
   if (src->successors->find(dst) == src->successors->end() &&
   XBT_DEBUG("SD_task_dependency_remove: src = %s, dst = %s", SD_task_get_name(src), SD_task_get_name(dst));
 
   if (src->successors->find(dst) == src->successors->end() &&


@@ -688,12 +679,6 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
     THROWF(arg_error, 0, "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'",
            SD_task_get_name(src), SD_task_get_name(dst), SD_task_get_name(dst), SD_task_get_name(src));
 
     THROWF(arg_error, 0, "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'",
            SD_task_get_name(src), SD_task_get_name(dst), SD_task_get_name(dst), SD_task_get_name(src));
 

-  if (dst->predecessors->find(src) != dst->predecessors->end() ||
-      dst->inputs->find(src) != dst->inputs->end()){
-    dst->unsatisfied_dependencies--;
-    dst->is_not_ready--;
-  }
-

   e_SD_task_kind_t src_kind = SD_task_get_kind(src);
   e_SD_task_kind_t dst_kind = SD_task_get_kind(dst);
   if (src_kind == SD_TASK_COMM_E2E || src_kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
   e_SD_task_kind_t src_kind = SD_task_get_kind(src);
   e_SD_task_kind_t dst_kind = SD_task_get_kind(dst);
   if (src_kind == SD_TASK_COMM_E2E || src_kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){


@@ -713,15 +698,8 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
   }
 
   /* if the task was scheduled and dependencies are satisfied, we can make it runnable */
   }
 
   /* if the task was scheduled and dependencies are satisfied, we can make it runnable */

-  if (dst->unsatisfied_dependencies == 0) {
-    if (SD_task_get_state(dst) == SD_SCHEDULED)
-      SD_task_set_state(dst, SD_RUNNABLE);
-    else
-      SD_task_set_state(dst, SD_SCHEDULABLE);
-  }
-
-  if (dst->is_not_ready == 0)
-    SD_task_set_state(dst, SD_SCHEDULABLE);
+  if (dst->predecessors->empty() && dst->inputs->empty() && SD_task_get_state(dst) == SD_SCHEDULED)
+    SD_task_set_state(dst, SD_RUNNABLE);

 }
 
 /**
 }
 
 /**


@@ -802,7 +780,7 @@ static inline void SD_task_do_schedule(SD_task_t task)
   if (SD_task_get_state(task) > SD_SCHEDULABLE)
     THROWF(arg_error, 0, "Task '%s' has already been scheduled", SD_task_get_name(task));
 
   if (SD_task_get_state(task) > SD_SCHEDULABLE)
     THROWF(arg_error, 0, "Task '%s' has already been scheduled", SD_task_get_name(task));
 

-  if (task->unsatisfied_dependencies == 0)
+  if (task->predecessors->empty() && task->inputs->empty())

     SD_task_set_state(task, SD_RUNNABLE);
   else
     SD_task_set_state(task, SD_SCHEDULED);
     SD_task_set_state(task, SD_RUNNABLE);
   else
     SD_task_set_state(task, SD_SCHEDULED);


@@ -884,7 +862,7 @@ void SD_task_unschedule(SD_task_t task)
     /* the task should become SD_FAILED */
     task->surf_action->cancel();
   else {
     /* the task should become SD_FAILED */
     task->surf_action->cancel();
   else {

-    if (task->unsatisfied_dependencies == 0)
+    if (task->predecessors->empty() && task->inputs->empty())

       SD_task_set_state(task, SD_SCHEDULABLE);
     else
       SD_task_set_state(task, SD_NOT_SCHEDULED);
       SD_task_set_state(task, SD_SCHEDULABLE);
     else
       SD_task_set_state(task, SD_NOT_SCHEDULED);


@@ -923,9 +901,6 @@ void SD_task_run(SD_task_t task)
 
   XBT_DEBUG("surf_action = %p", task->surf_action);
 
 
   XBT_DEBUG("surf_action = %p", task->surf_action);
 

-  if (task->category)
-    TRACE_surf_action(task->surf_action, task->category);
-

   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */
   SD_task_set_state(task, SD_RUNNING);
 }
   __SD_task_destroy_scheduling_data(task);      /* now the scheduling data are not useful anymore */
   SD_task_set_state(task, SD_RUNNING);
 }

diff --git a/src/simdag/simdag_private.h b/src/simdag/simdag_private.h
index 331a2c3..0ce8109 100644 (file)
--- a/src/simdag/simdag_private.h
+++ b/src/simdag/simdag_private.h
@@ -49,9 +49,6 @@ typedef struct SD_task {
   int marked;                   /* used to check if the task DAG has some cycle*/
 
   /* dependencies */
   int marked;                   /* used to check if the task DAG has some cycle*/
 
   /* dependencies */

-  int unsatisfied_dependencies;
-  unsigned int is_not_ready;
-

   std::set<SD_task_t> *inputs;
   std::set<SD_task_t> *outputs;
   std::set<SD_task_t> *predecessors;
   std::set<SD_task_t> *inputs;
   std::set<SD_task_t> *outputs;
   std::set<SD_task_t> *predecessors;


@@ -63,9 +60,6 @@ typedef struct SD_task {
   double *flops_amount;
   double *bytes_amount;
   double rate;
   double *flops_amount;
   double *bytes_amount;
   double rate;

-
-  long long int counter;        /* task unique identifier for instrumentation */
-  char *category;               /* sd task category for instrumentation */

 } s_SD_task_t;
 
 /* SimDag private functions */
 } s_SD_task_t;
 
 /* SimDag private functions */