+ if (__SD_task_is_scheduled_or_runnable(task) /* if the task is scheduled or runnable */
+ && ((task->kind == SD_TASK_COMP_PAR_AMDAHL) ||
+ (task->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK))) { /* Don't free scheduling data for typed tasks */
+ __SD_task_destroy_scheduling_data(task);
+ xbt_free(task->workstation_list);
+ task->workstation_list=NULL;
+ task->workstation_nb = 0;
+ }
+
+ if (__SD_task_is_running(task)) /* the task should become SD_FAILED */
+ surf_workstation_model->action_cancel(task->surf_action);
+ else {
+ if (task->unsatisfied_dependencies == 0)
+ __SD_task_set_state(task, SD_SCHEDULABLE);
+ else
+ __SD_task_set_state(task, SD_NOT_SCHEDULED);
+ }
+ task->remains = task->amount;
+ task->start_time = -1.0;
+}
+
+/* Destroys the data memorized by SD_task_schedule.
+ * Task state must be SD_SCHEDULED or SD_RUNNABLE.
+ */
+static void __SD_task_destroy_scheduling_data(SD_task_t task)
+{
+ if (!__SD_task_is_scheduled_or_runnable(task)
+ && !__SD_task_is_in_fifo(task))
+ THROWF(arg_error, 0,
+ "Task '%s' must be SD_SCHEDULED, SD_RUNNABLE or SD_IN_FIFO",
+ SD_task_get_name(task));
+
+ xbt_free(task->computation_amount);
+ xbt_free(task->communication_amount);
+ task->computation_amount = task->communication_amount = NULL;
+}
+
+/* Runs a task. This function is directly called by __SD_task_try_to_run if
+ * the task doesn't have to wait in FIFOs. Otherwise, it is called by
+ * __SD_task_just_done when the task gets out of its FIFOs.
+ */
+void __SD_task_really_run(SD_task_t task)
+{
+
+ int i;
+ void **surf_workstations;
+
+ xbt_assert(__SD_task_is_runnable_or_in_fifo(task),
+ "Task '%s' is not runnable or in a fifo! Task state: %d",
+ SD_task_get_name(task), (int)SD_task_get_state(task));
+ xbt_assert(task->workstation_list != NULL,
+ "Task '%s': workstation_list is NULL!",
+ SD_task_get_name(task));
+
+ XBT_DEBUG("Really running task '%s'", SD_task_get_name(task));
+ int workstation_nb = task->workstation_nb;
+
+ /* set this task as current task for the workstations in sequential mode */
+ for (i = 0; i < workstation_nb; i++) {
+ if (SD_workstation_get_access_mode(task->workstation_list[i]) ==
+ SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ SD_workstation_priv(task->workstation_list[i])->current_task = task;
+ xbt_assert(__SD_workstation_is_busy(task->workstation_list[i]),
+ "The workstation should be busy now");
+ }
+ }
+
+ XBT_DEBUG("Task '%s' set as current task for its workstations",
+ SD_task_get_name(task));
+
+ /* start the task */
+
+ /* we have to create a Surf workstation array instead of the SimDag
+ * workstation array */
+ surf_workstations = xbt_new(void *, workstation_nb);
+
+ for (i = 0; i < workstation_nb; i++)
+ surf_workstations[i] = task->workstation_list[i];
+
+ double *computation_amount = xbt_new0(double, workstation_nb);
+ double *communication_amount = xbt_new0(double, workstation_nb * workstation_nb);
+
+
+ if(task->computation_amount)
+ memcpy(computation_amount, task->computation_amount, sizeof(double) *
+ workstation_nb);
+ if(task->communication_amount)
+ memcpy(communication_amount, task->communication_amount,
+ sizeof(double) * workstation_nb * workstation_nb);
+
+ task->surf_action =
+ surf_workstation_model->extension.
+ workstation.execute_parallel_task(workstation_nb,
+ surf_workstations,
+ computation_amount,
+ communication_amount,
+ task->rate);
+
+ surf_workstation_model->action_data_set(task->surf_action, task);
+
+ XBT_DEBUG("surf_action = %p", task->surf_action);
+
+#ifdef HAVE_TRACING
+ if (task->category)
+ TRACE_surf_action(task->surf_action, task->category);
+#endif
+
+ __SD_task_destroy_scheduling_data(task); /* now the scheduling data are not useful anymore */
+ __SD_task_set_state(task, SD_RUNNING);
+ xbt_assert(__SD_task_is_running(task), "Bad state of task '%s': %d",
+ SD_task_get_name(task), (int)SD_task_get_state(task));
+
+}
+
+/* Tries to run a task. This function is called by SD_simulate() when a
+ * scheduled task becomes SD_RUNNABLE (i.e., when its dependencies are
+ * satisfied).
+ * If one of the workstations where the task is scheduled on is busy (in
+ * sequential mode), the task doesn't start.
+ * Returns whether the task has started.
+ */
+int __SD_task_try_to_run(SD_task_t task)
+{
+
+ int can_start = 1;
+ int i;
+ SD_workstation_t workstation;
+
+ xbt_assert(__SD_task_is_runnable(task),
+ "Task '%s' is not runnable! Task state: %d",
+ SD_task_get_name(task), (int)SD_task_get_state(task));
+
+
+ for (i = 0; i < task->workstation_nb; i++) {
+ can_start = can_start &&
+ !__SD_workstation_is_busy(task->workstation_list[i]);
+ }
+
+ XBT_DEBUG("Task '%s' can start: %d", SD_task_get_name(task), can_start);
+
+ if (!can_start) { /* if the task cannot start and is not in the FIFOs yet */
+ for (i = 0; i < task->workstation_nb; i++) {
+ workstation = task->workstation_list[i];
+ if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ XBT_DEBUG("Pushing task '%s' in the FIFO of workstation '%s'",
+ SD_task_get_name(task),
+ SD_workstation_get_name(workstation));
+ xbt_fifo_push(SD_workstation_priv(workstation)->task_fifo, task);
+ }
+ }
+ __SD_task_set_state(task, SD_IN_FIFO);
+ xbt_assert(__SD_task_is_in_fifo(task), "Bad state of task '%s': %d",
+ SD_task_get_name(task), (int)SD_task_get_state(task));
+ XBT_DEBUG("Task '%s' state is now SD_IN_FIFO", SD_task_get_name(task));
+ } else {
+ __SD_task_really_run(task);
+ }
+
+ return can_start;
+}
+
+/* This function is called by SD_simulate when a task is done.
+ * It updates task->state and task->action and executes if necessary the tasks
+ * which were waiting in FIFOs for the end of `task'
+ */
+void __SD_task_just_done(SD_task_t task)
+{
+ int i, j;
+ SD_workstation_t workstation;
+
+ SD_task_t candidate;
+ int candidate_nb = 0;
+ int candidate_capacity = 8;
+ SD_task_t *candidates;
+ int can_start = 1;
+
+ xbt_assert(__SD_task_is_running(task),
+ "The task must be running! Task state: %d",
+ (int)SD_task_get_state(task));
+ xbt_assert(task->workstation_list != NULL,
+ "Task '%s': workstation_list is NULL!",
+ SD_task_get_name(task));
+
+
+ candidates = xbt_new(SD_task_t, 8);
+
+ __SD_task_set_state(task, SD_DONE);
+ surf_workstation_model->action_unref(task->surf_action);
+ task->surf_action = NULL;
+
+ XBT_DEBUG("Looking for candidates");
+
+ /* if the task was executed on sequential workstations,
+ maybe we can execute the next task of the FIFO for each workstation */
+ for (i = 0; i < task->workstation_nb; i++) {
+ workstation = task->workstation_list[i];
+ XBT_DEBUG("Workstation '%s': access_mode = %d",
+ SD_workstation_get_name(workstation), (int)SD_workstation_priv(workstation)->access_mode);
+ if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ xbt_assert(SD_workstation_priv(workstation)->task_fifo != NULL,
+ "Workstation '%s' has sequential access but no FIFO!",
+ SD_workstation_get_name(workstation));
+ xbt_assert(SD_workstation_priv(workstation)->current_task =
+ task, "Workstation '%s': current task should be '%s'",
+ SD_workstation_get_name(workstation),
+ SD_task_get_name(task));
+
+ /* the task is over so we can release the workstation */
+ SD_workstation_priv(workstation)->current_task = NULL;
+
+ XBT_DEBUG("Getting candidate in FIFO");
+ candidate =
+ xbt_fifo_get_item_content(xbt_fifo_get_first_item
+ (SD_workstation_priv(workstation)->task_fifo));
+
+ if (candidate != NULL) {
+ XBT_DEBUG("Candidate: '%s'", SD_task_get_name(candidate));
+ xbt_assert(__SD_task_is_in_fifo(candidate),
+ "Bad state of candidate '%s': %d",
+ SD_task_get_name(candidate),
+ (int)SD_task_get_state(candidate));
+ }
+
+ XBT_DEBUG("Candidate in fifo: %p", candidate);
+
+ /* if there was a task waiting for my place */
+ if (candidate != NULL) {
+ /* Unfortunately, we are not sure yet that we can execute the task now,
+ because the task can be waiting more deeply in some other
+ workstation's FIFOs ...
+ So we memorize all candidate tasks, and then we will check for each
+ candidate whether or not all its workstations are available. */
+
+ /* realloc if necessary */
+ if (candidate_nb == candidate_capacity) {
+ candidate_capacity *= 2;
+ candidates =
+ xbt_realloc(candidates,
+ sizeof(SD_task_t) * candidate_capacity);
+ }
+
+ /* register the candidate */
+ candidates[candidate_nb++] = candidate;
+ candidate->fifo_checked = 0;
+ }
+ }
+ }
+
+ XBT_DEBUG("Candidates found: %d", candidate_nb);
+
+ /* now we check every candidate task */
+ for (i = 0; i < candidate_nb; i++) {
+ candidate = candidates[i];
+
+ if (candidate->fifo_checked) {
+ continue; /* we have already evaluated that task */
+ }
+
+ xbt_assert(__SD_task_is_in_fifo(candidate),
+ "Bad state of candidate '%s': %d",
+ SD_task_get_name(candidate), (int)SD_task_get_state(candidate));
+
+ for (j = 0; j < candidate->workstation_nb && can_start; j++) {
+ workstation = candidate->workstation_list[j];
+
+ /* I can start on this workstation if the workstation is shared
+ or if I am the first task in the FIFO */
+ can_start = SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SHARED_ACCESS
+ || candidate ==
+ xbt_fifo_get_item_content(xbt_fifo_get_first_item
+ (SD_workstation_priv(workstation)->task_fifo));
+ }
+
+ XBT_DEBUG("Candidate '%s' can start: %d", SD_task_get_name(candidate),
+ can_start);
+
+ /* now we are sure that I can start! */
+ if (can_start) {
+ for (j = 0; j < candidate->workstation_nb && can_start; j++) {
+ workstation = candidate->workstation_list[j];
+
+ /* update the FIFO */
+ if (SD_workstation_priv(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
+ candidate = xbt_fifo_shift(SD_workstation_priv(workstation)->task_fifo); /* the return value is stored just for debugging */
+ XBT_DEBUG("Head of the FIFO: '%s'",
+ (candidate !=
+ NULL) ? SD_task_get_name(candidate) : "NULL");
+ xbt_assert(candidate == candidates[i],
+ "Error in __SD_task_just_done: bad first task in the FIFO");
+ }
+ } /* for each workstation */
+
+ /* finally execute the task */
+ XBT_DEBUG("Task '%s' state: %d", SD_task_get_name(candidate),
+ (int)SD_task_get_state(candidate));
+ __SD_task_really_run(candidate);
+
+ XBT_DEBUG
+ ("Calling __SD_task_is_running: task '%s', state set: %p, running_task_set: %p, is running: %d",
+ SD_task_get_name(candidate), candidate->state_set,
+ sd_global->running_task_set, __SD_task_is_running(candidate));
+ xbt_assert(__SD_task_is_running(candidate),
+ "Bad state of task '%s': %d",
+ SD_task_get_name(candidate),
+ (int)SD_task_get_state(candidate));
+ XBT_DEBUG("Okay, the task is running.");
+
+ } /* can start */
+ candidate->fifo_checked = 1;
+ } /* for each candidate */
+
+ xbt_free(candidates);
+}
+
+/*
+ * Remove all dependencies associated with a task. This function is called
+ * when the task is destroyed.
+ */
+static void __SD_task_remove_dependencies(SD_task_t task)
+{
+ /* we must destroy the dependencies carefuly (with SD_dependency_remove)
+ because each one is stored twice */
+ SD_dependency_t dependency;
+ while (!xbt_dynar_is_empty(task->tasks_before)) {
+ xbt_dynar_get_cpy(task->tasks_before, 0, &dependency);
+ SD_task_dependency_remove(dependency->src, dependency->dst);
+ }
+
+ while (!xbt_dynar_is_empty(task->tasks_after)) {
+ xbt_dynar_get_cpy(task->tasks_after, 0, &dependency);
+ SD_task_dependency_remove(dependency->src, dependency->dst);
+ }
+}
+
+/**
+ * \brief Returns the start time of a task
+ *
+ * The task state must be SD_RUNNING, SD_DONE or SD_FAILED.
+ *
+ * \param task: a task
+ * \return the start time of this task
+ */
+double SD_task_get_start_time(SD_task_t task)
+{
+ if (task->surf_action)
+ return surf_workstation_model->
+ action_get_start_time(task->surf_action);
+ else
+ return task->start_time;
+}
+
+/**
+ * \brief Returns the finish time of a task
+ *
+ * The task state must be SD_RUNNING, SD_DONE or SD_FAILED.
+ * If the state is not completed yet, the returned value is an
+ * estimation of the task finish time. This value can fluctuate
+ * until the task is completed.
+ *
+ * \param task: a task
+ * \return the start time of this task
+ */
+double SD_task_get_finish_time(SD_task_t task)
+{
+ if (task->surf_action) /* should never happen as actions are destroyed right after their completion */
+ return surf_workstation_model->
+ action_get_finish_time(task->surf_action);
+ else
+ return task->finish_time;
+}
+/** @brief Blah
+ *
+ */
+void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count)
+{
+ int i;
+ xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL,
+ "Task %s is not a SD_TASK_COMP_PAR_AMDAHL typed task."
+ "Cannot use this function.",
+ SD_task_get_name(task));
+ task->computation_amount = xbt_new0(double, ws_count);
+ task->communication_amount = xbt_new0(double, ws_count * ws_count);
+ xbt_free(task->workstation_list);
+ task->workstation_nb = ws_count;
+ task->workstation_list = xbt_new0(SD_workstation_t, ws_count);
+
+ for(i=0;i<ws_count;i++){
+ task->computation_amount[i] =
+ (task->alpha + (1 - task->alpha)/ws_count) * task->amount;
+ }
+}
+
+
+/** @brief Auto-schedules a task.
+ *
+ * Auto-scheduling mean that the task can be used with SD_task_schedulev(). This
+ * allows to specify the task costs at creation, and decouple them from the
+ * scheduling process where you just specify which resource should deliver the
+ * mandatory power.
+ *
+ * To be auto-schedulable, a task must be created with SD_task_create_comm_e2e()
+ * or SD_task_create_comp_seq(). Check their definitions for the exact semantic
+ * of each of them.
+ *
+ * @todo
+ * We should create tasks kind for the following categories:
+ * - Point to point communication (done)
+ * - Sequential computation (done)
+ * - group communication (redistribution, several kinds)
+ * - parallel tasks with no internal communication (one kind per speedup
+ * model such as Amdahl)
+ * - idem+ internal communication. Task type not enough since we cannot store
+ * comm cost alongside to comp one)
+ */
+void SD_task_schedulev(SD_task_t task, int count,
+ const SD_workstation_t * list)
+{
+ int i, j;
+ SD_dependency_t dep;
+ unsigned int cpt;
+ xbt_assert(task->kind != 0,
+ "Task %s is not typed. Cannot automatically schedule it.",
+ SD_task_get_name(task));
+ switch (task->kind) {
+ case SD_TASK_COMP_PAR_AMDAHL:
+ SD_task_distribute_comp_amdahl(task, count);
+ case SD_TASK_COMM_E2E:
+ case SD_TASK_COMP_SEQ:
+ xbt_assert(task->workstation_nb == count,
+ "Got %d locations, but were expecting %d locations",
+ count,task->workstation_nb);
+ for (i = 0; i < count; i++)
+ task->workstation_list[i] = list[i];
+ if (SD_task_get_kind(task)== SD_TASK_COMP_SEQ && !task->computation_amount){
+ /*This task has failed and is rescheduled. Reset the computation amount*/
+ task->computation_amount = xbt_new0(double, 1);
+ task->computation_amount[0] = task->remains;
+ }
+ SD_task_do_schedule(task);
+ break;
+ default:
+ xbt_die("Kind of task %s not supported by SD_task_schedulev()",
+ SD_task_get_name(task));
+ }
+ if (task->kind == SD_TASK_COMM_E2E) {
+ XBT_VERB("Schedule comm task %s between %s -> %s. It costs %.f bytes",
+ SD_task_get_name(task),
+ SD_workstation_get_name(task->workstation_list[0]),
+ SD_workstation_get_name(task->workstation_list[1]),
+ task->communication_amount[2]);
+
+ }
+
+ /* Iterate over all children and parents being COMM_E2E to say where I am
+ * located (and start them if runnable) */
+ if (task->kind == SD_TASK_COMP_SEQ) {
+ XBT_VERB("Schedule computation task %s on %s. It costs %.f flops",
+ SD_task_get_name(task),
+ SD_workstation_get_name(task->workstation_list[0]),
+ task->computation_amount[0]);
+
+ xbt_dynar_foreach(task->tasks_before, cpt, dep) {
+ SD_task_t before = dep->src;
+ if (before->kind == SD_TASK_COMM_E2E) {
+ before->workstation_list[1] = task->workstation_list[0];
+
+ if (before->workstation_list[0] &&
+ (__SD_task_is_schedulable(before)
+ || __SD_task_is_not_scheduled(before))) {
+ SD_task_do_schedule(before);
+ XBT_VERB
+ ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
+ SD_task_get_name(before),
+ SD_workstation_get_name(before->workstation_list[0]),
+ SD_workstation_get_name(before->workstation_list[1]),
+ before->communication_amount[2]);
+ }
+ }
+ }
+ xbt_dynar_foreach(task->tasks_after, cpt, dep) {
+ SD_task_t after = dep->dst;
+ if (after->kind == SD_TASK_COMM_E2E) {
+ after->workstation_list[0] = task->workstation_list[0];
+ if (after->workstation_list[1]
+ && (__SD_task_is_not_scheduled(after)
+ || __SD_task_is_schedulable(after))) {
+ SD_task_do_schedule(after);
+ XBT_VERB
+ ("Auto-Schedule comm task %s between %s -> %s. It costs %.f bytes",
+ SD_task_get_name(after),
+ SD_workstation_get_name(after->workstation_list[0]),
+ SD_workstation_get_name(after->workstation_list[1]),
+ after->communication_amount[2]);
+
+ }
+ }
+ }
+ }
+ /* Iterate over all children and parents being MXN_1D_BLOCK to say where I am
+ * located (and start them if runnable) */
+ if (task->kind == SD_TASK_COMP_PAR_AMDAHL) {
+ XBT_VERB("Schedule computation task %s on %d workstations. %.f flops"
+ " will be distributed following Amdahl's Law",
+ SD_task_get_name(task), task->workstation_nb,
+ task->computation_amount[0]);
+ xbt_dynar_foreach(task->tasks_before, cpt, dep) {
+ SD_task_t before = dep->src;
+ if (before->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
+ if (!before->workstation_list){
+ XBT_VERB("Sender side of Task %s is not scheduled yet",
+ SD_task_get_name(before));
+ before->workstation_list = xbt_new0(SD_workstation_t, count);
+ before->workstation_nb = count;
+ XBT_VERB("Fill the workstation list with list of Task '%s'",
+ SD_task_get_name(task));
+ for (i=0;i<count;i++)
+ before->workstation_list[i] = task->workstation_list[i];
+ } else {
+ XBT_VERB("Build communication matrix for task '%s'",
+ SD_task_get_name(before));
+ int src_nb, dst_nb;
+ double src_start, src_end, dst_start, dst_end;
+ src_nb = before->workstation_nb;
+ dst_nb = count;
+ before->workstation_list = (SD_workstation_t*) xbt_realloc(
+ before->workstation_list,
+ (before->workstation_nb+count)*sizeof(s_SD_workstation_t));
+ for(i=0; i<count; i++)
+ before->workstation_list[before->workstation_nb+i] =
+ task->workstation_list[i];
+
+ before->workstation_nb += count;
+ xbt_free(before->computation_amount);
+ xbt_free(before->communication_amount);
+ before->computation_amount = xbt_new0(double,
+ before->workstation_nb);
+ before->communication_amount = xbt_new0(double,
+ before->workstation_nb*
+ before->workstation_nb);
+
+ for(i=0;i<src_nb;i++){
+ src_start = i*before->amount/src_nb;
+ src_end = src_start + before->amount/src_nb;
+ for(j=0; j<dst_nb; j++){
+ dst_start = j*before->amount/dst_nb;
+ dst_end = dst_start + before->amount/dst_nb;
+ XBT_VERB("(%s->%s): (%.2f, %.2f)-> (%.2f, %.2f)",
+ SD_workstation_get_name(before->workstation_list[i]),
+ SD_workstation_get_name(before->workstation_list[src_nb+j]),
+ src_start, src_end, dst_start, dst_end);
+ if ((src_end <= dst_start) || (dst_end <= src_start)) {
+ before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+ } else {
+ before->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+ MIN(src_end, dst_end) - MAX(src_start, dst_start);
+ }
+ XBT_VERB("==> %.2f",
+ before->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+ }
+ }
+
+ if (__SD_task_is_schedulable(before) ||
+ __SD_task_is_not_scheduled(before)) {
+ SD_task_do_schedule(before);
+ XBT_VERB
+ ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",
+ SD_task_get_name(before),before->amount, src_nb, dst_nb);
+ }
+ }
+ }
+ }
+ xbt_dynar_foreach(task->tasks_after, cpt, dep) {
+ SD_task_t after = dep->dst;
+ if (after->kind == SD_TASK_COMM_PAR_MXN_1D_BLOCK){
+ if (!after->workstation_list){
+ XBT_VERB("Receiver side of Task '%s' is not scheduled yet",
+ SD_task_get_name(after));
+ after->workstation_list = xbt_new0(SD_workstation_t, count);
+ after->workstation_nb = count;
+ XBT_VERB("Fill the workstation list with list of Task '%s'",
+ SD_task_get_name(task));
+ for (i=0;i<count;i++)
+ after->workstation_list[i] = task->workstation_list[i];
+ } else {
+ int src_nb, dst_nb;
+ double src_start, src_end, dst_start, dst_end;
+ src_nb = count;
+ dst_nb = after->workstation_nb;
+ after->workstation_list = (SD_workstation_t*) xbt_realloc(
+ after->workstation_list,
+ (after->workstation_nb+count)*sizeof(s_SD_workstation_t));
+ for(i=after->workstation_nb - 1; i>=0; i--)
+ after->workstation_list[count+i] = after->workstation_list[i];
+ for(i=0; i<count; i++)
+ after->workstation_list[i] = task->workstation_list[i];
+
+ after->workstation_nb += count;
+
+ xbt_free(after->computation_amount);
+ xbt_free(after->communication_amount);
+
+ after->computation_amount = xbt_new0(double, after->workstation_nb);
+ after->communication_amount = xbt_new0(double,
+ after->workstation_nb*
+ after->workstation_nb);
+
+ for(i=0;i<src_nb;i++){
+ src_start = i*after->amount/src_nb;
+ src_end = src_start + after->amount/src_nb;
+ for(j=0; j<dst_nb; j++){
+ dst_start = j*after->amount/dst_nb;
+ dst_end = dst_start + after->amount/dst_nb;
+ XBT_VERB("(%d->%d): (%.2f, %.2f)-> (%.2f, %.2f)",
+ i, j, src_start, src_end, dst_start, dst_end);
+ if ((src_end <= dst_start) || (dst_end <= src_start)) {
+ after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]=0.0;
+ } else {
+ after->communication_amount[i*(src_nb+dst_nb)+src_nb+j] =
+ MIN(src_end, dst_end)- MAX(src_start, dst_start);
+ }
+ XBT_VERB("==> %.2f",
+ after->communication_amount[i*(src_nb+dst_nb)+src_nb+j]);
+ }
+ }
+
+ if (__SD_task_is_schedulable(after) ||
+ __SD_task_is_not_scheduled(after)) {
+ SD_task_do_schedule(after);
+ XBT_VERB
+ ("Auto-Schedule redistribution task %s. Send %.f bytes from %d hosts to %d hosts.",
+ SD_task_get_name(after),after->amount, src_nb, dst_nb);
+ }
+ }
+ }
+ }
+ }
+}
+
+/** @brief autoschedule a task on a list of workstations
+ *
+ * This function is very similar to SD_task_schedulev(),
+ * but takes the list of workstations to schedule onto as separate parameters.
+ * It builds a proper vector of workstations and then call SD_task_schedulev()
+ */
+void SD_task_schedulel(SD_task_t task, int count, ...)
+{
+ va_list ap;
+ SD_workstation_t *list = xbt_new(SD_workstation_t, count);
+ int i;
+ va_start(ap, count);
+ for (i = 0; i < count; i++) {
+ list[i] = va_arg(ap, SD_workstation_t);
+ }
+ va_end(ap);
+ SD_task_schedulev(task, count, list);
+ free(list);