Beispiel #1
0
 xbt_dynar_foreach(dax, cursor, task) {
   int kind = SD_task_get_kind(task);
   SD_workstation_t *wsl = SD_task_get_workstation_list(task);
   switch (kind) {
   case SD_TASK_COMP_SEQ:
     fprintf(out, "[%f] %s compute %f # %s\n",
             SD_task_get_start_time(task),
             SD_workstation_get_name(wsl[0]), SD_task_get_amount(task),
             SD_task_get_name(task));
     break;
   case SD_TASK_COMM_E2E:
     fprintf(out, "[%f] %s send %s %f # %s\n",
             SD_task_get_start_time(task),
             SD_workstation_get_name(wsl[0]),
             SD_workstation_get_name(wsl[1]), SD_task_get_amount(task),
             SD_task_get_name(task));
     fprintf(out, "[%f] %s recv %s %f # %s\n",
             SD_task_get_finish_time(task),
             SD_workstation_get_name(wsl[1]),
             SD_workstation_get_name(wsl[0]), SD_task_get_amount(task),
             SD_task_get_name(task));
     break;
   default:
     xbt_die("Task %s is of unknown kind %d", SD_task_get_name(task),
             SD_task_get_kind(task));
   }
   SD_task_destroy(task);
 }
static double finish_on_at(SD_task_t task, sg_host_t host)
{
  double result;
  unsigned int i;
  double data_available = 0.;
  double redist_time = 0;
  double last_data_available;

  xbt_dynar_t parents = SD_task_get_parents(task);

  if (!xbt_dynar_is_empty(parents)) {
    /* compute last_data_available */
    SD_task_t parent;
    last_data_available = -1.0;
    xbt_dynar_foreach(parents, i, parent) {
      /* normal case */
      if (SD_task_get_kind(parent) == SD_TASK_COMM_E2E) {
        xbt_dynar_t grand_parents = SD_task_get_parents(parent);
        SD_task_t grand_parent;

        xbt_assert(xbt_dynar_length(grand_parents) <2, "Error: transfer %s has 2 parents", SD_task_get_name(parent));

        xbt_dynar_get_cpy(grand_parents, 0, &grand_parent);

        sg_host_t * grand_parent_host_list = SD_task_get_workstation_list(grand_parent);
        /* Estimate the redistribution time from this parent */
        if (SD_task_get_amount(parent) <= 1e-6){
          redist_time= 0;
        } else {
          redist_time = SD_route_get_latency(grand_parent_host_list[0], host) +
                        SD_task_get_amount(parent) / SD_route_get_bandwidth(grand_parent_host_list[0], host);
        }
        data_available = SD_task_get_finish_time(grand_parent) + redist_time;

        xbt_dynar_free_container(&grand_parents);
      }

      /* no transfer, control dependency */
      if (SD_task_get_kind(parent) == SD_TASK_COMP_SEQ) {
        data_available = SD_task_get_finish_time(parent);
      }

      if (last_data_available < data_available)
        last_data_available = data_available;
    }

    xbt_dynar_free_container(&parents);

    result = MAX(sg_host_get_available_at(host), last_data_available) + SD_task_get_amount(task)/sg_host_speed(host);
  } else {
Beispiel #3
0
 xbt_dynar_foreach(dot, cursor, task) {
   int kind = SD_task_get_kind(task);
   sg_host_t *wsl = SD_task_get_workstation_list(task);
   switch (kind) {
   case SD_TASK_COMP_SEQ:
     fprintf(out, "[%f->%f] %s compute %f flops # %s\n",
         SD_task_get_start_time(task), SD_task_get_finish_time(task),
         sg_host_get_name(wsl[0]), SD_task_get_amount(task), SD_task_get_name(task));
     break;
   case SD_TASK_COMM_E2E:
     fprintf(out, "[%f -> %f] %s -> %s transfer of %.0f bytes # %s\n",
         SD_task_get_start_time(task), SD_task_get_finish_time(task),
         sg_host_get_name(wsl[0]), sg_host_get_name(wsl[1]), SD_task_get_amount(task), SD_task_get_name(task));
     break;
   default:
     xbt_die("Task %s is of unknown kind %d", SD_task_get_name(task), SD_task_get_kind(task));
   }
   SD_task_destroy(task);
 }