src/simdag/sd_task.c

   1 #include "private.h"
   2 #include "simdag/simdag.h"
   3 #include "xbt/sysdep.h"
   4 #include "xbt/dynar.h"
   5
   6 /* Creates a task.
   7  */
   8 SD_task_t SD_task_create(const char *name, void *data, double amount) {
   9   SD_CHECK_INIT_DONE();
  10   xbt_assert0(amount > 0, "amount must be positive");
  11
  12   SD_task_t task = xbt_new0(s_SD_task_t, 1);
  13
  14   /* general information */
  15   task->data = data; /* user data */
  16   if (name != NULL)
  17     task->name = xbt_strdup(name);
  18   else
  19     task->name = NULL;
  20
  21   task->state_set = sd_global->not_scheduled_task_set;
  22   xbt_swag_insert(task,task->state_set);
  23
  24   task->amount = amount;
  25   task->surf_action = NULL;
  26   task->watch_points = 0;
  27   task->state_changed = 0;
  28
  29   /* dependencies */
  30   task->tasks_before = xbt_dynar_new(sizeof(SD_dependency_t), NULL);
  31   task->tasks_after = xbt_dynar_new(sizeof(SD_dependency_t), NULL);
  32
  33   /* scheduling parameters */
  34   task->workstation_nb = 0;
  35   task->workstation_list = NULL;
  36   task->computation_amount = NULL;
  37   task->communication_amount = NULL;
  38   task->rate = 0;
  39
  40   return task;
  41 }
  42
  43 /* Returns the data of a task.
  44  */
  45 void* SD_task_get_data(SD_task_t task) {
  46   SD_CHECK_INIT_DONE();
  47   xbt_assert0(task != NULL, "Invalid parameter");
  48   return task->data;
  49 }
  50
  51 /* Returns the state of a task: SD_NOT_SCHEDULED, SD_SCHEDULED, SD_RUNNING, SD_DONE or SD_FAILED.
  52  */
  53 e_SD_task_state_t SD_task_get_state(SD_task_t task) {
  54   SD_CHECK_INIT_DONE();
  55   xbt_assert0(task != NULL, "Invalid parameter");
  56
  57   if (task->state_set == sd_global->not_scheduled_task_set)
  58     return SD_NOT_SCHEDULED;
  59   if (task->state_set == sd_global->scheduled_task_set)
  60     return SD_SCHEDULED;
  61   if (task->state_set == sd_global->running_task_set)
  62     return SD_RUNNING;
  63   if (task->state_set == sd_global->done_task_set)
  64     return SD_DONE;
  65   return SD_FAILED;
  66 }
  67
  68 /* Changes the state of a task. Update the swags and the flag sd_global->watch_point_reached.
  69  */
  70 void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) {
  71   xbt_swag_remove(task, task->state_set);
  72   switch (new_state) {
  73   case SD_NOT_SCHEDULED:
  74     task->state_set = sd_global->not_scheduled_task_set;
  75     break;
  76   case SD_SCHEDULED:
  77     task->state_set = sd_global->scheduled_task_set;
  78     break;
  79   case SD_RUNNING:
  80     task->state_set = sd_global->running_task_set;
  81     break;
  82   case SD_DONE:
  83     task->state_set = sd_global->done_task_set;
  84     break;
  85   default: /* SD_FAILED */
  86     task->state_set = sd_global->failed_task_set;
  87   }
  88   xbt_swag_insert(task,task->state_set);
  89
  90   if (task->watch_points & new_state) {
  91     printf("Watch point reached with task '%s' in state %d!\n", SD_task_get_name(task), new_state);
  92     sd_global->watch_point_reached = 1;
  93   }
  94 }
  95
  96 /* Sets the data of a task.
  97  */
  98 void SD_task_set_data(SD_task_t task, void *data) {
  99   SD_CHECK_INIT_DONE();
 100   xbt_assert0(task != NULL, "Invalid parameter");
 101   task->data = data;
 102 }
 103
 104 /* Returns the name of a task. The name can be NULL.
 105  */
 106 const char* SD_task_get_name(SD_task_t task) {
 107   SD_CHECK_INIT_DONE();
 108   xbt_assert0(task != NULL, "Invalid parameter");
 109   return task->name;
 110 }
 111
 112 /* Returns the computing amount of a task.
 113  */
 114 double SD_task_get_amount(SD_task_t task) {
 115   SD_CHECK_INIT_DONE();
 116   xbt_assert0(task != NULL, "Invalid parameter");
 117   return task->amount;
 118 }
 119
 120 /* Returns the remaining computing amount of a task.
 121  */
 122 double SD_task_get_remaining_amount(SD_task_t task) {
 123   SD_CHECK_INIT_DONE();
 124   xbt_assert0(task != NULL, "Invalid parameter");
 125
 126   if (task->surf_action)
 127     return task->amount;
 128   else
 129     return task->surf_action->remains;
 130 }
 131
 132 /* temporary function for debbuging
 133 void __SD_print_dependencies(SD_task_t task) {
 134   printf("The following tasks must be executed before %s:", SD_task_get_name(task));
 135   xbt_dynar_t dynar = task->tasks_before;
 136   int length = xbt_dynar_length(dynar);
 137   int i;
 138   SD_dependency_t dependency;
 139   for (i = 0; i < length; i++) {
 140     xbt_dynar_get_cpy(dynar, i, &dependency);
 141     printf(" %s", SD_task_get_name(dependency->src));
 142   }
 143
 144   printf("\nThe following tasks must be executed after %s:", SD_task_get_name(task));
 145
 146   dynar = task->tasks_after;
 147   length = xbt_dynar_length(dynar);
 148   for (i = 0; i < length; i++) {
 149     xbt_dynar_get_cpy(dynar, i, &dependency);
 150     printf(" %s", SD_task_get_name(dependency->dst));
 151   }
 152   printf("\n----------------------------\n");
 153 }*/
 154
 155 /* Destroys a dependency between two tasks.
 156  */
 157 static void __SD_task_destroy_dependency(void *dependency) {
 158   if (((SD_dependency_t) dependency)->name != NULL)
 159     xbt_free(((SD_dependency_t) dependency)->name);
 160   xbt_free(dependency);
 161 }
 162
 163 /* Adds a dependency between two tasks.
 164  */
 165 void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) {
 166   SD_CHECK_INIT_DONE();
 167   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 168   xbt_assert1(src != dst, "Cannot add a dependency between task '%s' and itself", SD_task_get_name(src));
 169
 170   xbt_dynar_t dynar = src->tasks_after;
 171   int length = xbt_dynar_length(dynar);
 172   int found = 0;
 173   int i;
 174   SD_dependency_t dependency;
 175   for (i = 0; i < length && !found; i++) {
 176     xbt_dynar_get_cpy(dynar, i, &dependency);
 177     found = (dependency->dst == dst);
 178   }
 179   xbt_assert2(!found, "A dependency already exists between task '%s' and task '%s'", SD_task_get_name(src), SD_task_get_name(dst));
 180
 181   dependency = xbt_new0(s_SD_dependency_t, 1);
 182
 183   if (name != NULL)
 184     dependency->name = xbt_strdup(name);
 185   dependency->data = data;
 186   dependency->src = src;
 187   dependency->dst = dst;
 188
 189   /* src must be executed before dst */
 190   xbt_dynar_push(src->tasks_after, &dependency);
 191   xbt_dynar_push(dst->tasks_before, &dependency);
 192
 193   /*  __SD_print_dependencies(src);
 194       __SD_print_dependencies(dst); */
 195 }
 196
 197 /* Removes a dependency between two tasks.
 198  */
 199 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
 200   SD_CHECK_INIT_DONE();
 201   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 202   xbt_assert1(src != dst, "Cannot remove a dependency between task '%s' and itself", SD_task_get_name(src));
 203
 204   xbt_dynar_t dynar = src->tasks_after;
 205   int length = xbt_dynar_length(dynar);
 206   int found = 0;
 207   int i;
 208   SD_dependency_t dependency;
 209   for (i = 0; i < length && !found; i++) {
 210     xbt_dynar_get_cpy(dynar, i, &dependency);
 211     if (dependency->dst == dst) {
 212       xbt_dynar_remove_at(dynar, i, NULL);
 213       found = 1;
 214     }
 215   }
 216   xbt_assert4(found, "No dependency found between task '%s' and '%s': task '%s' is not a successor of task '%s'",
 217               SD_task_get_name(src), SD_task_get_name(dst), SD_task_get_name(dst), SD_task_get_name(src));
 218
 219   dynar = dst->tasks_before;
 220   length = xbt_dynar_length(dynar);
 221   found = 0;
 222
 223   for (i = 0; i < length && !found; i++) {
 224     xbt_dynar_get_cpy(dynar, i, &dependency);
 225     if (dependency->src == src) {
 226       xbt_dynar_remove_at(dynar, i, NULL);
 227       __SD_task_destroy_dependency(dependency);
 228       found = 1;
 229     }
 230   }
 231   xbt_assert4(found, "SimDag error: task '%s' is a successor of '%s' but task '%s' is not a predecessor of task '%s'",
 232               SD_task_get_name(dst), SD_task_get_name(src), SD_task_get_name(src), SD_task_get_name(dst)); /* should never happen... */
 233
 234   /*   __SD_print_dependencies(src);
 235        __SD_print_dependencies(dst); */
 236 }
 237
 238 /* Returns the data associated to a dependency between two tasks. This data can be NULL.
 239  */
 240 void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) {
 241   SD_CHECK_INIT_DONE();
 242   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 243   xbt_assert1(src != dst, "Cannot have a dependency between task '%s' and itself", SD_task_get_name(src));
 244
 245   xbt_dynar_t dynar = src->tasks_after;
 246   int length = xbt_dynar_length(dynar);
 247   int found = 0;
 248   int i;
 249   SD_dependency_t dependency;
 250   for (i = 0; i < length && !found; i++) {
 251     xbt_dynar_get_cpy(dynar, i, &dependency);
 252     found = (dependency->dst == dst);
 253   }
 254   xbt_assert2(found, "No dependency found between task '%s' and '%s'", SD_task_get_name(src), SD_task_get_name(dst));
 255   return dependency->data;
 256 }
 257
 258 /* temporary function for debugging */
 259 static void __SD_print_watch_points(SD_task_t task) {
 260   static const int state_masks[] = {SD_SCHEDULED, SD_RUNNING, SD_DONE, SD_FAILED};
 261   static const char* state_names[] = {"scheduled", "running", "done", "failed"};
 262
 263   printf("Task '%s' watch points (%x): ", SD_task_get_name(task), task->watch_points);
 264
 265   int i;
 266   for (i = 0; i < 4; i++) {
 267     if (task->watch_points & state_masks[i])
 268       printf("%s ", state_names[i]);
 269   }
 270   printf("\n");
 271 }
 272
 273 /* Adds a watch point to a task.
 274    SD_simulate will stop as soon as the state of this task is the one given in argument.
 275    Watch point is then automatically removed.
 276  */
 277 void SD_task_watch(SD_task_t task, e_SD_task_state_t state) {
 278   SD_CHECK_INIT_DONE();
 279   xbt_assert0(task != NULL, "Invalid parameter");
 280
 281   task->watch_points = task->watch_points | state;
 282   __SD_print_watch_points(task);
 283 }
 284
 285 /* Removes a watch point from a task.
 286  */
 287 void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state) {
 288   SD_CHECK_INIT_DONE();
 289   xbt_assert0(task != NULL, "Invalid parameter");
 290
 291   task->watch_points = task->watch_points & ~state;
 292   __SD_print_watch_points(task);
 293 }
 294
 295 /* Destroys the data memorised by SD_task_schedule. Task state must be SD_SCHEDULED.
 296  */
 297 static void __SD_task_destroy_scheduling_data(SD_task_t task) {
 298   xbt_free(task->workstation_list);
 299   xbt_free(task->computation_amount);
 300   xbt_free(task->communication_amount);
 301 }
 302
 303 /* Schedules a task.
 304  * task: the task to schedule
 305  * workstation_nb: number of workstations where the task will be executed
 306  * workstation_list: workstations where the task will be executed
 307  * computation_amount: computation amount for each workstation
 308  * communication_amount: communication amount between each pair of workstations
 309  * rate: task execution speed rate
 310  */
 311 void SD_task_schedule(SD_task_t task, int workstation_nb,
 312                      const SD_workstation_t *workstation_list, double *computation_amount,
 313                      double *communication_amount, double rate) {
 314   SD_CHECK_INIT_DONE();
 315   xbt_assert0(task, "Invalid parameter");
 316   xbt_assert1(SD_task_get_state(task) == SD_NOT_SCHEDULED, "Task '%s' has already been scheduled.", SD_task_get_name(task));
 317   xbt_assert0(workstation_nb > 0, "workstation_nb must be positive");
 318
 319   task->workstation_nb = workstation_nb;
 320   task->rate = rate;
 321
 322   task->computation_amount = xbt_new0(double, workstation_nb);
 323   memcpy(task->computation_amount, computation_amount, sizeof(double) * workstation_nb);
 324
 325   int communication_nb = workstation_nb * workstation_nb;
 326   task->communication_amount = xbt_new0(double, communication_nb);
 327   memcpy(task->communication_amount, communication_amount, sizeof(double) * communication_nb);
 328
 329   /* we have to create a Surf workstation array instead of the SimDag workstation array */
 330   task->workstation_list = xbt_new0(void*, workstation_nb);
 331   int i;
 332   for (i = 0; i < workstation_nb; i++) {
 333     task->workstation_list[i] = workstation_list[i]->surf_workstation;
 334   }
 335
 336   __SD_task_set_state(task, SD_SCHEDULED);
 337 }
 338
 339 /* Unschedules a task. The state must be SD_SCHEDULED, SD_RUNNING or SD_FAILED.
 340  * The task is reinitialised and its state becomes SD_NOT_SCHEDULED.
 341  * Call SD_task_schedule to schedule it again.
 342  */
 343 void SD_task_unschedule(SD_task_t task) {
 344   SD_CHECK_INIT_DONE();
 345   xbt_assert0(task != NULL, "Invalid parameter");
 346   e_SD_task_state_t state = SD_task_get_state(task);
 347   xbt_assert1(state == SD_SCHEDULED ||
 348               state == SD_RUNNING ||
 349               state == SD_FAILED,
 350               "Task %s: the state must be SD_SCHEDULED, SD_RUNNING or SD_FAILED", SD_task_get_name(task));
 351
 352   if (state == SD_SCHEDULED)
 353     __SD_task_destroy_scheduling_data(task);
 354
 355   __SD_task_set_state(task, SD_NOT_SCHEDULED);
 356 }
 357
 358 /* Runs a task. This function is called by SD_simulate when a scheduled task can start
 359  * (ie when its dependencies are satisfied).
 360  */
 361 surf_action_t __SD_task_run(SD_task_t task) {
 362   SD_CHECK_INIT_DONE();
 363   xbt_assert0(task != NULL, "Invalid parameter");
 364
 365
 366   surf_action_t surf_action = surf_workstation_resource->extension_public->
 367     execute_parallel_task(task->workstation_nb,
 368                           task->workstation_list,
 369                           task->computation_amount,
 370                           task->communication_amount,
 371                           task->amount,
 372                           task->rate);
 373   __SD_task_set_state(task, SD_RUNNING);
 374
 375   __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
 376   return surf_action;
 377 }
 378
 379 /* Remove all dependencies associated with a task. This function is called when the task is done.
 380  */
 381 void __SD_task_remove_dependencies(SD_task_t task) {
 382   /* we must destroy the dependencies carefuly (with SD_dependency_remove)
 383      because each one is stored twice */
 384   SD_dependency_t dependency;
 385   while (xbt_dynar_length(task->tasks_before) > 0) {
 386     xbt_dynar_get_cpy(task->tasks_before, 0, &dependency);
 387     SD_task_dependency_remove(dependency->src, dependency->dst);
 388   }
 389
 390   while (xbt_dynar_length(task->tasks_after) > 0) {
 391     xbt_dynar_get_cpy(task->tasks_after, 0, &dependency);
 392     SD_task_dependency_remove(dependency->src, dependency->dst);
 393   }
 394 }
 395
 396 /* Destroys a task. The user data (if any) should have been destroyed first.
 397  */
 398 void SD_task_destroy(SD_task_t task) {
 399   SD_CHECK_INIT_DONE();
 400   xbt_assert0(task != NULL, "Invalid parameter");
 401
 402   /*printf("Destroying task %s...\n", SD_task_get_name(task));*/
 403
 404   __SD_task_remove_dependencies(task);
 405
 406   /* if the task was scheduled we have to free the scheduling parameters */
 407   if (SD_task_get_state(task) == SD_SCHEDULED)
 408     __SD_task_destroy_scheduling_data(task);
 409
 410   if (task->name != NULL)
 411     xbt_free(task->name);
 412
 413   xbt_dynar_free(&task->tasks_before);
 414   xbt_dynar_free(&task->tasks_after);
 415   xbt_free(task);
 416
 417   /*printf("Task destroyed.\n");*/
 418 }