src/surf/workstation_KCCFLN05.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2005 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/dict.h"
   9 #include "workstation_KCCFLN05_private.h"
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation_KCCFLN05, surf,
  12                                 "Logging specific to the SURF workstation module (KCCFLN05)");
  13
  14
  15 static lmm_system_t maxmin_system_cpu_KCCFLN05 = NULL;
  16 static lmm_system_t maxmin_system_network_KCCFLN05 = NULL;
  17 static xbt_dict_t network_link_set = NULL;
  18 static int nb_workstation = 0;
  19 s_route_KCCFLN05_t *routing_table = NULL;
  20 #define ROUTE(i,j) routing_table[(i)+(j)*nb_workstation]
  21
  22 /**************************************/
  23 /************* CPU object *************/
  24 /**************************************/
  25
  26 /************ workstation creation *********/
  27 static void workstation_free(void *workstation)
  28 {
  29   xbt_free(((workstation_KCCFLN05_t)workstation)->name);
  30   xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->incomming_communications));
  31   xbt_dynar_free(&(((workstation_KCCFLN05_t)workstation)->outgoing_communications));
  32   xbt_free(workstation);
  33 }
  34
  35 static workstation_KCCFLN05_t workstation_new(const char *name,
  36                                               double power_scale,
  37                                               double power_initial,
  38                                               tmgr_trace_t power_trace,
  39                                               e_surf_cpu_state_t state_initial,
  40                                               tmgr_trace_t state_trace,
  41                                               double interference_send,
  42                                               double interference_recv,
  43                                               double interference_send_recv,
  44                                               double max_outgoing_rate)
  45 {
  46   workstation_KCCFLN05_t workstation = xbt_new0(s_workstation_KCCFLN05_t, 1);
  47
  48   workstation->resource = (surf_resource_t) surf_workstation_resource;
  49   workstation->name = xbt_strdup(name);
  50   workstation->id = nb_workstation++;
  51
  52   workstation->power_scale = power_scale;
  53   workstation->power_current = power_initial;
  54   if (power_trace)
  55     workstation->power_event =
  56         tmgr_history_add_trace(history, power_trace, 0.0, 0, workstation);
  57
  58   workstation->state_current = state_initial;
  59   if (state_trace)
  60     workstation->state_event =
  61         tmgr_history_add_trace(history, state_trace, 0.0, 0, workstation);
  62
  63   workstation->interference_send=interference_send;
  64   workstation->interference_recv=interference_recv;
  65   workstation->interference_send_recv=interference_send_recv;
  66
  67   workstation->constraint =
  68       lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
  69                          workstation->power_current * workstation->power_scale);
  70   if(max_outgoing_rate>0)
  71     workstation->bus=
  72       lmm_constraint_new(maxmin_system_cpu_KCCFLN05, workstation,
  73                          max_outgoing_rate);
  74
  75   workstation->incomming_communications =
  76     xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
  77   workstation->outgoing_communications =
  78     xbt_dynar_new(sizeof(surf_action_network_KCCFLN05_t),NULL);
  79
  80   xbt_dict_set(workstation_set, name, workstation, workstation_free);
  81
  82   return workstation;
  83 }
  84
  85 static void parse_workstation(void)
  86 {
  87   double power_scale = 0.0;
  88   double power_initial = 0.0;
  89   tmgr_trace_t power_trace = NULL;
  90   e_surf_cpu_state_t state_initial = SURF_CPU_OFF;
  91   tmgr_trace_t state_trace = NULL;
  92   double interference_send = 0.0;
  93   double interference_recv = 0.0;
  94   double interference_send_recv = 0.0;
  95   double max_outgoing_rate = -1.0;
  96
  97   surf_parse_get_double(&power_scale,A_cpu_power);
  98   surf_parse_get_double(&power_initial,A_cpu_availability);
  99   surf_parse_get_trace(&power_trace,A_cpu_availability_file);
 100
 101   xbt_assert0((A_cpu_state==A_cpu_state_ON)||
 102               (A_cpu_state==A_cpu_state_OFF),
 103               "Invalid state")
 104   if (A_cpu_state==A_cpu_state_ON) state_initial = SURF_CPU_ON;
 105   if (A_cpu_state==A_cpu_state_OFF) state_initial = SURF_CPU_OFF;
 106   surf_parse_get_trace(&state_trace,A_cpu_state_file);
 107
 108   surf_parse_get_double(&interference_send,A_cpu_interference_send);
 109   surf_parse_get_double(&interference_recv,A_cpu_interference_recv);
 110   surf_parse_get_double(&interference_send_recv,A_cpu_interference_send_recv);
 111   surf_parse_get_double(&max_outgoing_rate,A_cpu_max_outgoing_rate);
 112
 113   workstation_new(A_cpu_name, power_scale, power_initial, power_trace, state_initial,
 114                   state_trace, interference_send, interference_recv,
 115                   interference_send_recv, max_outgoing_rate);
 116 }
 117
 118 /*********** resource management ***********/
 119
 120 static void *name_service(const char *name)
 121 {
 122   void *workstation = NULL;
 123
 124   xbt_dict_get(workstation_set, name, &workstation);
 125
 126   return workstation;
 127 }
 128
 129 static const char *get_resource_name(void *resource_id)
 130 {
 131   return ((workstation_KCCFLN05_t) resource_id)->name;
 132 }
 133
 134 static int cpu_used(void *resource_id)
 135 {
 136   return lmm_constraint_used(maxmin_system_cpu_KCCFLN05,
 137                              ((workstation_KCCFLN05_t) resource_id)->constraint);
 138 }
 139
 140 static int link_used(void *resource_id)
 141 {
 142   return lmm_constraint_used(maxmin_system_network_KCCFLN05,
 143                              ((network_link_KCCFLN05_t) resource_id)->constraint);
 144 }
 145
 146 static e_surf_cpu_state_t get_state(void *cpu)
 147 {
 148   return ((workstation_KCCFLN05_t) cpu)->state_current;
 149 }
 150
 151 static void update_cpu_KCCFLN05_state(void *id,
 152                                       tmgr_trace_event_t event_type,
 153                                       double value)
 154 {
 155   workstation_KCCFLN05_t cpu = id;
 156
 157   if (event_type == cpu->power_event) {
 158     cpu->power_current = value;
 159     /*** The bound is updated in share_cpu_KCCFLN05_resources ***/
 160     /*     lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05, cpu->constraint, */
 161     /*                          cpu->power_current * cpu->power_scale); */
 162   } else if (event_type == cpu->state_event) {
 163     if (value > 0)
 164       cpu->state_current = SURF_CPU_ON;
 165     else
 166       cpu->state_current = SURF_CPU_OFF;
 167   } else {
 168     CRITICAL0("Unknown event ! \n");
 169     xbt_abort();
 170   }
 171
 172   return;
 173 }
 174
 175 /**************************************/
 176 /*********** network object ***********/
 177 /**************************************/
 178
 179 static void create_routing_table(void)
 180 {
 181   routing_table = xbt_new0(s_route_KCCFLN05_t, nb_workstation * nb_workstation);
 182 }
 183
 184 static void network_link_free(void *nw_link)
 185 {
 186   xbt_free(((network_link_KCCFLN05_t)nw_link)->name);
 187   xbt_free(nw_link);
 188 }
 189
 190 static network_link_KCCFLN05_t network_link_new(char *name,
 191                                                  double bw_initial,
 192                                                  tmgr_trace_t bw_trace,
 193                                                  e_surf_network_link_state_t
 194                                                  state_initial,
 195                                                  tmgr_trace_t state_trace)
 196 {
 197   network_link_KCCFLN05_t nw_link = xbt_new0(s_network_link_KCCFLN05_t, 1);
 198
 199
 200   nw_link->resource = (surf_resource_t) surf_network_resource;
 201   nw_link->name = name;
 202   nw_link->bw_current = bw_initial;
 203   if (bw_trace)
 204     nw_link->bw_event =
 205         tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
 206   nw_link->state_current = state_initial;
 207   if (state_trace)
 208     nw_link->state_event =
 209         tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
 210
 211   nw_link->constraint =
 212       lmm_constraint_new(maxmin_system_network_KCCFLN05, nw_link, nw_link->bw_current);
 213
 214   xbt_dict_set(network_link_set, name, nw_link, network_link_free);
 215
 216   return nw_link;
 217 }
 218
 219 static void parse_network_link(void)
 220 {
 221   char *name;
 222   double bw_initial;
 223   tmgr_trace_t bw_trace;
 224   e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
 225   tmgr_trace_t state_trace;
 226
 227   name = xbt_strdup(A_network_link_name);
 228   surf_parse_get_double(&bw_initial,A_network_link_bandwidth);
 229   surf_parse_get_trace(&bw_trace, A_network_link_bandwidth_file);
 230
 231   xbt_assert0((A_network_link_state==A_network_link_state_ON)||
 232               (A_network_link_state==A_network_link_state_OFF),
 233               "Invalid state")
 234   if (A_network_link_state==A_network_link_state_ON)
 235     state_initial = SURF_NETWORK_LINK_ON;
 236   if (A_network_link_state==A_network_link_state_OFF)
 237     state_initial = SURF_NETWORK_LINK_OFF;
 238   surf_parse_get_trace(&state_trace,A_network_link_state_file);
 239
 240   network_link_new(name, bw_initial, bw_trace, state_initial, state_trace);
 241 }
 242
 243 static void route_new(int src_id, int dst_id, char **links, int nb_link,
 244                       double impact_on_src, double impact_on_dst,
 245                       double impact_on_src_with_other_recv,
 246                       double impact_on_dst_with_other_send)
 247 {
 248   network_link_KCCFLN05_t *link_list = NULL;
 249   int i;
 250   route_KCCFLN05_t route = &(ROUTE(src_id,dst_id));
 251
 252   route->size= nb_link;
 253   link_list = route->links = xbt_new0(network_link_KCCFLN05_t, nb_link);
 254   for (i = 0; i < nb_link; i++) {
 255     xbt_dict_get(network_link_set, links[i], (void *) &(link_list[i]));
 256     xbt_free(links[i]);
 257   }
 258   xbt_free(links);
 259   route->impact_on_src=impact_on_src;
 260   route->impact_on_dst=impact_on_src;
 261   route->impact_on_src_with_other_recv=impact_on_src_with_other_recv;
 262   route->impact_on_dst_with_other_send=impact_on_dst_with_other_send;
 263 }
 264
 265 static int nb_link = 0;
 266 static char **link_name = NULL;
 267 static int src_id = -1;
 268 static int dst_id = -1;
 269 static double impact_on_src;
 270 static double impact_on_dst;
 271 static double impact_on_src_with_other_recv;
 272 static double impact_on_dst_with_other_send;
 273
 274 static void parse_route_set_endpoints(void)
 275 {
 276   src_id = ((workstation_KCCFLN05_t) name_service(A_route_src))->id;
 277   dst_id = ((workstation_KCCFLN05_t) name_service(A_route_dst))->id;
 278   surf_parse_get_double(&impact_on_src,A_route_impact_on_src);
 279   surf_parse_get_double(&impact_on_dst,A_route_impact_on_dst);
 280   surf_parse_get_double(&impact_on_src_with_other_recv,A_route_impact_on_src_with_other_recv);
 281   surf_parse_get_double(&impact_on_dst_with_other_send,A_route_impact_on_dst_with_other_send);
 282
 283   nb_link = 0;
 284   link_name = NULL;
 285 }
 286
 287 static void parse_route_elem(void)
 288 {
 289   nb_link++;
 290   link_name = xbt_realloc(link_name, (nb_link) * sizeof(char *));
 291   link_name[(nb_link) - 1] = xbt_strdup(A_route_element_name);
 292 }
 293
 294 static void parse_route_set_route(void)
 295 {
 296   route_new(src_id, dst_id, link_name, nb_link, impact_on_src, impact_on_dst,
 297             impact_on_src_with_other_recv, impact_on_dst_with_other_send);
 298 }
 299
 300 static void parse_file(const char *file)
 301 {
 302   /* Figuring out the workstations */
 303   surf_parse_reset_parser();
 304   ETag_cpu_fun=parse_workstation;
 305   surf_parse_open(file);
 306   xbt_assert1((!surf_parse()),"Parse error in %s",file);
 307   surf_parse_close();
 308
 309   create_routing_table();
 310
 311   /* Figuring out the network links */
 312   surf_parse_reset_parser();
 313   ETag_network_link_fun=parse_network_link;
 314   surf_parse_open(file);
 315   xbt_assert1((!surf_parse()),"Parse error in %s",file);
 316   surf_parse_close();
 317
 318   /* Building the routes */
 319   surf_parse_reset_parser();
 320   STag_route_fun=parse_route_set_endpoints;
 321   ETag_route_element_fun=parse_route_elem;
 322   ETag_route_fun=parse_route_set_route;
 323   surf_parse_open(file);
 324   xbt_assert1((!surf_parse()),"Parse error in %s",file);
 325   surf_parse_close();
 326 }
 327
 328 static void update_network_KCCFLN05_state(void *id,
 329                                           tmgr_trace_event_t event_type,
 330                                           double value)
 331 {
 332   network_link_KCCFLN05_t nw_link = id;
 333
 334   if (event_type == nw_link->bw_event) {
 335     nw_link->bw_current = value;
 336     lmm_update_constraint_bound(maxmin_system_network_KCCFLN05, nw_link->constraint,
 337                                 nw_link->bw_current);
 338   } else if (event_type == nw_link->state_event) {
 339     if (value > 0)
 340       nw_link->state_current = SURF_NETWORK_LINK_ON;
 341     else
 342       nw_link->state_current = SURF_NETWORK_LINK_OFF;
 343   } else {
 344     CRITICAL0("Unknown event ! \n");
 345     xbt_abort();
 346   }
 347
 348   return;
 349 }
 350
 351 /**************************************/
 352 /*************** actions **************/
 353 /**************************************/
 354 /*************** network **************/
 355 static void action_network_KCCFLN05_free(surf_action_t action)
 356 {
 357   int cpt;
 358   surf_action_t act = NULL;
 359   workstation_KCCFLN05_t src = ((surf_action_network_KCCFLN05_t) action)->src;
 360   workstation_KCCFLN05_t dst = ((surf_action_network_KCCFLN05_t) action)->dst;
 361
 362   xbt_swag_remove(action, action->state_set);
 363   lmm_variable_free(maxmin_system_network_KCCFLN05,
 364                     ((surf_action_network_KCCFLN05_t) action)->variable);
 365
 366   xbt_dynar_foreach (src->outgoing_communications,cpt,act) {
 367     if(act==action) {
 368       xbt_dynar_remove_at(src->outgoing_communications, cpt, &act);
 369       break;
 370     }
 371   }
 372
 373   xbt_dynar_foreach (dst->incomming_communications,cpt,act) {
 374     if(act==action) {
 375       xbt_dynar_remove_at(dst->incomming_communications, cpt, &act);
 376       break;
 377     }
 378   }
 379
 380   xbt_free(action);
 381 }
 382
 383 static double share_network_KCCFLN05_resources(double now)
 384 {
 385  s_surf_action_network_KCCFLN05_t action;
 386  return generic_maxmin_share_resources2(surf_network_resource->common_public->
 387                                         states.running_action_set,
 388                                         xbt_swag_offset(action, variable),
 389                                         maxmin_system_network_KCCFLN05);
 390 }
 391
 392 static void action_network_KCCFLN05_change_state(surf_action_t action,
 393                                                  e_surf_action_state_t state)
 394 {
 395   surf_action_change_state(action, state);
 396   return;
 397 }
 398
 399 static void update_actions_network_KCCFLN05_state(double now, double delta)
 400 {
 401   surf_action_network_KCCFLN05_t action = NULL;
 402   surf_action_network_KCCFLN05_t next_action = NULL;
 403   xbt_swag_t running_actions =
 404       surf_network_resource->common_public->states.running_action_set;
 405   xbt_swag_t failed_actions =
 406       surf_network_resource->common_public->states.failed_action_set;
 407
 408   xbt_swag_foreach_safe(action, next_action, running_actions) {
 409     surf_double_update(&(action->generic_action.remains),
 410                        lmm_variable_getvalue(action->variable) * delta);
 411     if (action->generic_action.max_duration != NO_MAX_DURATION)
 412           surf_double_update(&(action->generic_action.max_duration), delta);
 413     if ((action->generic_action.remains <= 0.0) &&
 414         (lmm_get_variable_weight(action->variable)>0)) {
 415       action->generic_action.finish = surf_get_clock();
 416       action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
 417     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 418                (action->generic_action.max_duration <= 0.0)) {
 419       action->generic_action.finish = surf_get_clock();
 420       action_network_KCCFLN05_change_state((surf_action_t) action, SURF_ACTION_DONE);
 421     } else {                    /* Need to check that none of the resource has failed */
 422       /* FIXME : FAILURES ARE NOT HANDLED YET */
 423     }
 424   }
 425
 426   xbt_swag_foreach_safe(action, next_action, failed_actions) {
 427     lmm_variable_disable(maxmin_system_network_KCCFLN05, action->variable);
 428   }
 429
 430   return;
 431 }
 432
 433 static surf_action_t communicate_KCCFLN05(void *src, void *dst, double size,
 434                                           double rate)
 435 {
 436   surf_action_network_KCCFLN05_t action = NULL;
 437   workstation_KCCFLN05_t card_src = src;
 438   workstation_KCCFLN05_t card_dst = dst;
 439   route_KCCFLN05_t route = &ROUTE(card_src->id, card_dst->id);
 440   int i;
 441
 442   action = xbt_new0(s_surf_action_network_KCCFLN05_t, 1);
 443
 444   action->generic_action.cost = size;
 445   action->generic_action.remains = size;
 446   action->generic_action.max_duration = NO_MAX_DURATION;
 447   action->generic_action.start = -1.0;
 448   action->generic_action.finish = -1.0;
 449   action->generic_action.resource_type =
 450       (surf_resource_t) surf_network_resource;
 451
 452   action->generic_action.state_set =
 453       surf_network_resource->common_public->states.running_action_set;
 454
 455   xbt_swag_insert(action, action->generic_action.state_set);
 456
 457   if(rate>0)
 458     action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, rate,
 459                                         route->size+1);
 460   else
 461     action->variable = lmm_variable_new(maxmin_system_network_KCCFLN05, action, 1.0, -1.0,
 462                                         route->size+1);
 463
 464   for (i = 0; i < route->size; i++)
 465     lmm_expand(maxmin_system_network_KCCFLN05, route->links[i]->constraint,
 466                action->variable, 1.0);
 467
 468   if(card_src->bus)
 469     lmm_expand(maxmin_system_network_KCCFLN05, card_src->bus,
 470                action->variable, 1.0);
 471
 472   action->src=src;
 473   action->dst=dst;
 474
 475   xbt_dynar_push(card_src->outgoing_communications,&action);
 476   xbt_dynar_push(card_dst->incomming_communications,&action);
 477
 478   return (surf_action_t) action;
 479 }
 480
 481 static void network_KCCFLN05_action_suspend(surf_action_t action)
 482 {
 483   lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
 484                              ((surf_action_network_KCCFLN05_t) action)->variable, 0.0);
 485 }
 486
 487 static void network_KCCFLN05_action_resume(surf_action_t action)
 488 {
 489   lmm_update_variable_weight(maxmin_system_network_KCCFLN05,
 490                              ((surf_action_network_KCCFLN05_t) action)->variable, 1.0);
 491 }
 492
 493 static int network_KCCFLN05_action_is_suspended(surf_action_t action)
 494 {
 495   return (lmm_get_variable_weight(((surf_action_network_KCCFLN05_t) action)->variable) == 0.0);
 496 }
 497
 498 /***************** CPU ****************/
 499 static void action_cpu_KCCFLN05_free(surf_action_t action)
 500 {
 501   xbt_swag_remove(action, action->state_set);
 502   lmm_variable_free(maxmin_system_cpu_KCCFLN05, ((surf_action_cpu_KCCFLN05_t)action)->variable);
 503   xbt_free(action);
 504 }
 505
 506 /* #define WARNING(format, ...) (fprintf(stderr, "[%s , %s : %d] ", __FILE__, __FUNCTION__, __LINE__),\ */
 507 /*                               fprintf(stderr, format, ## __VA_ARGS__), \ */
 508 /*                               fprintf(stderr, "\n")) */
 509 /* #define VOIRP(expr) WARNING("  {" #expr " = %p }", expr) */
 510 /* #define VOIRD(expr) WARNING("  {" #expr " = %d }", expr) */
 511 /* #define VOIRG(expr) WARNING("  {" #expr " = %lg }", expr) */
 512
 513 static double share_cpu_KCCFLN05_resources(double now)
 514 {
 515   s_surf_action_cpu_KCCFLN05_t s_cpu_action;
 516   lmm_constraint_t cnst = NULL;
 517   workstation_KCCFLN05_t workstation = NULL;
 518   double W=0.0;
 519   double scale=0.0;
 520   int cpt;
 521   surf_action_network_KCCFLN05_t action;
 522
 523   for(cnst = lmm_get_first_active_constraint(maxmin_system_cpu_KCCFLN05);
 524       cnst;
 525       cnst= lmm_get_next_active_constraint(maxmin_system_cpu_KCCFLN05, cnst))
 526     {
 527       workstation = lmm_constraint_id(cnst);
 528       W=workstation->power_current * workstation->power_scale;
 529
 530       if((!xbt_dynar_length(workstation->incomming_communications)) &&
 531          (!xbt_dynar_length(workstation->outgoing_communications))) {
 532         scale = 1.0;
 533       } else if((!xbt_dynar_length(workstation->incomming_communications)) &&
 534                 (xbt_dynar_length(workstation->outgoing_communications))) {
 535         scale = workstation->interference_send;
 536         xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
 537 /*        VOIRD(action->src->id); */
 538 /*        VOIRD(action->dst->id); */
 539 /*        VOIRP(&ROUTE(action->src->id,action->dst->id)); */
 540 /*        VOIRG(ROUTE(action->src->id,action->dst->id).impact_on_src); */
 541           scale -= ROUTE(action->src->id,action->dst->id).impact_on_src *
 542             lmm_variable_getvalue(action->variable);
 543         }
 544         if(scale<0.0) scale=0.0;
 545         xbt_assert0(scale>=0.0,"Negative interference !");
 546       } else if((xbt_dynar_length(workstation->incomming_communications)) &&
 547                 (!xbt_dynar_length(workstation->outgoing_communications))) {
 548         scale = workstation->interference_recv;
 549         xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
 550           scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst *
 551             lmm_variable_getvalue(action->variable);
 552         }
 553         if(scale<0.0) scale=0.0;
 554         xbt_assert0(scale>=0.0,"Negative interference !");
 555       } else {
 556         scale = workstation->interference_send_recv;
 557         xbt_dynar_foreach (workstation->outgoing_communications,cpt,action) {
 558           scale -= ROUTE(action->src->id,action->dst->id).impact_on_src_with_other_recv *
 559             lmm_variable_getvalue(action->variable);
 560         }
 561         xbt_dynar_foreach (workstation->incomming_communications,cpt,action) {
 562           scale -= ROUTE(action->src->id,action->dst->id).impact_on_dst_with_other_send *
 563             lmm_variable_getvalue(action->variable);
 564         }
 565         if(scale<0.0) scale=0.0;
 566         xbt_assert0(scale>=0.0,"Negative interference !");
 567       }
 568       lmm_update_constraint_bound(maxmin_system_cpu_KCCFLN05,workstation->constraint,
 569                                   W*scale);
 570     }
 571
 572   return generic_maxmin_share_resources2(surf_cpu_resource->common_public->
 573                                          states.running_action_set,
 574                                          xbt_swag_offset(s_cpu_action, variable),
 575                                          maxmin_system_cpu_KCCFLN05);
 576 }
 577
 578 static void update_actions_cpu_KCCFLN05_state(double now, double delta)
 579 {
 580   surf_action_cpu_KCCFLN05_t action = NULL;
 581   surf_action_cpu_KCCFLN05_t next_action = NULL;
 582   xbt_swag_t running_actions =
 583       surf_cpu_resource->common_public->states.running_action_set;
 584   xbt_swag_t failed_actions =
 585       surf_cpu_resource->common_public->states.failed_action_set;
 586
 587   xbt_swag_foreach_safe(action, next_action, running_actions) {
 588     surf_double_update(&(action->generic_action.remains),
 589         lmm_variable_getvalue(action->variable) * delta);
 590     if (action->generic_action.max_duration != NO_MAX_DURATION)
 591       action->generic_action.max_duration -= delta;
 592     if ((action->generic_action.remains <= 0) &&
 593         (lmm_get_variable_weight(action->variable)>0)) {
 594       action->generic_action.finish = surf_get_clock();
 595       surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 596     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 597                (action->generic_action.max_duration <= 0)) {
 598       action->generic_action.finish = surf_get_clock();
 599       surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 600     } else {                    /* Need to check that none of the resource has failed */
 601       lmm_constraint_t cnst = NULL;
 602       int i = 0;
 603       workstation_KCCFLN05_t cpu = NULL;
 604
 605       while ((cnst =
 606               lmm_get_cnst_from_var(maxmin_system_cpu_KCCFLN05, action->variable,
 607                                     i++))) {
 608         cpu = lmm_constraint_id(cnst);
 609         if (cpu->state_current == SURF_CPU_OFF) {
 610           action->generic_action.finish = surf_get_clock();
 611           surf_action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 612           break;
 613         }
 614       }
 615     }
 616   }
 617
 618   xbt_swag_foreach_safe(action, next_action, failed_actions) {
 619     lmm_variable_disable(maxmin_system_cpu_KCCFLN05, action->variable);
 620   }
 621
 622   return;
 623 }
 624
 625 static surf_action_t execute_KCCFLN05(void *cpu, double size)
 626 {
 627   surf_action_cpu_KCCFLN05_t action = NULL;
 628   workstation_KCCFLN05_t CPU = cpu;
 629
 630   action = xbt_new0(s_surf_action_cpu_KCCFLN05_t, 1);
 631
 632   action->generic_action.cost = size;
 633   action->generic_action.remains = size;
 634   action->generic_action.max_duration = NO_MAX_DURATION;
 635   action->generic_action.start = surf_get_clock();
 636   action->generic_action.finish = -1.0;
 637   action->generic_action.resource_type =
 638       (surf_resource_t) surf_cpu_resource;
 639
 640   if (CPU->state_current == SURF_CPU_ON)
 641     action->generic_action.state_set =
 642         surf_cpu_resource->common_public->states.running_action_set;
 643   else
 644     action->generic_action.state_set =
 645         surf_cpu_resource->common_public->states.failed_action_set;
 646   xbt_swag_insert(action, action->generic_action.state_set);
 647
 648   action->variable = lmm_variable_new(maxmin_system_cpu_KCCFLN05, action, 1.0, -1.0, 1);
 649   lmm_expand(maxmin_system_cpu_KCCFLN05, CPU->constraint, action->variable,
 650              1.0);
 651
 652   return (surf_action_t) action;
 653 }
 654
 655 static void cpu_KCCFLN05_action_suspend(surf_action_t action)
 656 {
 657   lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
 658                              ((surf_action_cpu_KCCFLN05_t) action)->variable, 0.0);
 659 }
 660
 661 static void cpu_KCCFLN05_action_resume(surf_action_t action)
 662 {
 663   lmm_update_variable_weight(maxmin_system_cpu_KCCFLN05,
 664                              ((surf_action_cpu_KCCFLN05_t) action)->variable, 1.0);
 665 }
 666
 667 static int cpu_KCCFLN05_action_is_suspended(surf_action_t action)
 668 {
 669   return (lmm_get_variable_weight(((surf_action_cpu_KCCFLN05_t) action)->variable) == 0.0);
 670 }
 671
 672 /************* workstation ************/
 673 static void action_change_state(surf_action_t action,
 674                                 e_surf_action_state_t state)
 675 {
 676   xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
 677   surf_action_change_state(action, state);
 678   return;
 679 }
 680
 681 static void action_free(surf_action_t action)
 682 {
 683   xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
 684   return;
 685 }
 686
 687 static int resource_used(void *resource_id)
 688 {
 689   xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
 690   return 0;
 691 }
 692
 693 static double share_resources(double now)
 694 {
 695   return -1.0;
 696 }
 697
 698 static void update_actions_state(double now, double delta)
 699 {
 700   return;
 701 }
 702
 703 static void update_resource_state(void *id,
 704                                   tmgr_trace_event_t event_type,
 705                                   double value)
 706 {
 707   xbt_assert0(0, "Workstation is a virtual resource. I should not be there!");
 708   return;
 709 }
 710
 711 static void action_suspend(surf_action_t action)
 712 {
 713   if(action->resource_type==(surf_resource_t)surf_network_resource)
 714     surf_network_resource->common_public->suspend(action);
 715   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 716     surf_cpu_resource->common_public->suspend(action);
 717   else DIE_IMPOSSIBLE;
 718 }
 719
 720 static void action_resume(surf_action_t action)
 721 {
 722   if(action->resource_type==(surf_resource_t)surf_network_resource)
 723     surf_network_resource->common_public->resume(action);
 724   else if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 725     surf_cpu_resource->common_public->resume(action);
 726   else DIE_IMPOSSIBLE;
 727 }
 728
 729 static int action_is_suspended(surf_action_t action)
 730 {
 731   if(action->resource_type==(surf_resource_t)surf_network_resource)
 732     return surf_network_resource->common_public->is_suspended(action);
 733   if(action->resource_type==(surf_resource_t)surf_cpu_resource)
 734     return surf_cpu_resource->common_public->is_suspended(action);
 735   DIE_IMPOSSIBLE;
 736 }
 737
 738 /**************************************/
 739 /********* Module  creation ***********/
 740 /**************************************/
 741 static void cpu_KCCFLN05_finalize(void)
 742 {
 743   xbt_dict_free(&workstation_set);
 744   xbt_swag_free(surf_cpu_resource->common_public->states.ready_action_set);
 745   xbt_swag_free(surf_cpu_resource->common_public->states.
 746                 running_action_set);
 747   xbt_swag_free(surf_cpu_resource->common_public->states.
 748                 failed_action_set);
 749   xbt_swag_free(surf_cpu_resource->common_public->states.done_action_set);
 750   xbt_free(surf_cpu_resource->common_public);
 751   xbt_free(surf_cpu_resource->common_private);
 752   xbt_free(surf_cpu_resource->extension_public);
 753
 754   xbt_free(surf_cpu_resource);
 755   surf_cpu_resource = NULL;
 756
 757   if (maxmin_system_cpu_KCCFLN05) {
 758     lmm_system_free(maxmin_system_cpu_KCCFLN05);
 759     maxmin_system_cpu_KCCFLN05 = NULL;
 760   }
 761 }
 762
 763 static void cpu_KCCFLN05_resource_init_internal(void)
 764 {
 765   s_surf_action_t action;
 766
 767   surf_cpu_resource = xbt_new0(s_surf_cpu_resource_t, 1);
 768
 769   surf_cpu_resource->common_private =
 770       xbt_new0(s_surf_resource_private_t, 1);
 771   surf_cpu_resource->common_public =
 772     xbt_new0(s_surf_resource_public_t, 1);
 773
 774   surf_cpu_resource->extension_public =
 775       xbt_new0(s_surf_cpu_resource_extension_public_t, 1);
 776
 777   surf_cpu_resource->common_public->states.ready_action_set =
 778       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 779   surf_cpu_resource->common_public->states.running_action_set =
 780       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 781   surf_cpu_resource->common_public->states.failed_action_set =
 782       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 783   surf_cpu_resource->common_public->states.done_action_set =
 784       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 785
 786   surf_cpu_resource->common_public->name_service = name_service;
 787   surf_cpu_resource->common_public->get_resource_name = get_resource_name;
 788   surf_cpu_resource->common_public->action_get_state =
 789       surf_action_get_state;
 790   surf_cpu_resource->common_public->action_free = action_cpu_KCCFLN05_free;
 791   surf_cpu_resource->common_public->action_cancel = NULL;
 792   surf_cpu_resource->common_public->action_recycle = NULL;
 793   surf_cpu_resource->common_public->action_change_state = surf_action_change_state;
 794   surf_cpu_resource->common_public->action_set_data = surf_action_set_data;
 795   surf_cpu_resource->common_public->name = "CPU KCCFLN05";
 796
 797   surf_cpu_resource->common_private->resource_used = cpu_used;
 798   surf_cpu_resource->common_private->share_resources = share_cpu_KCCFLN05_resources;
 799   surf_cpu_resource->common_private->update_actions_state =
 800     update_actions_cpu_KCCFLN05_state;
 801   surf_cpu_resource->common_private->update_resource_state =
 802       update_cpu_KCCFLN05_state;
 803   surf_cpu_resource->common_private->finalize = cpu_KCCFLN05_finalize;
 804
 805   surf_cpu_resource->extension_public->execute = execute_KCCFLN05;
 806 /*FIXME*//*   surf_cpu_resource->extension_public->sleep = action_sleep; */
 807
 808   surf_cpu_resource->common_public->suspend = cpu_KCCFLN05_action_suspend;
 809   surf_cpu_resource->common_public->resume = cpu_KCCFLN05_action_resume;
 810   surf_cpu_resource->common_public->is_suspended = cpu_KCCFLN05_action_is_suspended;
 811
 812   surf_cpu_resource->extension_public->get_state = get_state;
 813
 814   workstation_set = xbt_dict_new();
 815
 816   maxmin_system_cpu_KCCFLN05 = lmm_system_new();
 817 }
 818
 819 static void network_KCCFLN05_finalize(void)
 820 {
 821   int i,j;
 822
 823   xbt_dict_free(&network_link_set);
 824   xbt_swag_free(surf_network_resource->common_public->states.
 825                 ready_action_set);
 826   xbt_swag_free(surf_network_resource->common_public->states.
 827                 running_action_set);
 828   xbt_swag_free(surf_network_resource->common_public->states.
 829                 failed_action_set);
 830   xbt_swag_free(surf_network_resource->common_public->states.
 831                 done_action_set);
 832   xbt_free(surf_network_resource->common_public);
 833   xbt_free(surf_network_resource->common_private);
 834   xbt_free(surf_network_resource->extension_public);
 835
 836   xbt_free(surf_network_resource);
 837   surf_network_resource = NULL;
 838
 839   for (i = 0; i < nb_workstation; i++)
 840     for (j = 0; j < nb_workstation; j++)
 841       xbt_free(ROUTE(i,j).links);
 842   xbt_free(routing_table);
 843   routing_table = NULL;
 844   nb_workstation = 0;
 845
 846   if (maxmin_system_network_KCCFLN05) {
 847     lmm_system_free(maxmin_system_network_KCCFLN05);
 848     maxmin_system_network_KCCFLN05 = NULL;
 849   }
 850 }
 851
 852 static void network_KCCFLN05_resource_init_internal(void)
 853 {
 854   s_surf_action_t action;
 855
 856   surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
 857
 858   surf_network_resource->common_private =
 859       xbt_new0(s_surf_resource_private_t, 1);
 860   surf_network_resource->common_public =
 861       xbt_new0(s_surf_resource_public_t, 1);
 862   surf_network_resource->extension_public =
 863       xbt_new0(s_surf_network_resource_extension_public_t, 1);
 864
 865   surf_network_resource->common_public->states.ready_action_set =
 866       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 867   surf_network_resource->common_public->states.running_action_set =
 868       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 869   surf_network_resource->common_public->states.failed_action_set =
 870       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 871   surf_network_resource->common_public->states.done_action_set =
 872       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 873
 874   surf_network_resource->common_public->name_service = name_service;
 875   surf_network_resource->common_public->get_resource_name = get_resource_name;
 876   surf_network_resource->common_public->action_get_state =
 877       surf_action_get_state;
 878   surf_network_resource->common_public->action_free = action_network_KCCFLN05_free;
 879   surf_network_resource->common_public->action_cancel = NULL;
 880   surf_network_resource->common_public->action_recycle = NULL;
 881   surf_network_resource->common_public->action_change_state = action_network_KCCFLN05_change_state;
 882   surf_network_resource->common_public->action_set_data = surf_action_set_data;
 883   surf_network_resource->common_public->name = "network KCCFLN05";
 884
 885   surf_network_resource->common_private->resource_used = link_used;
 886   surf_network_resource->common_private->share_resources = share_network_KCCFLN05_resources;
 887   surf_network_resource->common_private->update_actions_state =
 888     update_actions_network_KCCFLN05_state;
 889   surf_network_resource->common_private->update_resource_state =
 890     update_network_KCCFLN05_state;
 891   surf_network_resource->common_private->finalize = network_KCCFLN05_finalize;
 892
 893   surf_network_resource->common_public->suspend = network_KCCFLN05_action_suspend;
 894   surf_network_resource->common_public->resume = network_KCCFLN05_action_resume;
 895   surf_network_resource->common_public->is_suspended = network_KCCFLN05_action_is_suspended;
 896
 897   surf_network_resource->extension_public->communicate = communicate_KCCFLN05;
 898
 899   network_link_set = xbt_dict_new();
 900
 901
 902   maxmin_system_network_KCCFLN05 = lmm_system_new();
 903 }
 904
 905 static void workstation_KCCFLN05_finalize(void)
 906 {
 907   xbt_swag_free(surf_workstation_resource->common_public->states.ready_action_set);
 908   xbt_swag_free(surf_workstation_resource->common_public->states.running_action_set);
 909   xbt_swag_free(surf_workstation_resource->common_public->states.failed_action_set);
 910   xbt_swag_free(surf_workstation_resource->common_public->states.done_action_set);
 911
 912   xbt_free(surf_workstation_resource->common_public);
 913   xbt_free(surf_workstation_resource->common_private);
 914   xbt_free(surf_workstation_resource->extension_public);
 915
 916   xbt_free(surf_workstation_resource);
 917   surf_workstation_resource = NULL;
 918 }
 919
 920 static void workstation_KCCFLN05_resource_init_internal(void)
 921 {
 922   s_surf_action_t action;
 923
 924   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 925
 926   surf_workstation_resource->common_private =
 927       xbt_new0(s_surf_resource_private_t, 1);
 928   surf_workstation_resource->common_public =
 929       xbt_new0(s_surf_resource_public_t, 1);
 930   surf_workstation_resource->extension_public =
 931       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 932
 933   surf_workstation_resource->common_public->states.ready_action_set =
 934       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 935   surf_workstation_resource->common_public->states.running_action_set =
 936       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 937   surf_workstation_resource->common_public->states.failed_action_set =
 938       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 939   surf_workstation_resource->common_public->states.done_action_set =
 940       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 941
 942   surf_workstation_resource->common_public->name_service = name_service;
 943   surf_workstation_resource->common_public->get_resource_name =
 944       get_resource_name;
 945   surf_workstation_resource->common_public->action_get_state =
 946       surf_action_get_state;
 947   surf_workstation_resource->common_public->action_free = action_free;
 948   surf_workstation_resource->common_public->action_cancel = NULL;
 949   surf_workstation_resource->common_public->action_recycle = NULL;
 950   surf_workstation_resource->common_public->action_change_state = action_change_state;
 951   surf_workstation_resource->common_public->action_set_data = surf_action_set_data;
 952   surf_workstation_resource->common_public->name = "Workstation KCCFLN05";
 953
 954   surf_workstation_resource->common_private->resource_used = resource_used;
 955   surf_workstation_resource->common_private->share_resources = share_resources;
 956   surf_workstation_resource->common_private->update_actions_state = update_actions_state;
 957   surf_workstation_resource->common_private->update_resource_state = update_resource_state;
 958   surf_workstation_resource->common_private->finalize = workstation_KCCFLN05_finalize;
 959
 960
 961   surf_workstation_resource->common_public->suspend = action_suspend;
 962   surf_workstation_resource->common_public->resume = action_resume;
 963   surf_workstation_resource->common_public->is_suspended = action_is_suspended;
 964
 965   surf_workstation_resource->extension_public->execute = execute_KCCFLN05;
 966 /*FIXME*//*  surf_workstation_resource->extension_public->sleep = action_sleep; */
 967   surf_workstation_resource->extension_public->get_state = get_state;
 968   surf_workstation_resource->extension_public->communicate = communicate_KCCFLN05;
 969 }
 970
 971 /**************************************/
 972 /*************** Generic **************/
 973 /**************************************/
 974
 975 void surf_workstation_resource_init_KCCFLN05(const char *filename)
 976 {
 977   xbt_assert0(!surf_cpu_resource,"CPU resource type already defined");
 978   cpu_KCCFLN05_resource_init_internal();
 979   xbt_assert0(!surf_network_resource,"network resource type already defined");
 980   network_KCCFLN05_resource_init_internal();
 981   workstation_KCCFLN05_resource_init_internal();
 982   parse_file(filename);
 983
 984   xbt_dynar_push(resource_list, &surf_network_resource);
 985   xbt_dynar_push(resource_list, &surf_cpu_resource);
 986   xbt_dynar_push(resource_list, &surf_workstation_resource);
 987
 988   if (maxmin_system) { /* To avoid using this useless system */
 989     lmm_system_free(maxmin_system);
 990     maxmin_system = NULL;
 991   }
 992 }