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   SD_CHECK_INIT_DONE();
   9   xbt_assert0(amount > 0, "amount must be positive");
  10
  11   SD_task_data_t sd_data = xbt_new0(s_SD_task_data_t, 1); /* task private data */
  12
  13   /* general information */
  14   if (name != NULL)
  15     sd_data->name = xbt_strdup(name);
  16   else
  17     sd_data->name = NULL;
  18
  19   sd_data->state = SD_NOT_SCHEDULED;
  20   sd_data->amount = amount;
  21   sd_data->surf_action = NULL;
  22   sd_data->watch_points = 0;
  23
  24   /* dependencies */
  25   sd_data->tasks_before = xbt_dynar_new(sizeof(SD_task_t), NULL);
  26   sd_data->tasks_after = xbt_dynar_new(sizeof(SD_task_t), NULL);
  27
  28   /* scheduling parameters */
  29   sd_data->workstation_nb = 0;
  30   sd_data->workstation_list = NULL;
  31   sd_data->computation_amount = NULL;
  32   sd_data->communication_amount = NULL;
  33   sd_data->rate = 0;
  34
  35   SD_task_t task = xbt_new0(s_SD_task_t, 1);
  36   task->sd_data = sd_data; /* private data */
  37   task->data = data; /* user data */
  38
  39   return task;
  40 }
  41
  42 /* Schedules a task.
  43  * task: the task to schedule
  44  * workstation_nb: number of workstations where the task will be executed
  45  * workstation_list: workstations where the task will be executed
  46  * computation_amount: computation amount for each workstation
  47  * communication_amount: communication amount between each pair of workstations
  48  * rate: task execution speed rate
  49  */
  50 void SD_task_schedule(SD_task_t task, int workstation_nb,
  51                      const SD_workstation_t *workstation_list, double *computation_amount,
  52                      double *communication_amount, double rate) {
  53   SD_CHECK_INIT_DONE();
  54   xbt_assert0(task, "Invalid parameter");
  55   xbt_assert0(SD_task_get_state(task) == SD_NOT_SCHEDULED, "This task has already been scheduled.");
  56   xbt_assert0(workstation_nb > 0, "workstation_nb must be positive");
  57
  58   SD_task_data_t sd_data = task->sd_data;
  59   sd_data->workstation_nb = workstation_nb;
  60   sd_data->rate = rate;
  61
  62   sd_data->computation_amount = xbt_new0(double, workstation_nb);
  63   memcpy(sd_data->computation_amount, computation_amount, sizeof(double) * workstation_nb);
  64
  65   int communication_nb = workstation_nb * workstation_nb;
  66   sd_data->communication_amount = xbt_new0(double, communication_nb);
  67   memcpy(sd_data->communication_amount, communication_amount, sizeof(double) * communication_nb);
  68
  69   /* we have to create a Surf workstation array instead of the SimDag workstation array */
  70   sd_data->workstation_list = xbt_new0(void*, workstation_nb);
  71   int i;
  72   for (i = 0; i < workstation_nb; i++) {
  73     sd_data->workstation_list[i] = workstation_list[i]->sd_data->surf_workstation;
  74   }
  75
  76   sd_data->state = SD_SCHEDULED;
  77 }
  78
  79 /* Returns the data of a task.
  80  */
  81 void* SD_task_get_data(SD_task_t task) {
  82   SD_CHECK_INIT_DONE();
  83   xbt_assert0(task, "Invalid parameter");
  84   return task->data;
  85 }
  86
  87 /* Sets the data of a task.
  88  */
  89 void SD_task_set_data(SD_task_t task, void *data) {
  90   SD_CHECK_INIT_DONE();
  91   xbt_assert0(task, "Invalid parameter");
  92   task->data = data;
  93 }
  94
  95 /* Returns the name of a task. The name can be NULL.
  96  */
  97 const char* SD_task_get_name(SD_task_t task) {
  98   SD_CHECK_INIT_DONE();
  99   xbt_assert0(task, "Invalid parameter");
 100   return task->sd_data->name;
 101 }
 102
 103 /* Returns the computing amount of a task.
 104  */
 105 double SD_task_get_amount(SD_task_t task) {
 106   SD_CHECK_INIT_DONE();
 107   xbt_assert0(task, "Invalid parameter");
 108   return task->sd_data->amount;
 109 }
 110
 111 /* Returns the remaining computing amount of a task.
 112  */
 113 double SD_task_get_remaining_amount(SD_task_t task) {
 114   SD_CHECK_INIT_DONE();
 115   xbt_assert0(task, "Invalid parameter");
 116   SD_task_data_t sd_data = task->sd_data;
 117   if (sd_data->surf_action)
 118     return sd_data->amount;
 119   else
 120     return sd_data->surf_action->remains;
 121 }
 122
 123 /* Adds a dependency between two tasks.
 124  */
 125 void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) {
 126   SD_CHECK_INIT_DONE();
 127   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 128   /* TODO */
 129 }
 130
 131 /* Removes a dependency between two tasks.
 132  */
 133 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
 134   SD_CHECK_INIT_DONE();
 135   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 136   /* TODO */
 137 }
 138
 139 /* Returns the state of a task: SD_NOT_SCHEDULED, SD_SCHEDULED, SD_RUNNING, SD_DONE or SD_FAILED.
 140  */
 141 SD_task_state_t SD_task_get_state(SD_task_t task) {
 142   SD_CHECK_INIT_DONE();
 143   xbt_assert0(task, "Invalid parameter");
 144   return task->sd_data->state;
 145 }
 146
 147 /* temporary function for debugging */
 148 void __SD_print_watch_points(SD_task_t task) {
 149   static const int state_masks[] = {SD_SCHEDULED, SD_RUNNING, SD_DONE, SD_FAILED};
 150   static const char* state_names[] = {"scheduled", "running", "done", "failed"};
 151
 152   printf("Task '%s' watch points (%x): ", task->sd_data->name, task->sd_data->watch_points);
 153
 154   int i;
 155   for (i = 0; i < 4; i++) {
 156     if (task->sd_data->watch_points & state_masks[i])
 157       printf("%s ", state_names[i]);
 158   }
 159   printf("\n");
 160 }
 161
 162 /* Adds a watch point to a task.
 163    SD_simulate will stop as soon as the state of this task is the one given in argument.
 164    Watch point is then automatically removed.
 165  */
 166 void SD_task_watch(SD_task_t task, SD_task_state_t state) {
 167   SD_CHECK_INIT_DONE();
 168   xbt_assert0(task, "Invalid parameter");
 169
 170   task->sd_data->watch_points = task->sd_data->watch_points | state;
 171   __SD_print_watch_points(task);
 172 }
 173
 174 /* Removes a watch point from a task.
 175  */
 176 void SD_task_unwatch(SD_task_t task, SD_task_state_t state) {
 177   SD_CHECK_INIT_DONE();
 178   xbt_assert0(task, "Invalid parameter");
 179
 180   task->sd_data->watch_points = task->sd_data->watch_points & ~state;
 181   __SD_print_watch_points(task);
 182 }
 183
 184 /* Unschedules a task. The state must be SD_SCHEDULED, SD_RUNNING or SD_FAILED.
 185  * The task is reinitialised and its state becomes SD_NOT_SCHEDULED.
 186  * Call SD_task_schedule to schedule it again.
 187  */
 188 void SD_task_unschedule(SD_task_t task) {
 189   SD_CHECK_INIT_DONE();
 190   xbt_assert0(task, "Invalid parameter");
 191   xbt_assert1(task->sd_data->state == SD_SCHEDULED ||
 192               task->sd_data->state == SD_RUNNING ||
 193               task->sd_data->state == SD_FAILED,
 194               "Task %s: the state must be SD_SCHEDULED, SD_RUNNING or SD_FAILED", task->sd_data->name);
 195
 196   if (task->sd_data->state == SD_SCHEDULED)
 197     __SD_task_destroy_scheduling_data(task);
 198
 199   task->sd_data->state = SD_NOT_SCHEDULED;
 200 }
 201
 202 /* Runs a task. This function is called by SD_simulate when a scheduled task can start
 203  * (ie when its dependencies are satisfied).
 204  */
 205 void __SD_task_run(SD_task_t task) {
 206   SD_CHECK_INIT_DONE();
 207   xbt_assert0(task, "Invalid parameter");
 208
 209   SD_task_data_t sd_data = task->sd_data;
 210   surf_workstation_resource->extension_public->
 211     execute_parallel_task(sd_data->workstation_nb,
 212                           sd_data->workstation_list,
 213                           sd_data->computation_amount,
 214                           sd_data->communication_amount,
 215                           sd_data->amount,
 216                           sd_data->rate);
 217   task->sd_data->state = SD_RUNNING;
 218
 219   __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
 220 }
 221
 222
 223 /* Destroys a task. The user data (if any) should have been destroyed first.
 224  */
 225 void SD_task_destroy(SD_task_t task) {
 226   SD_CHECK_INIT_DONE();
 227   xbt_assert0(task, "Invalid parameter");
 228
 229   if (task->sd_data->state == SD_SCHEDULED)
 230     __SD_task_destroy_scheduling_data(task);
 231
 232   if (task->sd_data->name != NULL)
 233     xbt_free(task->sd_data->name);
 234
 235   xbt_dynar_free(&task->sd_data->tasks_before);
 236   xbt_dynar_free(&task->sd_data->tasks_after);
 237   xbt_free(task->sd_data);
 238   xbt_free(task);
 239 }
 240
 241 /* Destroys the data memorised by SD_task_schedule. Task state must be SD_SCHEDULED.
 242  */
 243 void __SD_task_destroy_scheduling_data(SD_task_t task) {
 244   xbt_free(task->sd_data->workstation_list);
 245   xbt_free(task->sd_data->computation_amount);
 246   xbt_free(task->sd_data->communication_amount);
 247 }