src/surf/workstation.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2004 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 "workstation_private.h"
  11 #include "cpu_private.h"
  12 #include "network_private.h"
  13
  14 #ifdef USE_GTNETS
  15 #include "network_gtnets_private.h"
  16 #endif
  17
  18 surf_workstation_resource_t surf_workstation_resource = NULL;
  19 xbt_dict_t workstation_set = NULL;
  20 static xbt_dict_t parallel_task_network_link_set = NULL;
  21
  22 static workstation_CLM03_t workstation_new(const char *name,
  23                                      void *cpu, void *card)
  24 {
  25   workstation_CLM03_t workstation = xbt_new0(s_workstation_CLM03_t, 1);
  26
  27   workstation->resource = (surf_resource_t) surf_workstation_resource;
  28   workstation->name = xbt_strdup(name);
  29   workstation->cpu = cpu;
  30   workstation->network_card = card;
  31
  32   return workstation;
  33 }
  34
  35 static void workstation_free(void *workstation)
  36 {
  37   free(((workstation_CLM03_t)workstation)->name);
  38   free(workstation);
  39 }
  40
  41 static void create_workstations(void)
  42 {
  43   xbt_dict_cursor_t cursor = NULL;
  44   char *name = NULL;
  45   void *cpu = NULL;
  46   void *nw_card = NULL;
  47
  48   xbt_dict_foreach(cpu_set, cursor, name, cpu) {
  49     nw_card = xbt_dict_get_or_null(network_card_set, name);
  50     xbt_assert1(nw_card,
  51                 "No corresponding card found for %s",name);
  52
  53     xbt_dict_set(workstation_set, name,
  54                  workstation_new(name, cpu, nw_card), workstation_free);
  55   }
  56 }
  57
  58 static void *name_service(const char *name)
  59 {
  60   return xbt_dict_get_or_null(workstation_set, name);
  61 }
  62
  63 static const char *get_resource_name(void *resource_id)
  64 {
  65   return ((workstation_CLM03_t) resource_id)->name;
  66 }
  67
  68 static int resource_used(void *resource_id)
  69 {
  70   xbt_assert0(0,
  71               "Workstation is a virtual resource. I should not be there!");
  72   return 0;
  73 }
  74
  75 static int parallel_action_free(surf_action_t action)
  76 {
  77   action->using--;
  78   if(!action->using) {
  79     xbt_swag_remove(action, action->state_set);
  80     if(((surf_action_parallel_task_CSL05_t)action)->variable)
  81       lmm_variable_free(maxmin_system, ((surf_action_parallel_task_CSL05_t)action)->variable);
  82     free(action);
  83     return 1;
  84   }
  85   return 0;
  86 }
  87
  88 static void parallel_action_use(surf_action_t action)
  89 {
  90   action->using++;
  91 }
  92
  93 static int action_free(surf_action_t action)
  94 {
  95   if(action->resource_type==(surf_resource_t)surf_network_resource)
  96     return surf_network_resource->common_public->action_free(action);
  97   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
  98     return surf_cpu_resource->common_public->action_free(action);
  99   else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
 100     return parallel_action_free(action);
 101   else DIE_IMPOSSIBLE;
 102   return 0;
 103 }
 104
 105 static void action_use(surf_action_t action)
 106 {
 107   if(action->resource_type==(surf_resource_t)surf_network_resource)
 108     surf_network_resource->common_public->action_use(action);
 109   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 110     surf_cpu_resource->common_public->action_use(action);
 111   else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
 112     parallel_action_use(action);
 113   else DIE_IMPOSSIBLE;
 114   return;
 115 }
 116
 117 static void action_cancel(surf_action_t action)
 118 {
 119   if(action->resource_type==(surf_resource_t)surf_network_resource)
 120     surf_network_resource->common_public->action_cancel(action);
 121   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 122     surf_cpu_resource->common_public->action_cancel(action);
 123   else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
 124     parallel_action_use(action);
 125   else DIE_IMPOSSIBLE;
 126   return;
 127 }
 128
 129 static void action_recycle(surf_action_t action)
 130 {
 131   DIE_IMPOSSIBLE;
 132   return;
 133 }
 134
 135 static void action_change_state(surf_action_t action,
 136                                 e_surf_action_state_t state)
 137 {
 138   if(action->resource_type==(surf_resource_t)surf_network_resource)
 139     surf_network_resource->common_public->action_change_state(action,state);
 140   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 141     surf_cpu_resource->common_public->action_change_state(action,state);
 142   else if(action->resource_type==(surf_resource_t)surf_workstation_resource)
 143     surf_action_change_state(action, state);
 144   else DIE_IMPOSSIBLE;
 145   return;
 146 }
 147
 148 static double share_resources(double now)
 149 {
 150   s_surf_action_parallel_task_CSL05_t action;
 151   return generic_maxmin_share_resources(surf_workstation_resource->common_public->
 152                                         states.running_action_set,
 153                                         xbt_swag_offset(action, variable));
 154 }
 155
 156 static void update_actions_state(double now, double delta)
 157 {
 158   surf_action_parallel_task_CSL05_t action = NULL;
 159   surf_action_parallel_task_CSL05_t next_action = NULL;
 160   xbt_swag_t running_actions =
 161       surf_workstation_resource->common_public->states.running_action_set;
 162   /* FIXME: unused
 163   xbt_swag_t failed_actions =
 164       surf_workstation_resource->common_public->states.failed_action_set;
 165   */
 166
 167   xbt_swag_foreach_safe(action, next_action, running_actions) {
 168     double_update(&(action->generic_action.remains),
 169         lmm_variable_getvalue(action->variable) * delta);
 170     if (action->generic_action.max_duration != NO_MAX_DURATION)
 171       double_update(&(action->generic_action.max_duration), delta);
 172     if ((action->generic_action.remains <= 0) &&
 173         (lmm_get_variable_weight(action->variable)>0)) {
 174       action->generic_action.finish = surf_get_clock();
 175       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 176     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 177                (action->generic_action.max_duration <= 0)) {
 178       action->generic_action.finish = surf_get_clock();
 179       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 180     } else {                    /* Need to check that none of the resource has failed */
 181       lmm_constraint_t cnst = NULL;
 182       int i = 0;
 183       surf_resource_t resource = NULL;
 184
 185       while ((cnst =
 186               lmm_get_cnst_from_var(maxmin_system, action->variable,
 187                                     i++))) {
 188         resource = (surf_resource_t) lmm_constraint_id(cnst);
 189         if(resource== (surf_resource_t) surf_cpu_resource) {
 190           cpu_Cas01_t cpu = lmm_constraint_id(cnst);
 191           if (cpu->state_current == SURF_CPU_OFF) {
 192             action->generic_action.finish = surf_get_clock();
 193             action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 194             break;
 195           }
 196         } else if (resource== (surf_resource_t) surf_network_resource) {
 197           network_link_CM02_t nw_link = lmm_constraint_id(cnst);
 198
 199           if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
 200             action->generic_action.finish = surf_get_clock();
 201             action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 202             break;
 203           }
 204         }
 205       }
 206     }
 207   }
 208
 209   return;
 210 }
 211
 212 #ifdef USE_GTNETS
 213 /* KF. For GTNetS. This is the same as surf_actions_state_gtnets except for
 214    the network resource update.
 215 */
 216 static void update_actions_state_gtnets(double now, double delta)
 217 {
 218   surf_action_parallel_task_CSL05_t action = NULL;
 219   surf_action_parallel_task_CSL05_t next_action = NULL;
 220   xbt_swag_t running_actions =
 221       surf_workstation_resource->common_public->states.running_action_set;
 222   /* FIXME: unused
 223   xbt_swag_t failed_actions =
 224       surf_workstation_resource->common_public->states.failed_action_set;
 225   */
 226
 227   xbt_swag_foreach_safe(action, next_action, running_actions) {
 228     double_update(&(action->generic_action.remains),
 229         lmm_variable_getvalue(action->variable) * delta);
 230     if (action->generic_action.max_duration != NO_MAX_DURATION)
 231       double_update(&(action->generic_action.max_duration), delta);
 232     if ((action->generic_action.remains <= 0) &&
 233         (lmm_get_variable_weight(action->variable)>0)) {
 234       action->generic_action.finish = surf_get_clock();
 235       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 236     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 237                (action->generic_action.max_duration <= 0)) {
 238       action->generic_action.finish = surf_get_clock();
 239       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 240     } else {                    /* Need to check that none of the resource has failed */
 241       lmm_constraint_t cnst = NULL;
 242       int i = 0;
 243       surf_resource_t resource = NULL;
 244
 245       while ((cnst =
 246               lmm_get_cnst_from_var(maxmin_system, action->variable,
 247                                     i++))) {
 248         resource = (surf_resource_t) lmm_constraint_id(cnst);
 249         if(resource== (surf_resource_t) surf_cpu_resource) {
 250           cpu_Cas01_t cpu = lmm_constraint_id(cnst);
 251           if (cpu->state_current == SURF_CPU_OFF) {
 252             action->generic_action.finish = surf_get_clock();
 253             action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 254             break;
 255           }
 256         } else if (resource== (surf_resource_t) surf_network_resource) {
 257           /**
 258           network_link_GTNETS_t nw_link = lmm_constraint_id(cnst);
 259
 260           if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
 261             action->generic_action.finish = surf_get_clock();
 262             action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 263             break;
 264           }
 265           **/
 266         }
 267       }
 268     }
 269   }
 270
 271   return;
 272 }
 273 #endif
 274
 275 static void update_resource_state(void *id,
 276                                   tmgr_trace_event_t event_type,
 277                                   double value)
 278 {
 279   return;
 280 }
 281
 282 static surf_action_t execute(void *workstation, double size)
 283 {
 284   return surf_cpu_resource->extension_public->
 285       execute(((workstation_CLM03_t) workstation)->cpu, size);
 286 }
 287
 288 static surf_action_t action_sleep(void *workstation, double duration)
 289 {
 290   return surf_cpu_resource->extension_public->
 291       sleep(((workstation_CLM03_t) workstation)->cpu, duration);
 292 }
 293
 294 static void action_suspend(surf_action_t action)
 295 {
 296   if(action->resource_type==(surf_resource_t)surf_network_resource)
 297     surf_network_resource->common_public->suspend(action);
 298   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 299     surf_cpu_resource->common_public->suspend(action);
 300   else DIE_IMPOSSIBLE;
 301 }
 302
 303 static void action_resume(surf_action_t action)
 304 {
 305   if(action->resource_type==(surf_resource_t)surf_network_resource)
 306     surf_network_resource->common_public->resume(action);
 307   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 308     surf_cpu_resource->common_public->resume(action);
 309   else DIE_IMPOSSIBLE;
 310 }
 311
 312 static int action_is_suspended(surf_action_t action)
 313 {
 314   if(action->resource_type==(surf_resource_t)surf_network_resource)
 315     return surf_network_resource->common_public->is_suspended(action);
 316   if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 317     return surf_cpu_resource->common_public->is_suspended(action);
 318   DIE_IMPOSSIBLE;
 319 }
 320
 321 static void action_set_max_duration(surf_action_t action, double duration)
 322 {
 323   if(action->resource_type==(surf_resource_t)surf_network_resource)
 324     surf_network_resource->common_public->set_max_duration(action,duration);
 325   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 326     surf_cpu_resource->common_public->set_max_duration(action,duration);
 327   else  DIE_IMPOSSIBLE;
 328 }
 329
 330 static void action_set_priority(surf_action_t action, double priority)
 331 {
 332   if(action->resource_type==(surf_resource_t)surf_network_resource)
 333     surf_network_resource->common_public->set_priority(action,priority);
 334   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 335     surf_cpu_resource->common_public->set_priority(action,priority);
 336   else  DIE_IMPOSSIBLE;
 337 }
 338
 339 static surf_action_t communicate(void *workstation_src,
 340                                  void *workstation_dst, double size,
 341                                  double rate)
 342 {
 343   return surf_network_resource->extension_public->
 344       communicate(((workstation_CLM03_t) workstation_src)->network_card,
 345                   ((workstation_CLM03_t) workstation_dst)->network_card, size, rate);
 346 }
 347
 348 static e_surf_cpu_state_t get_state(void *workstation)
 349 {
 350   return surf_cpu_resource->extension_public->
 351       get_state(((workstation_CLM03_t) workstation)->cpu);
 352 }
 353
 354 static double get_speed(void *workstation, double load)
 355 {
 356   return surf_cpu_resource->extension_public->
 357       get_speed(((workstation_CLM03_t) workstation)->cpu, load);
 358 }
 359
 360 static double get_available_speed(void *workstation)
 361 {
 362   return surf_cpu_resource->extension_public->
 363       get_available_speed(((workstation_CLM03_t) workstation)->cpu);
 364 }
 365
 366 static surf_action_t execute_parallel_task (int workstation_nb,
 367                                             void **workstation_list,
 368                                             double *computation_amount,
 369                                             double *communication_amount,
 370                                             double amount,
 371                                             double rate)
 372 {
 373   surf_action_parallel_task_CSL05_t action = NULL;
 374   int i, j, k;
 375   int nb_link = 0;
 376   int nb_host = 0;
 377
 378   if (parallel_task_network_link_set == NULL) {
 379     parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
 380   }
 381
 382   /* Compute the number of affected resources... */
 383   for(i=0; i< workstation_nb; i++) {
 384     for(j=0; j< workstation_nb; j++) {
 385       network_card_CM02_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
 386       network_card_CM02_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
 387       int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
 388       network_link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
 389
 390       if(communication_amount[i*workstation_nb+j]>0)
 391         for(k=0; k< route_size; k++) {
 392           xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
 393         }
 394     }
 395   }
 396
 397   nb_link = xbt_dict_length(parallel_task_network_link_set);
 398   xbt_dict_reset(parallel_task_network_link_set);
 399
 400   for (i = 0; i<workstation_nb; i++)
 401     if(computation_amount[i]>0) nb_host++;
 402
 403   if(nb_link + workstation_nb == 0)
 404     return NULL;
 405
 406   action = xbt_new0(s_surf_action_parallel_task_CSL05_t, 1);
 407   action->generic_action.using = 1;
 408   action->generic_action.cost = amount;
 409   action->generic_action.remains = amount;
 410   action->generic_action.max_duration = NO_MAX_DURATION;
 411   action->generic_action.start = surf_get_clock();
 412   action->generic_action.finish = -1.0;
 413   action->generic_action.resource_type =
 414       (surf_resource_t) surf_workstation_resource;
 415   action->suspended = 0;  /* Should be useless because of the
 416                              calloc but it seems to help valgrind... */
 417   action->generic_action.state_set =
 418       surf_workstation_resource->common_public->states.running_action_set;
 419
 420   xbt_swag_insert(action, action->generic_action.state_set);
 421   action->rate = rate;
 422
 423   if(action->rate>0)
 424     action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
 425                                         nb_host + nb_link);
 426   else
 427     action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate,
 428                                         nb_host + nb_link);
 429
 430   for (i = 0; i<workstation_nb; i++)
 431     if(computation_amount[i]>0)
 432       lmm_expand(maxmin_system, ((cpu_Cas01_t) ((workstation_CLM03_t) workstation_list[i])->cpu)->constraint,
 433                  action->variable, computation_amount[i]);
 434
 435   for (i=0; i<workstation_nb; i++) {
 436     for(j=0; j< workstation_nb; j++) {
 437       network_card_CM02_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
 438       network_card_CM02_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
 439       int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
 440       network_link_CM02_t *route = ROUTE(card_src->id, card_dst->id);
 441
 442       for(k=0; k< route_size; k++) {
 443         if(communication_amount[i*workstation_nb+j]>0) {
 444           lmm_expand_add(maxmin_system, route[k]->constraint,
 445                        action->variable, communication_amount[i*workstation_nb+j]);
 446         }
 447       }
 448     }
 449   }
 450
 451   return (surf_action_t) action;
 452 }
 453
 454 #ifdef USE_GTNETS
 455 /* KF. We don't support this for GTNetS.
 456 */
 457 static surf_action_t execute_parallel_task_gtnets (int workstation_nb,
 458                                             void **workstation_list,
 459                                             double *computation_amount,
 460                                             double *communication_amount,
 461                                             double amount,
 462                                             double rate)
 463 {
 464   xbt_assert0(0,"Cannot execute parallel task");
 465   return 0;
 466 #if 0
 467   surf_action_parallel_task_CSL05_t action = NULL;
 468   int i, j, k;
 469   int nb_link = 0;
 470   int nb_host = 0;
 471
 472   if (parallel_task_network_link_set == NULL) {
 473     parallel_task_network_link_set = xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
 474   }
 475
 476   for(i=0; i< workstation_nb; i++) {
 477     for(j=0; j< workstation_nb; j++) {
 478       network_card_GTNETS_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
 479       network_card_GTNETS_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
 480       int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
 481       network_link_GTNETS_t *route = ROUTE(card_src->id, card_dst->id);
 482
 483       if(communication_amount[i*workstation_nb+j]>0)
 484         for(k=0; k< route_size; k++) {
 485           xbt_dict_set(parallel_task_network_link_set, route[k]->name, route[k], NULL);
 486         }
 487     }
 488   }
 489
 490   nb_link = xbt_dict_length(parallel_task_network_link_set);
 491   xbt_dict_reset(parallel_task_network_link_set);
 492
 493   for (i = 0; i<workstation_nb; i++)
 494     if(computation_amount[i]>0) nb_host++;
 495
 496   if(nb_link + workstation_nb == 0)
 497     return NULL;
 498
 499   action = xbt_new0(s_surf_action_parallel_task_CSL05_t, 1);
 500   action->generic_action.using = 1;
 501   action->generic_action.cost = amount;
 502   action->generic_action.remains = amount;
 503   action->generic_action.max_duration = NO_MAX_DURATION;
 504   action->generic_action.start = surf_get_clock();
 505   action->generic_action.finish = -1.0;
 506   action->generic_action.resource_type =
 507       (surf_resource_t) surf_workstation_resource;
 508   action->suspended = 0;  /* Should be useless because of the
 509                              calloc but it seems to help valgrind... */
 510   action->generic_action.state_set =
 511       surf_workstation_resource->common_public->states.running_action_set;
 512
 513   xbt_swag_insert(action, action->generic_action.state_set);
 514   action->rate = rate;
 515
 516   if(action->rate>0)
 517     action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
 518                                         nb_host + nb_link);
 519   else
 520     action->variable = lmm_variable_new(maxmin_system, action, 1.0, action->rate,
 521                                         nb_host + nb_link);
 522
 523   for (i = 0; i<workstation_nb; i++)
 524     if(computation_amount[i]>0)
 525       lmm_expand(maxmin_system, ((cpu_Cas01_t) ((workstation_CLM03_t) workstation_list[i])->cpu)->constraint,
 526                  action->variable, computation_amount[i]);
 527
 528   for (i=0; i<workstation_nb; i++) {
 529     for(j=0; j< workstation_nb; j++) {
 530       network_card_GTNETS_t card_src = ((workstation_CLM03_t*)workstation_list)[i]->network_card;
 531       network_card_GTNETS_t card_dst = ((workstation_CLM03_t*)workstation_list)[j]->network_card;
 532       int route_size = ROUTE_SIZE(card_src->id, card_dst->id);
 533       network_link_GTNETS_t *route = ROUTE(card_src->id, card_dst->id);
 534
 535       for(k=0; k< route_size; k++) {
 536         if(communication_amount[i*workstation_nb+j]>0) {
 537           lmm_expand_add(maxmin_system, route[k]->constraint,
 538                        action->variable, communication_amount[i*workstation_nb+j]);
 539         }
 540       }
 541     }
 542   }
 543
 544   return (surf_action_t) action;
 545 #endif
 546 }
 547 #endif
 548
 549 /* returns an array of network_link_CM02_t */
 550 static const void** get_route(void *src, void *dst) {
 551   workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
 552   workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
 553   return surf_network_resource->extension_public->get_route(workstation_src->network_card, workstation_dst->network_card);
 554 }
 555
 556 static int get_route_size(void *src, void *dst) {
 557   workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
 558   workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
 559   return surf_network_resource->extension_public->get_route_size(workstation_src->network_card, workstation_dst->network_card);
 560 }
 561
 562 static const char *get_link_name(const void *link) {
 563   return surf_network_resource->extension_public->get_link_name(link);
 564 }
 565
 566 static double get_link_bandwidth(const void *link) {
 567   return surf_network_resource->extension_public->get_link_bandwidth(link);
 568 }
 569
 570 static double get_link_latency(const void *link) {
 571   return surf_network_resource->extension_public->get_link_latency(link);
 572 }
 573
 574 static void finalize(void)
 575 {
 576   xbt_dict_free(&workstation_set);
 577   xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
 578   xbt_swag_free(surf_workstation_resource->common_public->states.
 579                 running_action_set);
 580   xbt_swag_free(surf_workstation_resource->common_public->states.
 581                 failed_action_set);
 582   xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
 583
 584   free(surf_workstation_resource->common_public);
 585   free(surf_workstation_resource->common_private);
 586   free(surf_workstation_resource->extension_public);
 587
 588   free(surf_workstation_resource);
 589   surf_workstation_resource = NULL;
 590 }
 591
 592 static void surf_workstation_resource_init_internal(void)
 593 {
 594   s_surf_action_t action;
 595
 596   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 597
 598   surf_workstation_resource->common_private =
 599       xbt_new0(s_surf_resource_private_t, 1);
 600   surf_workstation_resource->common_public =
 601       xbt_new0(s_surf_resource_public_t, 1);
 602 /*   surf_workstation_resource->extension_private = xbt_new0(s_surf_workstation_resource_extension_private_t,1); */
 603   surf_workstation_resource->extension_public =
 604       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 605
 606   surf_workstation_resource->common_public->states.ready_action_set =
 607       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 608   surf_workstation_resource->common_public->states.running_action_set =
 609       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 610   surf_workstation_resource->common_public->states.failed_action_set =
 611       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 612   surf_workstation_resource->common_public->states.done_action_set =
 613       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 614
 615   surf_workstation_resource->common_public->name_service = name_service;
 616   surf_workstation_resource->common_public->get_resource_name =
 617       get_resource_name;
 618   surf_workstation_resource->common_public->action_get_state =
 619       surf_action_get_state;
 620   surf_workstation_resource->common_public->action_get_start_time =
 621       surf_action_get_start_time;
 622   surf_workstation_resource->common_public->action_get_finish_time =
 623       surf_action_get_finish_time;
 624   surf_workstation_resource->common_public->action_free = action_free;
 625   surf_workstation_resource->common_public->action_use = action_use;
 626   surf_workstation_resource->common_public->action_cancel = action_cancel;
 627   surf_workstation_resource->common_public->action_recycle =
 628       action_recycle;
 629   surf_workstation_resource->common_public->action_change_state =
 630       action_change_state;
 631   surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
 632   surf_workstation_resource->common_public->name = "Workstation";
 633
 634   surf_workstation_resource->common_private->resource_used = resource_used;
 635   surf_workstation_resource->common_private->share_resources =
 636       share_resources;
 637   surf_workstation_resource->common_private->update_actions_state =
 638       update_actions_state;
 639   surf_workstation_resource->common_private->update_resource_state =
 640       update_resource_state;
 641   surf_workstation_resource->common_private->finalize = finalize;
 642
 643   surf_workstation_resource->common_public->suspend = action_suspend;
 644   surf_workstation_resource->common_public->resume = action_resume;
 645   surf_workstation_resource->common_public->is_suspended = action_is_suspended;
 646   surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
 647   surf_workstation_resource->common_public->set_priority = action_set_priority;
 648
 649   surf_workstation_resource->extension_public->execute = execute;
 650   surf_workstation_resource->extension_public->sleep = action_sleep;
 651   surf_workstation_resource->extension_public->get_state = get_state;
 652   surf_workstation_resource->extension_public->get_speed = get_speed;
 653   surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
 654   surf_workstation_resource->extension_public->communicate = communicate;
 655   surf_workstation_resource->extension_public->execute_parallel_task =
 656     execute_parallel_task;
 657   surf_workstation_resource->extension_public->get_route = get_route;
 658   surf_workstation_resource->extension_public->get_route_size = get_route_size;
 659   surf_workstation_resource->extension_public->get_link_name = get_link_name;
 660   surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
 661   surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
 662   workstation_set = xbt_dict_new();
 663
 664   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 665 }
 666
 667 #ifdef USE_GTNETS
 668 /* KF. For GTNetS. This is the same as surf_workstation_resource_init_internal
 669        except for
 670   - surf_workstation_resource->common_private->update_actions_state =
 671       update_actions_state_gtnets;
 672   -  surf_workstation_resource->extension_public->execute_parallel_task =
 673     execute_parallel_task_gtnets;
 674 */
 675 static void surf_workstation_resource_init_internal_gtnets(void)
 676 {
 677   s_surf_action_t action;
 678
 679   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 680
 681   surf_workstation_resource->common_private =
 682       xbt_new0(s_surf_resource_private_t, 1);
 683   surf_workstation_resource->common_public =
 684       xbt_new0(s_surf_resource_public_t, 1);
 685 /*   surf_workstation_resource->extension_private = xbt_new0(s_surf_workstation_resource_extension_private_t,1); */
 686   surf_workstation_resource->extension_public =
 687       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 688
 689   surf_workstation_resource->common_public->states.ready_action_set =
 690       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 691   surf_workstation_resource->common_public->states.running_action_set =
 692       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 693   surf_workstation_resource->common_public->states.failed_action_set =
 694       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 695   surf_workstation_resource->common_public->states.done_action_set =
 696       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 697
 698   surf_workstation_resource->common_public->name_service = name_service;
 699   surf_workstation_resource->common_public->get_resource_name =
 700       get_resource_name;
 701   surf_workstation_resource->common_public->action_get_state =
 702       surf_action_get_state;
 703   surf_workstation_resource->common_public->action_get_start_time =
 704       surf_action_get_start_time;
 705   surf_workstation_resource->common_public->action_get_finish_time =
 706       surf_action_get_finish_time;
 707   surf_workstation_resource->common_public->action_free = action_free;
 708   surf_workstation_resource->common_public->action_use = action_use;
 709   surf_workstation_resource->common_public->action_cancel = action_cancel;
 710   surf_workstation_resource->common_public->action_recycle =
 711       action_recycle;
 712   surf_workstation_resource->common_public->action_change_state =
 713       action_change_state;
 714   surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
 715   surf_workstation_resource->common_public->name = "Workstation";
 716
 717   surf_workstation_resource->common_private->resource_used = resource_used;
 718   surf_workstation_resource->common_private->share_resources =
 719       share_resources;
 720   surf_workstation_resource->common_private->update_actions_state =
 721       update_actions_state_gtnets;
 722   surf_workstation_resource->common_private->update_resource_state =
 723       update_resource_state;
 724   surf_workstation_resource->common_private->finalize = finalize;
 725
 726   surf_workstation_resource->common_public->suspend = action_suspend;
 727   surf_workstation_resource->common_public->resume = action_resume;
 728   surf_workstation_resource->common_public->is_suspended = action_is_suspended;
 729   surf_workstation_resource->common_public->set_max_duration = action_set_max_duration;
 730   surf_workstation_resource->common_public->set_priority = action_set_priority;
 731
 732   surf_workstation_resource->extension_public->execute = execute;
 733   surf_workstation_resource->extension_public->sleep = action_sleep;
 734   surf_workstation_resource->extension_public->get_state = get_state;
 735   surf_workstation_resource->extension_public->get_speed = get_speed;
 736   surf_workstation_resource->extension_public->get_available_speed = get_available_speed;
 737   surf_workstation_resource->extension_public->communicate = communicate;
 738   surf_workstation_resource->extension_public->execute_parallel_task =
 739     execute_parallel_task_gtnets;
 740   surf_workstation_resource->extension_public->get_route = get_route;
 741   surf_workstation_resource->extension_public->get_route_size = get_route_size;
 742   surf_workstation_resource->extension_public->get_link_name = get_link_name;
 743   surf_workstation_resource->extension_public->get_link_bandwidth = get_link_bandwidth;
 744   surf_workstation_resource->extension_public->get_link_latency = get_link_latency;
 745   workstation_set = xbt_dict_new();
 746
 747   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 748 }
 749 #endif
 750
 751 /********************************************************************/
 752 /* The model used in MSG and presented at CCGrid03                  */
 753 /********************************************************************/
 754 /* @InProceedings{Casanova.CLM_03, */
 755 /*   author = {Henri Casanova and Arnaud Legrand and Loris Marchal}, */
 756 /*   title = {Scheduling Distributed Applications: the SimGrid Simulation Framework}, */
 757 /*   booktitle = {Proceedings of the third IEEE International Symposium on Cluster Computing and the Grid (CCGrid'03)}, */
 758 /*   publisher = {"IEEE Computer Society Press"}, */
 759 /*   month = {may}, */
 760 /*   year = {2003} */
 761 /* } */
 762 void surf_workstation_resource_init_CLM03(const char *filename)
 763 {
 764 /*   int i ; */
 765 /*   surf_resource_t resource =  NULL; */
 766
 767   surf_workstation_resource_init_internal();
 768   surf_cpu_resource_init_Cas01(filename);
 769   surf_network_resource_init_CM02(filename);
 770   create_workstations();
 771   xbt_dynar_push(resource_list, &surf_workstation_resource);
 772 /*   xbt_dynar_foreach(resource_list, i, resource) { */
 773 /*     if(resource==surf_cpu_resource) { */
 774 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 775 /*       i--;  */
 776 /*       continue; */
 777 /*     } */
 778 /*     if(resource==surf_network_resource) { */
 779 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 780 /*       i--;  */
 781 /*       continue; */
 782 /*     } */
 783 /*   } */
 784 }
 785
 786 #ifdef USE_GTNETS
 787 /* KF. Use GTNetS for the network. */
 788 void surf_workstation_resource_init_GTNETS(const char *filename)
 789 {
 790   surf_workstation_resource_init_internal_gtnets();
 791   surf_cpu_resource_init_Cas01(filename);
 792   surf_network_resource_init_GTNETS(filename);
 793   create_workstations();
 794   xbt_dynar_push(resource_list, &surf_workstation_resource);
 795 }
 796 #endif