src/simdag/sd_task.c

   1 #include "private.h"
   2 #include "simdag/simdag.h"
   3 #include "xbt/sysdep.h"
   4
   5 /* Creates a task.
   6  */
   7 SD_task_t SD_task_create(const char *name, void *data, double amount) {
   8   CHECK_INIT_DONE();
   9   xbt_assert0(name != NULL, "name is NULL !");
  10   xbt_assert0(amount > 0, "amount must be positive");
  11
  12   SD_task_data_t sd_data = xbt_new0(s_SD_task_data_t, 1); /* task private data */
  13   sd_data->name = xbt_strdup(name);
  14   sd_data->state = SD_NOT_SCHEDULED;
  15   sd_data->amount = amount;
  16   sd_data->surf_action = NULL;
  17   sd_data->watch_points = 0;
  18
  19   SD_task_t task = xbt_new0(s_SD_task_t, 1);
  20   task->sd_data = sd_data; /* private data */
  21   task->data = data; /* user data */
  22
  23   /* TODO: dependencies */
  24
  25   return task;
  26 }
  27
  28 /* Schedules a task.
  29  */
  30 int SD_task_schedule(SD_task_t task, int workstation_nb,
  31                      SD_workstation_t **workstation_list, double *computation_amount,
  32                      double *communication_amount, double rate) {
  33   CHECK_INIT_DONE();
  34   xbt_assert0(task, "Invalid parameter");
  35   /* TODO */
  36
  37   return 0;
  38 }
  39
  40 /* Returns the data of a task.
  41  */
  42 void* SD_task_get_data(SD_task_t task) {
  43   CHECK_INIT_DONE();
  44   xbt_assert0(task, "Invalid parameter");
  45   return task->data;
  46 }
  47
  48 /* Sets the data of a task.
  49  */
  50 void SD_task_set_data(SD_task_t task, void *data) {
  51   CHECK_INIT_DONE();
  52   xbt_assert0(task, "Invalid parameter");
  53   task->data = data;
  54 }
  55
  56 /* Returns the name of a task.
  57  */
  58 const char* SD_task_get_name(SD_task_t task) {
  59   CHECK_INIT_DONE();
  60   xbt_assert0(task, "Invalid parameter");
  61   return task->sd_data->name;
  62 }
  63
  64 /* Returns the computing amount of a task.
  65  */
  66 double SD_task_get_amount(SD_task_t task) {
  67   CHECK_INIT_DONE();
  68   xbt_assert0(task, "Invalid parameter");
  69   return task->sd_data->amount;
  70 }
  71
  72 /* Returns the remaining computing amount of a task.
  73  */
  74 double SD_task_get_remaining_amount(SD_task_t task) {
  75   CHECK_INIT_DONE();
  76   xbt_assert0(task, "Invalid parameter");
  77   SD_task_data_t sd_data = task->sd_data;
  78   if (sd_data->surf_action == NULL)
  79     return sd_data->amount;
  80   else
  81     return sd_data->surf_action->remains;
  82 }
  83
  84 /* Adds a dependency between two tasks.
  85  */
  86 void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) {
  87   CHECK_INIT_DONE();
  88   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
  89   /* TODO */
  90 }
  91
  92 /* Removes a dependency between two tasks.
  93  */
  94 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
  95   CHECK_INIT_DONE();
  96   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
  97   /* TODO */
  98 }
  99
 100 /* Returns the state of a task: SD_NOT_SCHEDULED, SD_SCHEDULED, SD_RUNNING, SD_DONE or SD_FAILED.
 101  */
 102 SD_task_state_t SD_task_get_state(SD_task_t task) {
 103   CHECK_INIT_DONE();
 104   xbt_assert0(task, "Invalid parameter");
 105   return task->sd_data->state;
 106 }
 107
 108 /* temporary function for debugging */
 109 void __SD_print_watch_points(SD_task_t task) {
 110   static const int state_masks[] = {SD_SCHEDULED, SD_RUNNING, SD_DONE, SD_FAILED};
 111   static const char* state_names[] = {"scheduled", "running", "done", "failed"};
 112
 113   printf("Task '%s' watch points (%x): ", task->sd_data->name, task->sd_data->watch_points);
 114
 115   int i;
 116   for (i = 0; i < 4; i++) {
 117     if (task->sd_data->watch_points & state_masks[i])
 118       printf("%s ", state_names[i]);
 119
 120   }
 121   printf("\n");
 122 }
 123
 124 /* Adds a watch point to a task.
 125    SD_simulate will stop as soon as the state of this task is the one given in argument.
 126    Watch point is then automatically removed.
 127  */
 128 void SD_task_watch(SD_task_t task, SD_task_state_t state) {
 129   CHECK_INIT_DONE();
 130   xbt_assert0(task, "Invalid parameter");
 131
 132   task->sd_data->watch_points = task->sd_data->watch_points | state;
 133   __SD_print_watch_points(task);
 134 }
 135
 136 /* Removes a watch point from a task.
 137  */
 138 void SD_task_unwatch(SD_task_t task, SD_task_state_t state) {
 139   CHECK_INIT_DONE();
 140   xbt_assert0(task, "Invalid parameter");
 141
 142   task->sd_data->watch_points = task->sd_data->watch_points & ~state;
 143   __SD_print_watch_points(task);
 144 }
 145
 146 /* Unschedules a task.
 147    Change state and rerun
 148  */
 149 void SD_task_unschedule(SD_task_t task) {
 150   CHECK_INIT_DONE();
 151   xbt_assert0(task, "Invalid parameter");
 152   /* TODO */
 153 }
 154
 155 /* Destroys a task. The user data (if any) should have been destroyed first.
 156  */
 157 void SD_task_destroy(SD_task_t task) {
 158   CHECK_INIT_DONE();
 159   xbt_free(task->sd_data->name);
 160   xbt_free(task->sd_data);
 161   /* TODO: dependencies */
 162   xbt_free(task);
 163 }