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   s_surf_action_network_t action;
 299   return generic_maxmin_share_resources(surf_network_resource->common_public->states.running_action_set,
 300                                         xbt_swag_offset(action,variable));
 301 }
 302
 303
 304 static void update_actions_state(xbt_heap_float_t now,
 305                                  xbt_heap_float_t delta)
 306 {
 307   xbt_heap_float_t deltap = 0.0;
 308   surf_action_network_t action = NULL;
 309   surf_action_network_t next_action = NULL;
 310   xbt_swag_t running_actions =
 311       surf_network_resource->common_public->states.running_action_set;
 312   xbt_swag_t failed_actions =
 313       surf_network_resource->common_public->states.failed_action_set;
 314
 315   xbt_swag_foreach_safe(action, next_action, running_actions) {
 316     deltap = delta;
 317     if(action->latency>0) {
 318       if(action->latency>deltap) {
 319         action->latency-=deltap;
 320         deltap = 0.0;
 321       } else {
 322         deltap -= action->latency;
 323         action->latency = 0.0;
 324       }
 325     }
 326     action->generic_action.remains -=
 327       lmm_variable_getvalue(action->variable) * deltap;
 328     if(action->generic_action.max_duration!=NO_MAX_DURATION)
 329       action->generic_action.max_duration -= delta;
 330
 331 /*     if(action->generic_action.remains<.00001) action->generic_action.remains=0; */
 332
 333     if (action->generic_action.remains <= 0) {
 334       action->generic_action.finish = surf_get_clock();
 335       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 336     } else if((action->generic_action.max_duration!=NO_MAX_DURATION) &&
 337               (action->generic_action.max_duration<=0)) {
 338       action->generic_action.finish = surf_get_clock();
 339       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 340     } else {                    /* Need to check that none of the resource has failed */
 341       lmm_constraint_t cnst = NULL;
 342       int i = 0;
 343       network_link_t nw_link = NULL;
 344
 345       while ((cnst =
 346               lmm_get_cnst_from_var(maxmin_system, action->variable,
 347                                     i++))) {
 348         nw_link = lmm_constraint_id(cnst);
 349         if (nw_link->state_current == SURF_NETWORK_LINK_OFF) {
 350           action->generic_action.finish = surf_get_clock();
 351           action_change_state((surf_action_t) action, SURF_ACTION_FAILED);
 352           break;
 353         }
 354       }
 355     }
 356   }
 357
 358   xbt_swag_foreach_safe(action, next_action, failed_actions) {
 359     lmm_variable_disable(maxmin_system, action->variable);
 360   }
 361
 362   return;
 363 }
 364
 365 static void update_resource_state(void *id,
 366                                   tmgr_trace_event_t event_type,
 367                                   xbt_maxmin_float_t value)
 368 {
 369   network_link_t nw_link = id;
 370
 371 /*   printf("[" XBT_HEAP_FLOAT_T "] Asking to update network card \"%s\" with value " */
 372 /*       XBT_MAXMIN_FLOAT_T " for event %p\n", surf_get_clock(), nw_link->name, */
 373 /*       value, event_type); */
 374
 375   if (event_type == nw_link->bw_event) {
 376     nw_link->bw_current = value;
 377     lmm_update_constraint_bound(maxmin_system, nw_link->constraint,
 378                                 nw_link->bw_current);
 379   } else if (event_type == nw_link->lat_event) {
 380     xbt_maxmin_float_t delta = value - nw_link->lat_current;
 381     lmm_variable_t var = NULL;
 382     surf_action_network_t action = NULL;
 383
 384     nw_link->lat_current = value;
 385     while(lmm_get_var_from_cnst(maxmin_system, nw_link->constraint, &var)) {
 386       action  = lmm_variable_id(var);
 387       action->lat_current+=delta;
 388       lmm_update_variable_bound(maxmin_system, var,
 389                                 1/(action->lat_current));
 390     }
 391   } else if (event_type == nw_link->state_event) {
 392     if (value > 0)
 393       nw_link->state_current = SURF_NETWORK_LINK_ON;
 394     else
 395       nw_link->state_current = SURF_NETWORK_LINK_OFF;
 396   } else {
 397     CRITICAL0("Unknown event ! \n");
 398     xbt_abort();
 399   }
 400
 401   return;
 402 }
 403
 404 static surf_action_t communicate(void *src, void *dst,
 405                                  xbt_maxmin_float_t size)
 406 {
 407   surf_action_network_t action = NULL;
 408   network_card_t card_src = src;
 409   network_card_t card_dst = dst;
 410   int route_size = ROUTE_SIZE(card_src->id,card_dst->id);
 411   network_link_t *route = ROUTE(card_src->id,card_dst->id);
 412   int i;
 413
 414   action = xbt_new0(s_surf_action_network_t, 1);
 415
 416   action->generic_action.cost = size;
 417   action->generic_action.remains = size;
 418   action->generic_action.max_duration = NO_MAX_DURATION;
 419   action->generic_action.start = -1.0;
 420   action->generic_action.finish = -1.0;
 421   action->generic_action.callback = NULL;
 422   action->generic_action.resource_type =
 423       (surf_resource_t) surf_network_resource;
 424
 425   action->generic_action.state_set =
 426     surf_network_resource->common_public->states.running_action_set;
 427
 428   xbt_swag_insert(action, action->generic_action.state_set);
 429
 430   action->variable = lmm_variable_new(maxmin_system, action, 1.0, -1.0,
 431                                       route_size);
 432   for(i=0; i<route_size; i++)
 433     lmm_expand(maxmin_system, route[i]->constraint, action->variable,
 434                1.0);
 435
 436   action->latency = 0.0;
 437   for(i=0; i<route_size; i++)
 438     action->latency += route[i]->lat_current;
 439   action->lat_current = action->latency;
 440   lmm_update_variable_bound(maxmin_system, action->variable,
 441                             SG_TCP_CTE_GAMMA/action->lat_current);
 442
 443   return (surf_action_t) action;
 444 }
 445
 446 static void finalize(void)
 447 {
 448   xbt_dict_free(&network_card_set);
 449   xbt_dict_free(&network_link_set);
 450   xbt_swag_free(surf_network_resource->common_public->states.ready_action_set);
 451   xbt_swag_free(surf_network_resource->common_public->states.
 452                 running_action_set);
 453   xbt_swag_free(surf_network_resource->common_public->states.
 454                 failed_action_set);
 455   xbt_swag_free(surf_network_resource->common_public->states.done_action_set);
 456   xbt_free(surf_network_resource->common_public);
 457   xbt_free(surf_network_resource->common_private);
 458   xbt_free(surf_network_resource->extension_public);
 459
 460   xbt_free(surf_network_resource);
 461   surf_network_resource = NULL;
 462 }
 463
 464 static void surf_network_resource_init_internal(void)
 465 {
 466   s_surf_action_t action;
 467
 468   surf_network_resource = xbt_new0(s_surf_network_resource_t, 1);
 469
 470   surf_network_resource->common_private =
 471       xbt_new0(s_surf_resource_private_t, 1);
 472   surf_network_resource->common_public =
 473       xbt_new0(s_surf_resource_public_t, 1);
 474 /*   surf_network_resource->extension_private = xbt_new0(s_surf_network_resource_extension_private_t,1); */
 475   surf_network_resource->extension_public =
 476       xbt_new0(s_surf_network_resource_extension_public_t, 1);
 477
 478   surf_network_resource->common_public->states.ready_action_set =
 479       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 480   surf_network_resource->common_public->states.running_action_set =
 481       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 482   surf_network_resource->common_public->states.failed_action_set =
 483       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 484   surf_network_resource->common_public->states.done_action_set =
 485       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 486
 487   surf_network_resource->common_public->name_service = name_service;
 488   surf_network_resource->common_public->get_resource_name =
 489       get_resource_name;
 490   surf_network_resource->common_public->action_get_state =
 491       surf_action_get_state;
 492   surf_network_resource->common_public->action_free = action_free;
 493   surf_network_resource->common_public->action_cancel = action_cancel;
 494   surf_network_resource->common_public->action_recycle = action_recycle;
 495   surf_network_resource->common_public->action_change_state =
 496       action_change_state;
 497
 498   surf_network_resource->common_private->resource_used = resource_used;
 499   surf_network_resource->common_private->share_resources = share_resources;
 500   surf_network_resource->common_private->update_actions_state =
 501       update_actions_state;
 502   surf_network_resource->common_private->update_resource_state =
 503       update_resource_state;
 504   surf_network_resource->common_private->finalize = finalize;
 505
 506   surf_network_resource->extension_public->communicate = communicate;
 507
 508   network_link_set = xbt_dict_new();
 509   network_card_set = xbt_dict_new();
 510
 511   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 512 }
 513
 514 void surf_network_resource_init(const char *filename)
 515 {
 516   surf_network_resource_init_internal();
 517   parse_file(filename);
 518   xbt_dynar_push(resource_list, &surf_network_resource);
 519 }