src/surf/workstation_ptask_L07.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2007 Arnaud Legrand. All rights reserved.                  */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "xbt/ex.h"
   9 #include "xbt/dict.h"
  10 #include "surf_private.h"
  11
  12 typedef enum {
  13   SURF_WORKSTATION_RESOURCE_CPU,
  14   SURF_WORKSTATION_RESOURCE_LINK,
  15 } e_surf_workstation_resource_type_t;
  16
  17 /**************************************/
  18 /********* cpu object *****************/
  19 /**************************************/
  20 typedef struct cpu_L07 {
  21   surf_resource_t resource;                     /* Do not move this field */
  22   e_surf_workstation_resource_type_t type;      /* Do not move this field */
  23   char *name;                                   /* Do not move this field */
  24   lmm_constraint_t constraint;                  /* Do not move this field */
  25   double power_scale;
  26   double power_current;
  27   tmgr_trace_event_t power_event;
  28   e_surf_cpu_state_t state_current;
  29   tmgr_trace_event_t state_event;
  30   int id;                       /* cpu and network card are a single object... */
  31 } s_cpu_L07_t, *cpu_L07_t;
  32
  33 /**************************************/
  34 /*********** network object ***********/
  35 /**************************************/
  36
  37 typedef struct network_link_L07 {
  38   surf_resource_t resource;                     /* Do not move this field */
  39   e_surf_workstation_resource_type_t type;      /* Do not move this field */
  40   char *name;                                   /* Do not move this field */
  41   lmm_constraint_t constraint;                  /* Do not move this field */
  42   double bw_current;
  43   tmgr_trace_event_t bw_event;
  44   e_surf_network_link_state_t state_current;
  45   tmgr_trace_event_t state_event;
  46 } s_network_link_L07_t, *network_link_L07_t;
  47
  48
  49 typedef struct s_route_L07 {
  50   network_link_L07_t *links;
  51   int size;
  52 } s_route_L07_t, *route_L07_t;
  53
  54 /**************************************/
  55 /*************** actions **************/
  56 /**************************************/
  57 typedef struct surf_action_workstation_L07 {
  58   s_surf_action_t generic_action;
  59   lmm_variable_t variable;
  60   double rate;
  61   int suspended;
  62 } s_surf_action_workstation_L07_t,
  63   *surf_action_workstation_L07_t;
  64
  65
  66 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_workstation);
  67
  68 static int nb_workstation = 0;
  69 static s_route_L07_t *routing_table = NULL;
  70 #define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation]
  71 static xbt_dict_t parallel_task_network_link_set = NULL;
  72 lmm_system_t ptask_maxmin_system = NULL;
  73
  74 /**************************************/
  75 /******* Resource Public     **********/
  76 /**************************************/
  77
  78 static void *name_service(const char *name)
  79 {
  80   return xbt_dict_get_or_null(workstation_set, name);
  81 }
  82
  83 static const char *get_resource_name(void *resource_id)
  84 {
  85   /* We can freely cast as a cpu_L07_t because it has the same
  86      prefix as network_link_L07_t. However, only cpu_L07_t
  87      will theoretically be given as an argument here. */
  88   return ((cpu_L07_t) resource_id)->name;
  89 }
  90
  91 /* action_get_state is inherited from the surf module */
  92
  93 static void action_use(surf_action_t action)
  94 {
  95   action->using++;
  96   return;
  97 }
  98
  99 static int action_free(surf_action_t action)
 100 {
 101   action->using--;
 102
 103   if (!action->using) {
 104     xbt_swag_remove(action, action->state_set);
 105     if (((surf_action_workstation_L07_t) action)->variable)
 106       lmm_variable_free(ptask_maxmin_system,
 107                         ((surf_action_workstation_L07_t) action)->
 108                         variable);
 109     free(action);
 110     return 1;
 111   }
 112   return 0;
 113 }
 114
 115 static void action_cancel(surf_action_t action)
 116 {
 117   surf_action_change_state(action, SURF_ACTION_FAILED);
 118   return;
 119 }
 120
 121 static void action_recycle(surf_action_t action)
 122 {
 123   DIE_IMPOSSIBLE;
 124   return;
 125 }
 126
 127 /* action_change_state is inherited from the surf module */
 128 /* action_set_data is inherited from the surf module */
 129
 130 static void action_suspend(surf_action_t action)
 131 {
 132   XBT_IN1("(%p))",action);
 133   if(((surf_action_workstation_L07_t) action)->suspended != 2) {
 134     ((surf_action_workstation_L07_t) action)->suspended = 1;
 135     lmm_update_variable_weight(ptask_maxmin_system,
 136                                ((surf_action_workstation_L07_t)
 137                                 action)->variable, 0.0);
 138   }
 139   XBT_OUT;
 140 }
 141
 142 static void action_resume(surf_action_t action)
 143 {
 144   XBT_IN1("(%p)",action);
 145   if(((surf_action_workstation_L07_t) action)->suspended !=2) {
 146     lmm_update_variable_weight(ptask_maxmin_system,
 147                                ((surf_action_workstation_L07_t)
 148                                 action)->variable, 1.0);
 149     ((surf_action_workstation_L07_t) action)->suspended = 0;
 150   }
 151   XBT_OUT;
 152 }
 153
 154 static int action_is_suspended(surf_action_t action)
 155 {
 156   return (((surf_action_workstation_L07_t) action)->suspended==1);
 157 }
 158
 159 static void action_set_max_duration(surf_action_t action, double duration)
 160 {                               /* FIXME: should inherit */
 161   XBT_IN2("(%p,%g)",action,duration);
 162   action->max_duration = duration;
 163   XBT_OUT;
 164 }
 165
 166
 167 static void action_set_priority(surf_action_t action, double priority)
 168 {                               /* FIXME: should inherit */
 169   XBT_IN2("(%p,%g)",action,priority);
 170   action->priority = priority;
 171   XBT_OUT;
 172 }
 173
 174 /**************************************/
 175 /******* Resource Private    **********/
 176 /**************************************/
 177
 178 static int resource_used(void *resource_id)
 179 {
 180   /* We can freely cast as a network_link_L07_t because it has
 181      the same prefix as cpu_L07_t */
 182   return lmm_constraint_used(ptask_maxmin_system,
 183                              ((network_link_L07_t) resource_id)->
 184                              constraint);
 185
 186 }
 187
 188 static double share_resources(double now)
 189 {
 190   s_surf_action_workstation_L07_t s_action;
 191
 192   xbt_swag_t running_actions =
 193     surf_workstation_resource->common_public->states.running_action_set;
 194   double min =
 195     generic_maxmin_share_resources2(running_actions,
 196                                     xbt_swag_offset(s_action, variable),
 197                                     ptask_maxmin_system, bottleneck_solve);
 198
 199   DEBUG1("min value : %f",min);
 200
 201   return min;
 202 }
 203
 204 static void update_actions_state(double now, double delta)
 205 {
 206   surf_action_workstation_L07_t action = NULL;
 207   surf_action_workstation_L07_t next_action = NULL;
 208   xbt_swag_t running_actions =
 209       surf_workstation_resource->common_public->states.running_action_set;
 210
 211   xbt_swag_foreach_safe(action, next_action, running_actions) {
 212     DEBUG3("Action (%p) : remains (%g) updated by %g.",
 213            action, action->generic_action.remains,
 214            lmm_variable_getvalue(action->variable) * delta);
 215     double_update(&(action->generic_action.remains),
 216                   lmm_variable_getvalue(action->variable) * delta);
 217
 218     if (action->generic_action.max_duration != NO_MAX_DURATION)
 219       double_update(&(action->generic_action.max_duration), delta);
 220
 221     if ((action->generic_action.remains <= 0) &&
 222         (lmm_get_variable_weight(action->variable)>0)) {
 223       action->generic_action.finish = surf_get_clock();
 224       surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 225     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 226                (action->generic_action.max_duration <= 0)) {
 227       action->generic_action.finish = surf_get_clock();
 228       surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 229     } else {
 230       /* Need to check that none of the resource has failed */
 231       lmm_constraint_t cnst = NULL;
 232       int i = 0;
 233       void *constraint_id = NULL;
 234
 235       while ((cnst =
 236               lmm_get_cnst_from_var(ptask_maxmin_system, action->variable,
 237                                     i++))) {
 238         constraint_id = lmm_constraint_id(cnst);
 239
 240 /*      if(((network_link_L07_t)constraint_id)->type== */
 241 /*         SURF_WORKSTATION_RESOURCE_LINK) { */
 242 /*        DEBUG2("Checking for link %s (%p)", */
 243 /*               ((network_link_L07_t)constraint_id)->name, */
 244 /*               ((network_link_L07_t)constraint_id)); */
 245 /*      } */
 246 /*      if(((cpu_L07_t)constraint_id)->type== */
 247 /*         SURF_WORKSTATION_RESOURCE_CPU) { */
 248 /*        DEBUG3("Checking for cpu %s (%p) : %s", */
 249 /*               ((cpu_L07_t)constraint_id)->name, */
 250 /*               ((cpu_L07_t)constraint_id), */
 251 /*               ((cpu_L07_t)constraint_id)->state_current==SURF_CPU_OFF?"Off":"On"); */
 252 /*      } */
 253
 254         if(((((network_link_L07_t)constraint_id)->type==
 255              SURF_WORKSTATION_RESOURCE_LINK) &&
 256             (((network_link_L07_t)constraint_id)->state_current==
 257              SURF_NETWORK_LINK_OFF)) ||
 258            ((((cpu_L07_t)constraint_id)->type==
 259              SURF_WORKSTATION_RESOURCE_CPU) &&
 260             (((cpu_L07_t)constraint_id)->state_current==
 261              SURF_CPU_OFF))) {
 262           DEBUG1("Action (%p) Failed!!",action);
 263           action->generic_action.finish = surf_get_clock();
 264           surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 265           break;
 266         }
 267       }
 268     }
 269   }
 270   return;
 271 }
 272
 273 static void update_resource_state(void *id,
 274                                   tmgr_trace_event_t event_type,
 275                                   double value)
 276 {
 277   cpu_L07_t cpu = id;
 278   network_link_L07_t nw_link = id ;
 279
 280   if(nw_link->type == SURF_WORKSTATION_RESOURCE_LINK) {
 281     DEBUG2("Updating link %s (%p)",nw_link->name,nw_link);
 282     if (event_type == nw_link->bw_event) {
 283       nw_link->bw_current = value;
 284       lmm_update_constraint_bound(ptask_maxmin_system, nw_link->constraint,
 285                                   nw_link->bw_current);
 286     } else if (event_type == nw_link->state_event) {
 287       if (value > 0)
 288         nw_link->state_current = SURF_NETWORK_LINK_ON;
 289       else
 290         nw_link->state_current = SURF_NETWORK_LINK_OFF;
 291     } else {
 292       CRITICAL0("Unknown event ! \n");
 293       xbt_abort();
 294     }
 295     return;
 296   } else if(cpu->type == SURF_WORKSTATION_RESOURCE_CPU) {
 297     DEBUG3("Updating cpu %s (%p) with value %g",cpu->name,cpu,value);
 298     if (event_type == cpu->power_event) {
 299       cpu->power_current = value;
 300       lmm_update_constraint_bound(ptask_maxmin_system, cpu->constraint,
 301                                   cpu->power_current);
 302     } else if (event_type == cpu->state_event) {
 303       if (value > 0)
 304         cpu->state_current = SURF_CPU_ON;
 305       else
 306         cpu->state_current = SURF_CPU_OFF;
 307     } else {
 308       CRITICAL0("Unknown event ! \n");
 309       xbt_abort();
 310     }
 311     return;
 312   } else {
 313     DIE_IMPOSSIBLE;
 314   }
 315   return;
 316 }
 317
 318 static void finalize(void)
 319 {
 320   int i,j;
 321
 322   xbt_dict_free(&network_link_set);
 323   xbt_dict_free(&workstation_set);
 324   if (parallel_task_network_link_set != NULL) {
 325     xbt_dict_free(&parallel_task_network_link_set);
 326   }
 327   xbt_swag_free(surf_workstation_resource->common_public->states.
 328                 ready_action_set);
 329   xbt_swag_free(surf_workstation_resource->common_public->states.
 330                 running_action_set);
 331   xbt_swag_free(surf_workstation_resource->common_public->states.
 332                 failed_action_set);
 333   xbt_swag_free(surf_workstation_resource->common_public->states.
 334                 done_action_set);
 335
 336   free(surf_workstation_resource->common_public);
 337   free(surf_workstation_resource->common_private);
 338   free(surf_workstation_resource->extension_public);
 339
 340   free(surf_workstation_resource);
 341   surf_workstation_resource = NULL;
 342
 343   for (i = 0; i < nb_workstation; i++)
 344     for (j = 0; j < nb_workstation; j++)
 345       free(ROUTE(i, j).links);
 346   free(routing_table);
 347   routing_table = NULL;
 348   nb_workstation = 0;
 349
 350   if (ptask_maxmin_system) {
 351     lmm_system_free(ptask_maxmin_system);
 352     ptask_maxmin_system = NULL;
 353   }
 354 }
 355
 356 /**************************************/
 357 /******* Resource Private    **********/
 358 /**************************************/
 359
 360 static surf_action_t execute(void *cpu, double size)
 361 {
 362   xbt_assert0(0,"This model does not implement plain computations");
 363 }
 364
 365 static surf_action_t action_sleep(void *cpu, double duration)
 366 {
 367   surf_action_workstation_L07_t action = NULL;
 368
 369   XBT_IN2("(%s,%g)",((cpu_L07_t)cpu)->name,duration);
 370
 371   action = (surf_action_workstation_L07_t) execute(cpu, 1.0);
 372   action->generic_action.max_duration = duration;
 373   action->suspended = 2;
 374   lmm_update_variable_weight(ptask_maxmin_system, action->variable, 0.0);
 375
 376   XBT_OUT;
 377   return (surf_action_t) action;
 378 }
 379
 380 static e_surf_cpu_state_t resource_get_state(void *cpu)
 381 {
 382   return ((cpu_L07_t) cpu)->state_current;
 383 }
 384
 385 static double get_speed(void *cpu, double load)
 386 {
 387   return load*(((cpu_L07_t) cpu)->power_scale);
 388 }
 389
 390 static double get_available_speed(void *cpu)
 391 {
 392   return ((cpu_L07_t) cpu)->power_current;
 393 }
 394
 395 static surf_action_t communicate(void *src, void *dst, double size, double rate)
 396 {
 397   xbt_assert0(0,"This model does not implement plain communications");
 398 }
 399
 400 static surf_action_t execute_parallel_task(int workstation_nb,
 401                                            void **workstation_list,
 402                                            double *computation_amount,
 403                                            double *communication_amount,
 404                                            double amount,
 405                                            double rate)
 406 {
 407   surf_action_workstation_L07_t action = NULL;
 408   int i, j, k;
 409   int nb_link = 0;
 410   int nb_host = 0;
 411
 412   if (parallel_task_network_link_set == NULL) {
 413     parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
 414   }
 415
 416   /* Compute the number of affected resources... */
 417   for(i=0; i< workstation_nb; i++) {
 418     for(j=0; j< workstation_nb; j++) {
 419       cpu_L07_t card_src = workstation_list[i];
 420       cpu_L07_t card_dst = workstation_list[j];
 421       int route_size = ROUTE(card_src->id, card_dst->id).size;
 422       network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
 423
 424       if(communication_amount[i*workstation_nb+j]>0)
 425         for(k=0; k< route_size; k++) {
 426           xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
 427         }
 428     }
 429   }
 430   nb_link = xbt_dict_length(parallel_task_network_link_set);
 431   xbt_dict_reset(parallel_task_network_link_set);
 432
 433
 434   for (i = 0; i<workstation_nb; i++)
 435     if(computation_amount[i]>0) nb_host++;
 436
 437
 438   if(nb_link + nb_host == 0) /* was workstation_nb... */
 439     return NULL;
 440
 441   action = xbt_new0(s_surf_action_workstation_L07_t, 1);
 442   DEBUG3("Creating a parallel task (%p) with %d cpus and %d links.",
 443          action, nb_host,  nb_link);
 444   action->generic_action.using = 1;
 445   action->generic_action.cost = amount;
 446   action->generic_action.remains = amount;
 447   action->generic_action.max_duration = NO_MAX_DURATION;
 448   action->generic_action.start = -1.0;
 449   action->generic_action.finish = -1.0;
 450   action->generic_action.resource_type =
 451       (surf_resource_t) surf_workstation_resource;
 452   action->suspended = 0;  /* Should be useless because of the
 453                              calloc but it seems to help valgrind... */
 454   action->generic_action.state_set =
 455       surf_workstation_resource->common_public->states.running_action_set;
 456
 457   xbt_swag_insert(action, action->generic_action.state_set);
 458   action->rate = rate;
 459
 460   if(action->rate>0)
 461     action->variable = lmm_variable_new(ptask_maxmin_system, action, 1.0, -1.0,
 462                                         nb_host + nb_link);
 463   else
 464     action->variable = lmm_variable_new(ptask_maxmin_system, action, 1.0, action->rate,
 465                                         nb_host + nb_link);
 466
 467   for (i = 0; i<workstation_nb; i++)
 468     if(computation_amount[i]>0)
 469       lmm_expand(ptask_maxmin_system, ((cpu_L07_t) workstation_list[i])->constraint,
 470                  action->variable, computation_amount[i]);
 471
 472   for (i=0; i<workstation_nb; i++) {
 473     for(j=0; j< workstation_nb; j++) {
 474       cpu_L07_t card_src = workstation_list[i];
 475       cpu_L07_t card_dst = workstation_list[j];
 476       int route_size = ROUTE(card_src->id, card_dst->id).size;
 477       network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
 478
 479       for(k=0; k< route_size; k++) {
 480         if(communication_amount[i*workstation_nb+j]>0) {
 481           lmm_expand_add(ptask_maxmin_system, route[k]->constraint,
 482                        action->variable, communication_amount[i*workstation_nb+j]);
 483         }
 484       }
 485     }
 486   }
 487
 488   return (surf_action_t) action;
 489 }
 490
 491 /* returns an array of network_link_L07_t */
 492 static const void** get_route(void *src, void *dst) {
 493   cpu_L07_t card_src = src;
 494   cpu_L07_t card_dst = dst;
 495   route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
 496
 497   return (const void**) route->links;
 498 }
 499
 500 static int get_route_size(void *src, void *dst) {
 501   cpu_L07_t card_src = src;
 502   cpu_L07_t card_dst = dst;
 503   route_L07_t route = &(ROUTE(card_src->id, card_dst->id));
 504   return route->size;
 505 }
 506
 507 static const char *get_link_name(const void *link) {
 508   return ((network_link_L07_t) link)->name;
 509 }
 510
 511 static double get_link_bandwidth(const void *link) {
 512   return ((network_link_L07_t) link)->bw_current;
 513 }
 514
 515 static double get_link_latency(const void *link) {
 516   xbt_assert0(0,"This model does not implement latencies");
 517 }
 518
 519 /**************************************/
 520 /*** Resource Creation & Destruction **/
 521 /**************************************/
 522
 523 static void cpu_free(void *cpu)
 524 {
 525   free(((cpu_L07_t) cpu)->name);
 526   free(cpu);
 527 }
 528
 529 static cpu_L07_t cpu_new(const char *name, double power_scale,
 530                               double power_initial,
 531                               tmgr_trace_t power_trace,
 532                               e_surf_cpu_state_t state_initial,
 533                               tmgr_trace_t state_trace)
 534 {
 535   cpu_L07_t cpu = xbt_new0(s_cpu_L07_t, 1);
 536
 537   cpu->resource = (surf_resource_t) surf_workstation_resource;
 538   cpu->type = SURF_WORKSTATION_RESOURCE_CPU;
 539   cpu->name = xbt_strdup(name);
 540   cpu->id = nb_workstation++;
 541
 542   cpu->power_scale = power_scale;
 543   xbt_assert0(cpu->power_scale > 0, "Power has to be >0");
 544
 545   cpu->power_current = power_initial;
 546   if (power_trace)
 547     cpu->power_event =
 548         tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu);
 549
 550   cpu->state_current = state_initial;
 551   if (state_trace)
 552     cpu->state_event =
 553         tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu);
 554
 555   cpu->constraint =
 556       lmm_constraint_new(ptask_maxmin_system, cpu,
 557                          cpu->power_current * cpu->power_scale);
 558
 559   xbt_dict_set(workstation_set, name, cpu, cpu_free);
 560
 561   return cpu;
 562 }
 563
 564 static void parse_cpu(void)
 565 {
 566   double power_scale = 0.0;
 567   double power_initial = 0.0;
 568   tmgr_trace_t power_trace = NULL;
 569   e_surf_cpu_state_t state_initial = SURF_CPU_OFF;
 570   tmgr_trace_t state_trace = NULL;
 571
 572   surf_parse_get_double(&power_scale, A_surfxml_cpu_power);
 573   surf_parse_get_double(&power_initial, A_surfxml_cpu_availability);
 574   surf_parse_get_trace(&power_trace, A_surfxml_cpu_availability_file);
 575
 576   xbt_assert0((A_surfxml_cpu_state == A_surfxml_cpu_state_ON) ||
 577               (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF),
 578               "Invalid state");
 579   if (A_surfxml_cpu_state == A_surfxml_cpu_state_ON)
 580     state_initial = SURF_CPU_ON;
 581   if (A_surfxml_cpu_state == A_surfxml_cpu_state_OFF)
 582     state_initial = SURF_CPU_OFF;
 583   surf_parse_get_trace(&state_trace, A_surfxml_cpu_state_file);
 584
 585   cpu_new(A_surfxml_cpu_name, power_scale, power_initial, power_trace,
 586           state_initial, state_trace);
 587 }
 588
 589 static void create_routing_table(void)
 590 {
 591   routing_table =
 592       xbt_new0(s_route_L07_t, nb_workstation * nb_workstation);
 593 }
 594
 595 static void network_link_free(void *nw_link)
 596 {
 597   free(((network_link_L07_t) nw_link)->name);
 598   free(nw_link);
 599 }
 600
 601 static network_link_L07_t network_link_new(char *name,
 602                                                 double bw_initial,
 603                                                 tmgr_trace_t bw_trace,
 604                                                 e_surf_network_link_state_t
 605                                                 state_initial,
 606                                                 tmgr_trace_t state_trace,
 607                                                 e_surf_network_link_sharing_policy_t policy)
 608 {
 609   network_link_L07_t nw_link = xbt_new0(s_network_link_L07_t, 1);
 610
 611
 612   nw_link->resource = (surf_resource_t) surf_workstation_resource;
 613   nw_link->type = SURF_WORKSTATION_RESOURCE_LINK;
 614   nw_link->name = name;
 615   nw_link->bw_current = bw_initial;
 616   if (bw_trace)
 617     nw_link->bw_event =
 618         tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
 619   nw_link->state_current = state_initial;
 620   if (state_trace)
 621     nw_link->state_event =
 622         tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
 623
 624   nw_link->constraint =
 625       lmm_constraint_new(ptask_maxmin_system, nw_link, nw_link->bw_current);
 626
 627   if(policy == SURF_NETWORK_LINK_FATPIPE)
 628     lmm_constraint_shared(nw_link->constraint);
 629
 630   xbt_dict_set(network_link_set, name, nw_link, network_link_free);
 631
 632   return nw_link;
 633 }
 634
 635 static void parse_network_link(void)
 636 {
 637   char *name;
 638   double bw_initial;
 639   tmgr_trace_t bw_trace;
 640   e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
 641   e_surf_network_link_sharing_policy_t policy_initial = SURF_NETWORK_LINK_SHARED;
 642   tmgr_trace_t state_trace;
 643
 644   name = xbt_strdup(A_surfxml_network_link_name);
 645   surf_parse_get_double(&bw_initial,A_surfxml_network_link_bandwidth);
 646   surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
 647
 648   xbt_assert0((A_surfxml_network_link_state==A_surfxml_network_link_state_ON)||
 649               (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF),
 650               "Invalid state");
 651   if (A_surfxml_network_link_state==A_surfxml_network_link_state_ON)
 652     state_initial = SURF_NETWORK_LINK_ON;
 653   else if (A_surfxml_network_link_state==A_surfxml_network_link_state_OFF)
 654     state_initial = SURF_NETWORK_LINK_OFF;
 655
 656   if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_SHARED)
 657     policy_initial = SURF_NETWORK_LINK_SHARED;
 658   else if (A_surfxml_network_link_sharing_policy==A_surfxml_network_link_sharing_policy_FATPIPE)
 659     policy_initial = SURF_NETWORK_LINK_FATPIPE;
 660
 661   surf_parse_get_trace(&state_trace,A_surfxml_network_link_state_file);
 662
 663   network_link_new(name, bw_initial, bw_trace, state_initial, state_trace,
 664                    policy_initial);
 665 }
 666
 667 static void route_new(int src_id, int dst_id, network_link_L07_t *link_list, int nb_link)
 668 {
 669   route_L07_t route = &(ROUTE(src_id, dst_id));
 670
 671   route->size = nb_link;
 672   route->links = link_list = xbt_realloc(link_list, sizeof(network_link_L07_t) * nb_link);
 673 }
 674
 675 static int nb_link;
 676 static int link_list_capacity;
 677 static network_link_L07_t *link_list = NULL;
 678 static int src_id = -1;
 679 static int dst_id = -1;
 680
 681 static void parse_route_set_endpoints(void)
 682 {
 683   cpu_L07_t cpu_tmp = NULL;
 684
 685   cpu_tmp = (cpu_L07_t) name_service(A_surfxml_route_src);
 686   xbt_assert1(cpu_tmp,"Invalid cpu %s",A_surfxml_route_src);
 687   if(cpu_tmp != NULL) src_id = cpu_tmp->id;
 688
 689   cpu_tmp = (cpu_L07_t) name_service(A_surfxml_route_dst);
 690   xbt_assert1(cpu_tmp,"Invalid cpu %s",A_surfxml_route_dst);
 691   if(cpu_tmp != NULL)  dst_id = cpu_tmp->id;
 692
 693   nb_link = 0;
 694   link_list_capacity = 1;
 695   link_list = xbt_new(network_link_L07_t, link_list_capacity);
 696 }
 697
 698 static void parse_route_elem(void)
 699 {
 700   xbt_ex_t e;
 701   if (nb_link == link_list_capacity) {
 702     link_list_capacity *= 2;
 703     link_list = xbt_realloc(link_list, (link_list_capacity) * sizeof(network_link_L07_t));
 704   }
 705   TRY {
 706      link_list[nb_link++] = xbt_dict_get(network_link_set, A_surfxml_route_element_name);
 707   } CATCH(e) {
 708      RETHROW1("Link %s not found (dict raised this exception: %s)",A_surfxml_route_element_name);
 709   }
 710 }
 711
 712 static void parse_route_set_route(void)
 713 {
 714   if( src_id != -1 && dst_id != -1 )
 715   route_new(src_id, dst_id, link_list, nb_link);
 716 }
 717
 718 static void parse_file(const char *file)
 719 {
 720   int i;
 721
 722   /* Figuring out the cpus */
 723   surf_parse_reset_parser();
 724   ETag_surfxml_cpu_fun = parse_cpu;
 725   surf_parse_open(file);
 726   xbt_assert1((!surf_parse()), "Parse error in %s", file);
 727   surf_parse_close();
 728
 729   create_routing_table();
 730
 731   /* Figuring out the network links */
 732   surf_parse_reset_parser();
 733   ETag_surfxml_network_link_fun = parse_network_link;
 734   surf_parse_open(file);
 735   xbt_assert1((!surf_parse()), "Parse error in %s", file);
 736   surf_parse_close();
 737
 738   /* Building the routes */
 739   surf_parse_reset_parser();
 740   STag_surfxml_route_fun = parse_route_set_endpoints;
 741   ETag_surfxml_route_element_fun = parse_route_elem;
 742   ETag_surfxml_route_fun = parse_route_set_route;
 743   surf_parse_open(file);
 744   xbt_assert1((!surf_parse()), "Parse error in %s", file);
 745   surf_parse_close();
 746
 747   /* Adding loopback if needed */
 748   for (i = 0; i < nb_workstation; i++)
 749     if(!ROUTE(i,i).size) {
 750       ROUTE(i,i).size=1;
 751       ROUTE(i,i).links = xbt_new0(network_link_L07_t, 1);
 752       ROUTE(i,i).links[0] = network_link_new(xbt_strdup("__MSG_loopback__"),
 753                                    498000000, NULL,
 754                                    SURF_NETWORK_LINK_ON, NULL,
 755                                    SURF_NETWORK_LINK_SHARED);
 756     }
 757 }
 758
 759 /**************************************/
 760 /********* Module  creation ***********/
 761 /**************************************/
 762
 763 static void resource_init_internal(void)
 764 {
 765   s_surf_action_t action;
 766
 767   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 768
 769   surf_workstation_resource->common_private =
 770       xbt_new0(s_surf_resource_private_t, 1);
 771   surf_workstation_resource->common_public =
 772       xbt_new0(s_surf_resource_public_t, 1);
 773   surf_workstation_resource->extension_public =
 774       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 775
 776   surf_workstation_resource->common_public->states.ready_action_set =
 777       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 778   surf_workstation_resource->common_public->states.running_action_set =
 779       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 780   surf_workstation_resource->common_public->states.failed_action_set =
 781       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 782   surf_workstation_resource->common_public->states.done_action_set =
 783       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 784
 785   surf_workstation_resource->common_public->name_service = name_service;
 786   surf_workstation_resource->common_public->get_resource_name = get_resource_name;
 787   surf_workstation_resource->common_public->action_get_state = surf_action_get_state;
 788   surf_workstation_resource->common_public->action_get_start_time =
 789       surf_action_get_start_time;
 790   surf_workstation_resource->common_public->action_get_finish_time =
 791       surf_action_get_finish_time;
 792   surf_workstation_resource->common_public->action_use = action_use;
 793   surf_workstation_resource->common_public->action_free = action_free;
 794   surf_workstation_resource->common_public->action_cancel = action_cancel;
 795   surf_workstation_resource->common_public->action_recycle = action_recycle;
 796   surf_workstation_resource->common_public->action_change_state = surf_action_change_state;
 797   surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
 798   surf_workstation_resource->common_public->suspend = action_suspend;
 799   surf_workstation_resource->common_public->resume = action_resume;
 800   surf_workstation_resource->common_public->is_suspended = action_is_suspended;
 801   surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
 802   surf_workstation_resource->common_public->set_priority = action_set_priority;
 803   surf_workstation_resource->common_public->name = "Workstation ptask_L07";
 804
 805   surf_workstation_resource->common_private->resource_used = resource_used;
 806   surf_workstation_resource->common_private->share_resources = share_resources;
 807   surf_workstation_resource->common_private->update_actions_state = update_actions_state;
 808   surf_workstation_resource->common_private->update_resource_state = update_resource_state;
 809   surf_workstation_resource->common_private->finalize = finalize;
 810
 811   surf_workstation_resource->extension_public->execute = execute;
 812   surf_workstation_resource->extension_public->sleep = action_sleep;
 813   surf_workstation_resource->extension_public->get_state = resource_get_state;
 814   surf_workstation_resource->extension_public->get_speed = get_speed;
 815   surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
 816   surf_workstation_resource->extension_public->communicate = communicate;
 817   surf_workstation_resource->extension_public->execute_parallel_task = execute_parallel_task;
 818   surf_workstation_resource->extension_public->get_route = get_route;
 819   surf_workstation_resource->extension_public->get_route_size = get_route_size;
 820   surf_workstation_resource->extension_public->get_link_name = get_link_name;
 821   surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
 822   surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
 823
 824   workstation_set  = xbt_dict_new();
 825   network_link_set = xbt_dict_new();
 826
 827   if(!ptask_maxmin_system)
 828     ptask_maxmin_system = lmm_system_new();
 829 }
 830
 831 /**************************************/
 832 /*************** Generic **************/
 833 /**************************************/
 834 void surf_workstation_resource_init_ptask_L07(const char *filename)
 835 {
 836   xbt_assert0(!surf_cpu_resource, "CPU resource type already defined");
 837   xbt_assert0(!surf_network_resource, "network resource type already defined");
 838   resource_init_internal();
 839   parse_file(filename);
 840
 841   update_resource_description(surf_workstation_resource_description,
 842                               surf_workstation_resource_description_size,
 843                               "ptask_L07",
 844                               (surf_resource_t) surf_workstation_resource);
 845   xbt_dynar_push(resource_list, &surf_workstation_resource);
 846 }