Do connect all log channel manually to parent using XBT_LOG_CONNECT() too, so that...

[simgrid.git] / src / simdag / sd_task.c

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index f2aa7bd..c9db873 100644 (file)
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -124,12 +124,12 @@ 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_resource->common_public->
+    task->start_time = surf_workstation_model->common_public->
       action_get_start_time(task->surf_action);
     break;
   case SD_DONE:
     task->state_set = sd_global->done_task_set;
-    task->finish_time = surf_workstation_resource->common_public->
+    task->finish_time = surf_workstation_model->common_public->
       action_get_finish_time(task->surf_action);
     task->remains = 0;
     break;
@@ -301,6 +301,31 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task
       __SD_print_dependencies(dst); */
 }
 
+/**
+ * \brief Indacates whether there is a dependency between two tasks.
+ *
+ * \param src a task
+ * \param dst a task depending on \a src
+ */
+int SD_task_dependency_exists(SD_task_t src, SD_task_t dst) {
+  xbt_dynar_t dynar;
+  int length;
+  int i;
+  SD_dependency_t dependency;
+
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+  dynar = src->tasks_after;
+  length = xbt_dynar_length(dynar);
+
+  for (i = 0; i < length; i++) {
+    xbt_dynar_get_cpy(dynar, i, &dependency);
+    if (dependency->dst == dst) return 1;
+  }
+  return 0;
+}
+
 /**
  * \brief Remove a dependency between two tasks
  *
@@ -564,7 +589,7 @@ void SD_task_unschedule(SD_task_t task) {
     __SD_task_destroy_scheduling_data(task);
 
   if (__SD_task_is_running(task)) /* the task should become SD_FAILED */
-    surf_workstation_resource->common_public->action_cancel(task->surf_action);
+    surf_workstation_model->common_public->action_cancel(task->surf_action);
   else
     __SD_task_set_state(task, SD_NOT_SCHEDULED);
   task->remains = task->amount;
@@ -620,19 +645,60 @@ void __SD_task_really_run(SD_task_t task) {
     surf_workstations[i] = task->workstation_list[i]->surf_workstation;
   }
   
-  task->surf_action = surf_workstation_resource->extension_public->
-    execute_parallel_task(task->workstation_nb,
-                         surf_workstations,
-                         task->computation_amount,
-                         task->communication_amount,
-                         task->amount,
-                         task->rate);
-  surf_workstation_resource->common_public->action_set_data(task->surf_action, task);
+  task->surf_action = NULL;
+  if((task->workstation_nb==1) &&
+     (task->communication_amount[0]==0.0)) {
+    task->surf_action = surf_workstation_model->extension_public->
+      execute(surf_workstations[0], task->computation_amount[0]);
+  } else if((task->workstation_nb==1) &&
+           (task->computation_amount[0]==0.0)) {
+    task->surf_action = surf_workstation_model->extension_public->
+      communicate(surf_workstations[0], surf_workstations[0],
+                 task->communication_amount[0],task->rate);
+  } else if((task->workstation_nb==2) &&
+           (task->computation_amount[0]==0.0)&&
+           (task->computation_amount[1]==0.0)) {
+    int nb=0;
+    double value=0.0;
+    
+    for (i = 0; i < task->workstation_nb*task->workstation_nb; i++) {
+      if(task->communication_amount[i]>0.0) {
+       nb++;
+       value = task->communication_amount[i];
+      }
+    }
+    if(nb==1) {
+      task->surf_action = surf_workstation_model->extension_public->
+       communicate(surf_workstations[0], surf_workstations[1],
+                   value, task->rate);
+    }
+  }
+  if(!task->surf_action) {
+    double *computation_amount = xbt_new(double, task->workstation_nb);
+    double *communication_amount = xbt_new(double, task->workstation_nb * 
+                                          task->workstation_nb);
+
+    memcpy(computation_amount, task->computation_amount, sizeof(double) * 
+          task->workstation_nb);
+    memcpy(communication_amount, task->communication_amount, 
+          sizeof(double) * task->workstation_nb * task->workstation_nb);
+
+    task->surf_action = surf_workstation_model->extension_public->
+      execute_parallel_task(task->workstation_nb,
+                           surf_workstations,
+                           computation_amount,
+                           communication_amount,
+                           task->amount,
+                           task->rate);
+  } else {
+    xbt_free(surf_workstations);
+  }
+
+  surf_workstation_model->common_public->action_set_data(task->surf_action, task);
   task->state_changed = 1;
 
   DEBUG1("surf_action = %p",  task->surf_action);
 
-  xbt_free(surf_workstations);
   __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
   __SD_task_set_state(task, SD_RUNNING);
   xbt_assert2(__SD_task_is_running(task), "Bad state of task '%s': %d",
@@ -708,7 +774,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_resource->common_public->action_free(task->surf_action);
+  surf_workstation_model->common_public->action_free(task->surf_action);
   task->surf_action = NULL;
 
   DEBUG0("Looking for candidates");
@@ -841,7 +907,7 @@ double SD_task_get_start_time(SD_task_t task) {
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
   if(task->surf_action)
-    return surf_workstation_resource->common_public->action_get_start_time(task->surf_action);
+    return surf_workstation_model->common_public->action_get_start_time(task->surf_action);
   else 
     return task->start_time;
 }
@@ -862,7 +928,7 @@ double SD_task_get_finish_time(SD_task_t task) {
   xbt_assert0(task != NULL, "Invalid parameter");
 
   if(task->surf_action) /* should never happen as actions are destroyed right after their completion */
-    return surf_workstation_resource->common_public->action_get_finish_time(task->surf_action);
+    return surf_workstation_model->common_public->action_get_finish_time(task->surf_action);
   else 
     return task->finish_time;
 }
@@ -891,7 +957,7 @@ void SD_task_destroy(SD_task_t task) {
     xbt_free(task->name);
 
   if (task->surf_action != NULL)
-    surf_workstation_resource->common_public->action_free(task->surf_action);
+    surf_workstation_model->common_public->action_free(task->surf_action);
 
   if (task->workstation_list != NULL)
     xbt_free(task->workstation_list);