src/surf/network.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 "network_private.h"
   9 #include "xbt/dict.h"
  10
  11 #define SG_TCP_CTE_GAMMA 20000.0
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(network, surf,
  14                                 "Logging specific to the SURF network module");
  15
  16 surf_network_resource_t surf_network_resource = NULL;
  17
  18 static xbt_dict_t network_link_set = NULL;
  19 static xbt_dict_t network_card_set = NULL;
  20
  21 static int card_number = 0;
  22 static network_link_t **routing_table = NULL;
  23 static int *routing_table_size = NULL;
  24
  25 #define ROUTE(i,j) routing_table[(i)+(j)*card_number]
  26 #define ROUTE_SIZE(i,j) routing_table_size[(i)+(j)*card_number]
  27
  28 static void create_routing_table(void)
  29 {
  30   routing_table = xbt_new0(network_link_t *,card_number*card_number);
  31   routing_table_size = xbt_new0(int,card_number*card_number);
  32 }
  33
  34 static void network_link_free(void *nw_link)
  35 {
  36   xbt_free(nw_link);
  37 }
  38
  39 static network_link_t network_link_new(const char *name,
  40                                        xbt_maxmin_float_t bw_initial,
  41                                        tmgr_trace_t bw_trace,
  42                                        xbt_maxmin_float_t lat_initial,
  43                                        tmgr_trace_t lat_trace,
  44                                        e_surf_network_link_state_t state_initial,
  45                                        tmgr_trace_t state_trace)
  46 {
  47   network_link_t nw_link = xbt_new0(s_network_link_t, 1);
  48
  49
  50   nw_link->resource = (surf_resource_t) surf_network_resource;
  51   nw_link->name = name;
  52   nw_link->bw_current = bw_initial;
  53   if (bw_trace)
  54     nw_link->bw_event =
  55         tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
  56   nw_link->lat_current = lat_initial;
  57   if (lat_trace)
  58     nw_link->lat_event =
  59         tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
  60   nw_link->state_current = state_initial;
  61   if (state_trace)
  62     nw_link->state_event =
  63         tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
  64
  65   nw_link->constraint =
  66       lmm_constraint_new(maxmin_system, nw_link,
  67                          nw_link->bw_current);
  68
  69   xbt_dict_set(network_link_set, name, nw_link, network_link_free);
  70
  71   return nw_link;
  72 }
  73
  74 static int network_card_new(const char *card_name)
  75 {
  76   network_card_t card = NULL;
  77
  78   xbt_dict_get(network_card_set, card_name, (void *) &card);
  79
  80   if(!card) {
  81     card = xbt_new0(s_network_card_t,1);
  82     card->name=xbt_strdup(card_name);
  83     card->id=card_number++;
  84     xbt_dict_set(network_card_set, card_name, card, NULL);
  85   }
  86   return card->id;
  87 }
  88
  89 static void route_new(int src_id, int dst_id,
  90                       char* *links, int nb_link)
  91 {
  92   network_link_t *link_list = NULL;
  93   int i ;
  94
  95   ROUTE_SIZE(src_id,dst_id) = nb_link;
  96   link_list = (ROUTE(src_id,dst_id) = xbt_new0(network_link_t,nb_link));
  97   for(i=0; i < nb_link; i++) {
  98     xbt_dict_get(network_link_set,links[i], (void *) &(link_list[i]));
  99     xbt_free(links[i]);
 100   }
 101   xbt_free(links);
 102 }
 103
 104 /*
 105    Semantic:  name       initial   bandwidth   initial   latency    initial     state
 106                         bandwidth    trace     latency    trace      state      trace
 107
 108    Token:   TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD TOKEN_WORD
 109    Type:     string       float      string    float      string     ON/OFF     string
 110 */
 111 static void parse_network_link(void)
 112 {
 113   e_surf_token_t token;
 114   char *name;
 115   xbt_maxmin_float_t bw_initial;
 116   tmgr_trace_t bw_trace;
 117   xbt_maxmin_float_t lat_initial;
 118   tmgr_trace_t lat_trace;
 119   e_surf_network_link_state_t state_initial;
 120   tmgr_trace_t state_trace;
 121
 122   name = xbt_strdup(surf_parse_text);
 123
 124   surf_parse_float(&bw_initial);
 125   surf_parse_trace(&bw_trace);
 126   surf_parse_float(&lat_initial);
 127   surf_parse_trace(&lat_trace);
 128
 129   token = surf_parse();         /* state_initial */
 130   xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos);
 131   if (strcmp(surf_parse_text, "ON") == 0)
 132     state_initial = SURF_NETWORK_LINK_ON;
 133   else if (strcmp(surf_parse_text, "OFF") == 0)
 134     state_initial = SURF_NETWORK_LINK_OFF;
 135   else {
 136     CRITICAL2("Invalid cpu state (line %d): %s neq ON or OFF\n", line_pos,
 137               surf_parse_text);
 138     xbt_abort();
 139   }
 140
 141   surf_parse_trace(&state_trace);
 142
 143   network_link_new(name, bw_initial, bw_trace,
 144                    lat_initial, lat_trace,
 145                    state_initial, state_trace);
 146 }
 147
 148 /*
 149    Semantic:  source   destination           network
 150                                               links
 151
 152    Token:   TOKEN_WORD TOKEN_WORD TOKEN_LP TOKEN_WORD* TOKEN_RP
 153    Type:     string       string             string
 154 */
 155 static void parse_route(int fake)
 156 {
 157   int src_id = -1;
 158   int dst_id = -1;
 159   int nb_link = 0;
 160   char **link_name = NULL;
 161   e_surf_token_t token;
 162
 163   src_id = network_card_new(surf_parse_text);
 164
 165   token = surf_parse();
 166   xbt_assert1((token == TOKEN_WORD), "Parse error line %d", line_pos);
 167   dst_id = network_card_new(surf_parse_text);
 168
 169   token = surf_parse();
 170   xbt_assert1((token == TOKEN_LP), "Parse error line %d", line_pos);
 171
 172   while((token = surf_parse())==TOKEN_WORD) {
 173     if(!fake) {
 174       nb_link++;
 175       link_name=xbt_realloc(link_name, (nb_link) * sizeof(char*));
 176       link_name[(nb_link)-1]=xbt_strdup(surf_parse_text);
 177     }
 178   }
 179   xbt_assert1((token == TOKEN_RP), "Parse error line %d", line_pos);
 180
 181   if(!fake) route_new(src_id,dst_id,link_name, nb_link);
 182 }
 183
 184 static void parse_file(const char *file)
 185 {
 186   e_surf_token_t token;
 187
 188   /* Figuring out the network links in the system */
 189   find_section(file, "NETWORK");
 190   while (1) {
 191     token = surf_parse();
 192
 193     if (token == TOKEN_END_SECTION)
 194       break;
 195     if (token == TOKEN_NEWLINE)
 196       continue;
 197
 198     if (token == TOKEN_WORD)
 199       parse_network_link();
 200     else {
 201       CRITICAL1("Parse error line %d\n", line_pos);
 202       xbt_abort();
 203     }
 204   }
 205   close_section("NETWORK");
 206
 207   /* Figuring out the network cards used */
 208   find_section(file, "ROUTE");
 209   while (1) {
 210     token = surf_parse();
 211
 212     if (token == TOKEN_END_SECTION)
 213       break;
 214     if (token == TOKEN_NEWLINE)
 215       continue;
 216
 217     if (token == TOKEN_WORD)
 218       parse_route(1);
 219     else {
 220       CRITICAL1("Parse error line %d\n", line_pos);
 221       xbt_abort();
 222     }
 223   }
 224   close_section("ROUTE");
 225
 226   create_routing_table();
 227
 228   /* Building the routes */
 229   find_section(file, "ROUTE");
 230   while (1) {
 231     token = surf_parse();
 232
 233     if (token == TOKEN_END_SECTION)
 234       break;
 235     if (token == TOKEN_NEWLINE)
 236       continue;
 237
 238     if (token == TOKEN_WORD)
 239       parse_route(0);
 240     else {
 241       CRITICAL1("Parse error line %d\n", line_pos);
 242       xbt_abort();
 243     }
 244   }
 245   close_section("ROUTE");
 246 }
 247
 248 static void *name_service(const char *name)
 249 {
 250   network_card_t card = NULL;
 251
 252   xbt_dict_get(network_card_set, name, (void *) &card);
 253
 254   return card;
 255 }
 256
 257 static const char *get_resource_name(void *resource_id)
 258 {
 259   return ((network_card_t) resource_id)->name;
 260 }
 261
 262 static int resource_used(void *resource_id)
 263 {
 264   return lmm_constraint_used(maxmin_system,
 265                              ((network_link_t) resource_id)->constraint);
 266 }
 267
 268 static void action_free(surf_action_t action)
 269 {
 270   surf_action_network_t Action = (surf_action_network_t) action;
 271
 272   xbt_swag_remove(action, action->state_set);
 273   lmm_variable_free(maxmin_system, Action->variable);
 274   xbt_free(action);
 275
 276   return;
 277 }
 278
 279 static void action_cancel(surf_action_t action)
 280 {
 281   return;
 282 }
 283
 284 static void action_recycle(surf_action_t action)
 285 {
 286   return;
 287 }
 288
 289 static void action_change_state(surf_action_t action,
 290                                 e_surf_action_state_t state)
 291 {
 292   surf_action_change_state(action, state);
 293   return;
 294 }
 295
 296 static xbt_heap_float_t share_resources(xbt_heap_float_t now)
 297 {
 298   surf_action_network_t action = NULL;
 299   xbt_swag_t running_actions =
 300       surf_network_resource->common_public->states.running_action_set;
 301   xbt_maxmin_float_t min = -1;
 302   xbt_maxmin_float_t value = -1;
 303   lmm_solve(maxmin_system);
 304
 305   action = xbt_swag_getFirst(running_actions);
 306   if (!action)
 307     return -1.0;
 308   value = lmm_variable_getvalue(action->variable);
 309   min = action->generic_action.remains / value;
 310
 311   xbt_swag_foreach(action, running_actions) {
 312     value = action->latency + (action->generic_action.remains /
 313         lmm_variable_getvalue(action->variable));
 314     if (value < min)
 315       min = value;
 316   }
 317
 318   return min;
 319 }
 320
 321
 322 static void update_actions_state(xbt_heap_float_t now,
 323                                  xbt_heap_float_t delta)
 324 {
 325   xbt_heap_float_t deltap = 0.0;
 326   surf_action_network_t action = NULL;
 327   surf_action_network_t next_action = NULL;
 328   xbt_swag_t running_actions =
 329       surf_network_resource->common_public->states.running_action_set;
 330   xbt_swag_t failed_actions =
 331       surf_network_resource->common_public->states.failed_action_set;
 332
 333   xbt_swag_foreach_safe(action, next_action, running_actions) {
 334     deltap = delta;
 335     if(action->latency>0) {
 336       if(action->latency>deltap) {
 337         action->latency-=deltap;
 338         deltap = 0.0;
 339       } else {
 340         deltap -= action->latency;
 341         action->latency = 0.0;
 342       }
 343     }
 344     action->generic_action.remains -=
 345       lmm_variable_getvalue(action->variable) * deltap;
 346
 347 /*     if(action->generic_action.remains<.00001) action->generic_action.remains=0; */
 348
 349     if (action->generic_action.remains <= 0) {
 350       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 351     } else {                    /* Need to check that none of the resource has failed */
 352       lmm_constraint_t cnst = NULL;
 353       int i = 0;
 354       network_link_t nw_link = NULL;
 355
 356       while ((cnst =
 357               lmm_get_cnst_from_var(maxmin_system, action->variable,
 358                                     i++))) {
 359         nw_link = lmm_constraint_id(cnst);
 360         if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
 361           action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 362           break;
 363         }
 364       }
 365     }
 366   }
 367
 368   xbt_swag_foreach_safe(action, next_action, failed_actions) {
 369     lmm_variable_disable(maxmin_system, action->variable);
 370   }
 371
 372   return;
 373 }
 374
 375 static void update_resource_state(void *id,
 376                                   tmgr_trace_event_t event_type,
 377                                   xbt_maxmin_float_t value)
 378 {
 379   network_link_t nw_link = id;
 380
 381 /*   printf("[" XBT_HEAP_FLOAT_T "] Asking to update network card \"%s\" with value " */
 382 /*       XBT_MAXMIN_FLOAT_T " for event %p\n", surf_get_clock(), nw_link->name, */
 383 /*       value, event_type); */
 384
 385   if (event_type == nw_link->bw_event) {
 386     nw_link->bw_current = value;
 387     lmm_update_constraint_bound(maxmin_system, nw_link->constraint,
 388                                 nw_link->bw_current);
 389   } else if (event_type == nw_link->lat_event) {
 390     xbt_maxmin_float_t delta = value - nw_link->lat_current;
 391     lmm_variable_t var = NULL;
 392     surf_action_network_t action = NULL;
 393
 394     nw_link->lat_current = value;
 395     while(lmm_get_var_from_cnst(maxmin_system, nw_link->constraint, &var)) {
 396       action  = lmm_variable_id(var);
 397       action->lat_current+=delta;
 398       lmm_update_variable_bound(maxmin_system, var,
 399                                 1/(action->lat_current));
 400     }
 401   } else if (event_type == nw_link->state_event) {
 402     if (value > 0)
 403       nw_link->state_current = SURF_NETWORK_LINK_ON;
 404     else
 405       nw_link->state_current = SURF_NETWORK_LINK_OFF;
 406   } else {
 407     CRITICAL0("Unknown event ! \n");
 408     xbt_abort();
 409   }
 410
 411   return;
 412 }
 413
 414 static surf_action_t communicate(void *src, void *dst,
 415                                  xbt_maxmin_float_t size)
 416 {
 417   surf_action_network_t action = NULL;
 418   network_card_t card_src = src;
 419   network_card_t card_dst = dst;
 420   int route_size = ROUTE_SIZE(card_src->id,card_dst->id);
 421   network_link_t *route = ROUTE(card_src->id,card_dst->id);
 422   int i;
 423
 424   action = xbt_new0(s_surf_action_network_t, 1);
 425
 426   action->generic_action.cost = size;
 427   action->generic_action.remains = size;
 428   action->generic_action.start = -1.0;
 429   action->generic_action.finish = -1.0;
 430   action->generic_action.callback = NULL;
 431   action->generic_action.resource_type =
 432       (surf_resource_t) surf_network_resource;
 433
 434   action->generic_action.state_set =
 435     surf_network_resource->common_public->states.running_action_set;
 436
 437   xbt_swag_insert(action, action->generic_action.state_set);
 438
 439   action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
 440                                       route_size);
 441   for(i=0; i<route_size; i++)
 442     lmm_expand(maxmin_system, route[i]->constraint, action->variable,
 443                1.0);
 444
 445   action->latency = 0.0;
 446   for(i=0; i<route_size; i++)
 447     action->latency += route[i]->lat_current;
 448   action->lat_current = action->latency;
 449   lmm_update_variable_bound(maxmin_system, action->variable,
 450                             SG_TCP_CTE_GAMMA/action->lat_current);
 451
 452   return (surf_action_t) action;
 453 }
 454
 455 static void finalize(void)
 456 {
 457   xbt_dict_free(&network_card_set);
 458   xbt_dict_free(&network_link_set);
 459   xbt_swag_free(surf_network_resource->common_public->states.ready_action_set);
 460   xbt_swag_free(surf_network_resource->common_public->states.
 461                 running_action_set);
 462   xbt_swag_free(surf_network_resource->common_public->states.
 463                 failed_action_set);
 464   xbt_swag_free(surf_network_resource->common_public->states.done_action_set);
 465   xbt_free(surf_network_resource->common_public);
 466   xbt_free(surf_network_resource->common_private);
 467   xbt_free(surf_network_resource->extension_public);
 468
 469   xbt_free(surf_network_resource);
 470   surf_network_resource = NULL;
 471 }
 472
 473 static void surf_network_resource_init_internal(void)
 474 {
 475   s_surf_action_t action;
 476
 477   surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
 478
 479   surf_network_resource->common_private =
 480       xbt_new0(s_surf_resource_private_t, 1);
 481   surf_network_resource->common_public =
 482       xbt_new0(s_surf_resource_public_t, 1);
 483 /*   surf_network_resource->extension_private = xbt_new0(s_surf_network_resource_extension_private_t,1); */
 484   surf_network_resource->extension_public =
 485       xbt_new0(s_surf_network_resource_extension_public_t, 1);
 486
 487   surf_network_resource->common_public->states.ready_action_set =
 488       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 489   surf_network_resource->common_public->states.running_action_set =
 490       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 491   surf_network_resource->common_public->states.failed_action_set =
 492       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 493   surf_network_resource->common_public->states.done_action_set =
 494       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 495
 496   surf_network_resource->common_public->name_service = name_service;
 497   surf_network_resource->common_public->get_resource_name =
 498       get_resource_name;
 499   surf_network_resource->common_public->action_get_state =
 500       surf_action_get_state;
 501   surf_network_resource->common_public->action_free = action_free;
 502   surf_network_resource->common_public->action_cancel = action_cancel;
 503   surf_network_resource->common_public->action_recycle = action_recycle;
 504   surf_network_resource->common_public->action_change_state =
 505       action_change_state;
 506
 507   surf_network_resource->common_private->resource_used = resource_used;
 508   surf_network_resource->common_private->share_resources = share_resources;
 509   surf_network_resource->common_private->update_actions_state =
 510       update_actions_state;
 511   surf_network_resource->common_private->update_resource_state =
 512       update_resource_state;
 513   surf_network_resource->common_private->finalize = finalize;
 514
 515   surf_network_resource->extension_public->communicate = communicate;
 516
 517   network_link_set = xbt_dict_new();
 518   network_card_set = xbt_dict_new();
 519
 520   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 521 }
 522
 523 void surf_network_resource_init(const char *filename)
 524 {
 525   surf_network_resource_init_internal();
 526   parse_file(filename);
 527   xbt_dynar_push(resource_list, &surf_network_resource);
 528 }