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/log.h"
  10 #include "xbt/str.h"
  11
  12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network, surf,
  13                                 "Logging specific to the SURF network module");
  14
  15 surf_model_t surf_network_model = NULL;
  16 static lmm_system_t network_maxmin_system = NULL;
  17 static void (*network_solve) (lmm_system_t) = NULL;
  18
  19 double latency_factor = 1.0;    /* default value */
  20 double bandwidth_factor = 1.0;  /* default value */
  21 double weight_S_parameter = 0.0;        /* default value */
  22
  23 int card_number = 0;
  24 int host_count = 0;
  25 double sg_tcp_gamma = 0.0;
  26
  27
  28
  29 static link_CM02_t link_new(char *name,
  30                             double bw_initial,
  31                             tmgr_trace_t bw_trace,
  32                             double lat_initial,
  33                             tmgr_trace_t lat_trace,
  34                             e_surf_resource_state_t
  35                             state_initial,
  36                             tmgr_trace_t state_trace,
  37                             e_surf_link_sharing_policy_t
  38                             policy, xbt_dict_t properties)
  39 {
  40   link_CM02_t nw_link = (link_CM02_t)
  41     surf_resource_lmm_new(sizeof(s_link_CM02_t),
  42         surf_network_model,name,properties,
  43         network_maxmin_system, bandwidth_factor * bw_initial,
  44         history,
  45         state_initial,state_trace,
  46         bw_initial,bw_trace);
  47
  48   xbt_assert1(!xbt_dict_get_or_null(surf_network_model->resource_set, name),
  49               "Link '%s' declared several times in the platform file.", name);
  50
  51   nw_link->lat_current = lat_initial;
  52   if (lat_trace)
  53     nw_link->lat_event =
  54       tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
  55
  56   if (policy == SURF_LINK_FATPIPE)
  57     lmm_constraint_shared(nw_link->lmm_resource.constraint);
  58
  59   xbt_dict_set(surf_network_model->resource_set, name, nw_link, surf_resource_free);
  60
  61   return nw_link;
  62 }
  63
  64 static void parse_link_init(void)
  65 {
  66   char *name_link;
  67   double bw_initial;
  68   tmgr_trace_t bw_trace;
  69   double lat_initial;
  70   tmgr_trace_t lat_trace;
  71   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
  72   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
  73   tmgr_trace_t state_trace;
  74
  75   name_link = xbt_strdup(A_surfxml_link_id);
  76   surf_parse_get_double(&bw_initial, A_surfxml_link_bandwidth);
  77   bw_trace = tmgr_trace_new(A_surfxml_link_bandwidth_file);
  78   surf_parse_get_double(&lat_initial, A_surfxml_link_latency);
  79   lat_trace = tmgr_trace_new(A_surfxml_link_latency_file);
  80
  81   xbt_assert0((A_surfxml_link_state == A_surfxml_link_state_ON)
  82               || (A_surfxml_link_state ==
  83                   A_surfxml_link_state_OFF), "Invalid state");
  84   if (A_surfxml_link_state == A_surfxml_link_state_ON)
  85     state_initial_link = SURF_RESOURCE_ON;
  86   else if (A_surfxml_link_state == A_surfxml_link_state_OFF)
  87     state_initial_link = SURF_RESOURCE_OFF;
  88
  89   if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
  90     policy_initial_link = SURF_LINK_SHARED;
  91   else if (A_surfxml_link_sharing_policy ==
  92            A_surfxml_link_sharing_policy_FATPIPE)
  93     policy_initial_link = SURF_LINK_FATPIPE;
  94
  95   state_trace = tmgr_trace_new(A_surfxml_link_state_file);
  96
  97   link_new(name_link, bw_initial, bw_trace,
  98            lat_initial, lat_trace, state_initial_link, state_trace,
  99            policy_initial_link, xbt_dict_new());
 100
 101 }
 102
 103 static void add_traces(void)
 104 {
 105   xbt_dict_cursor_t cursor = NULL;
 106   char *trace_name, *elm;
 107
 108   static int called = 0;
 109   if (called)
 110     return;
 111   called = 1;
 112
 113   /* connect all traces relative to network */
 114   xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
 115     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 116     link_CM02_t link = xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 117
 118     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 119                 trace_name, elm);
 120     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 121                 trace_name, elm);
 122
 123     link->lmm_resource.state_event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
 124   }
 125
 126   xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
 127     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 128     link_CM02_t link = xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 129
 130     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 131                 trace_name, elm);
 132     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 133                 trace_name, elm);
 134
 135     link->lmm_resource.power.event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
 136   }
 137
 138   xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
 139     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 140     link_CM02_t link = xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 141
 142     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 143                 trace_name, elm);
 144     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 145                 trace_name, elm);
 146
 147     link->lat_event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
 148   }
 149 }
 150
 151 static void define_callbacks(const char *file)
 152 {
 153   /* Figuring out the network links */
 154   surfxml_add_callback(STag_surfxml_link_cb_list, &parse_link_init);
 155   surfxml_add_callback(ETag_surfxml_platform_cb_list, &add_traces);
 156 }
 157
 158 static int resource_used(void *resource_id)
 159 {
 160   return lmm_constraint_used(network_maxmin_system,
 161                              ((surf_resource_lmm_t) resource_id)->constraint);
 162 }
 163
 164 static int action_unref(surf_action_t action)
 165 {
 166   action->refcount--;
 167   if (!action->refcount) {
 168     xbt_swag_remove(action, action->state_set);
 169     if (((surf_action_network_CM02_t) action)->variable)
 170       lmm_variable_free(network_maxmin_system,
 171                         ((surf_action_network_CM02_t) action)->variable);
 172     free(action);
 173     return 1;
 174   }
 175   return 0;
 176 }
 177
 178 static void action_cancel(surf_action_t action)
 179 {
 180   return;
 181 }
 182
 183 static void action_recycle(surf_action_t action)
 184 {
 185   return;
 186 }
 187
 188 static double share_resources(double now)
 189 {
 190   s_surf_action_network_CM02_t s_action;
 191   surf_action_network_CM02_t action = NULL;
 192   xbt_swag_t running_actions = surf_network_model->states.running_action_set;
 193   double min;
 194
 195   min = generic_maxmin_share_resources(running_actions,
 196                                        xbt_swag_offset(s_action,
 197                                                        variable),
 198                                        network_maxmin_system, network_solve);
 199
 200 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + xbt_swag_offset(s_action, variable)  )))
 201
 202   xbt_swag_foreach(action, running_actions) {
 203     if (action->latency > 0) {
 204       if (min < 0)
 205         min = action->latency;
 206       else if (action->latency < min)
 207         min = action->latency;
 208     }
 209   }
 210
 211   return min;
 212 }
 213
 214 static void update_actions_state(double now, double delta)
 215 {
 216   double deltap = 0.0;
 217   surf_action_network_CM02_t action = NULL;
 218   surf_action_network_CM02_t next_action = NULL;
 219   xbt_swag_t running_actions = surf_network_model->states.running_action_set;
 220   /*
 221      xbt_swag_t failed_actions =
 222      surf_network_model->states.failed_action_set;
 223    */
 224
 225   xbt_swag_foreach_safe(action, next_action, running_actions) {
 226     deltap = delta;
 227     if (action->latency > 0) {
 228       if (action->latency > deltap) {
 229         double_update(&(action->latency), deltap);
 230         deltap = 0.0;
 231       } else {
 232         double_update(&(deltap), action->latency);
 233         action->latency = 0.0;
 234       }
 235       if ((action->latency == 0.0) && !(action->suspended))
 236         lmm_update_variable_weight(network_maxmin_system, action->variable,
 237                                    action->weight);
 238     }
 239     double_update(&(action->generic_action.remains),
 240                   lmm_variable_getvalue(action->variable) * deltap);
 241     if (action->generic_action.max_duration != NO_MAX_DURATION)
 242       double_update(&(action->generic_action.max_duration), delta);
 243
 244     if ((action->generic_action.remains <= 0) &&
 245         (lmm_get_variable_weight(action->variable) > 0)) {
 246       action->generic_action.finish = surf_get_clock();
 247       surf_network_model->action_state_set((surf_action_t) action, SURF_ACTION_DONE);
 248     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 249                (action->generic_action.max_duration <= 0)) {
 250       action->generic_action.finish = surf_get_clock();
 251       surf_network_model->action_state_set((surf_action_t) action, SURF_ACTION_DONE);
 252     }
 253   }
 254
 255   return;
 256 }
 257
 258 static void update_resource_state(void *id,
 259                                   tmgr_trace_event_t event_type,
 260                                   double value, double date)
 261 {
 262   link_CM02_t nw_link = id;
 263   /*   printf("[" "%lg" "] Asking to update network card \"%s\" with value " */
 264   /*     "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
 265   /*     value, event_type); */
 266
 267   if (event_type == nw_link->lmm_resource.power.event) {
 268     double delta =
 269       weight_S_parameter / value - weight_S_parameter / nw_link->lmm_resource.power.current;
 270     lmm_variable_t var = NULL;
 271     lmm_element_t elem = NULL;
 272     surf_action_network_CM02_t action = NULL;
 273
 274     nw_link->lmm_resource.power.current = value;
 275     lmm_update_constraint_bound(network_maxmin_system, nw_link->lmm_resource.constraint,
 276                                 bandwidth_factor * nw_link->lmm_resource.power.current);
 277     if (weight_S_parameter > 0) {
 278       while ((var = lmm_get_var_from_cnst
 279               (network_maxmin_system, nw_link->lmm_resource.constraint, &elem))) {
 280         action = lmm_variable_id(var);
 281         action->weight += delta;
 282         if (!(action->suspended))
 283           lmm_update_variable_weight(network_maxmin_system, action->variable,
 284                                      action->weight);
 285       }
 286     }
 287   } else if (event_type == nw_link->lat_event) {
 288     double delta = value - nw_link->lat_current;
 289     lmm_variable_t var = NULL;
 290     lmm_element_t elem = NULL;
 291     surf_action_network_CM02_t action = NULL;
 292
 293     nw_link->lat_current = value;
 294     while ((var = lmm_get_var_from_cnst
 295             (network_maxmin_system, nw_link->lmm_resource.constraint, &elem))) {
 296       action = lmm_variable_id(var);
 297       action->lat_current += delta;
 298       action->weight += delta;
 299       if (action->rate < 0)
 300         lmm_update_variable_bound(network_maxmin_system, action->variable,
 301                                   sg_tcp_gamma / (2.0 * action->lat_current));
 302       else
 303         lmm_update_variable_bound(network_maxmin_system, action->variable,
 304                                   min(action->rate,
 305                                       sg_tcp_gamma / (2.0 *
 306                                                       action->lat_current)));
 307       if (!(action->suspended))
 308         lmm_update_variable_weight(network_maxmin_system, action->variable,
 309                                    action->weight);
 310
 311     }
 312   } else if (event_type == nw_link->lmm_resource.state_event) {
 313     if (value > 0)
 314       nw_link->lmm_resource.state_current = SURF_RESOURCE_ON;
 315     else {
 316       lmm_constraint_t cnst = nw_link->lmm_resource.constraint;
 317       lmm_variable_t var = NULL;
 318       lmm_element_t elem = NULL;
 319
 320       nw_link->lmm_resource.state_current = SURF_RESOURCE_OFF;
 321       while ((var = lmm_get_var_from_cnst
 322               (network_maxmin_system, cnst, &elem))) {
 323         surf_action_t action = lmm_variable_id(var);
 324
 325         if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
 326             surf_action_state_get(action) == SURF_ACTION_READY) {
 327           action->finish = date;
 328           surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
 329         }
 330       }
 331     }
 332   } else {
 333     CRITICAL0("Unknown event ! \n");
 334     xbt_abort();
 335   }
 336
 337   return;
 338 }
 339
 340 static surf_action_t communicate(const char *src_name, const char *dst_name,int src, int dst, double size,
 341                                  double rate)
 342 {
 343   surf_action_network_CM02_t action = NULL;
 344   /* LARGE PLATFORMS HACK:
 345      Add a link_CM02_t *link and a int link_nb to network_card_CM02_t. It will represent local links for this node
 346      Use the cluster_id for ->id */
 347   xbt_dynar_t route = used_routing->get_route(src, dst);
 348   /* LARGE PLATFORMS HACK:
 349      total_route_size = route_size + src->link_nb + dst->nb */
 350   unsigned int i;
 351
 352   XBT_IN4("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 353   /* LARGE PLATFORMS HACK:
 354      assert on total_route_size */
 355   xbt_assert2(xbt_dynar_length(route),
 356               "You're trying to send data from %s to %s but there is no connection between these two hosts.",
 357               src_name, dst_name);
 358
 359   link_CM02_t link;
 360   int failed=0;
 361   xbt_dynar_foreach(route,i,link) {
 362     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
 363       failed = 1;
 364       break;
 365     }
 366   }
 367   action = surf_action_new(sizeof(s_surf_action_network_CM02_t),size,surf_network_model,failed);
 368
 369   xbt_swag_insert(action, action->generic_action.state_set);
 370   action->rate = rate;
 371
 372   action->latency = 0.0;
 373   action->weight = 0.0;
 374   xbt_dynar_foreach(route,i,link) {
 375     action->latency += link->lat_current;
 376     action->weight +=
 377       link->lat_current + weight_S_parameter / link->lmm_resource.power.current;
 378   }
 379   /* LARGE PLATFORMS HACK:
 380      Add src->link and dst->link latencies */
 381   action->lat_current = action->latency;
 382   action->latency *= latency_factor;
 383
 384   /* LARGE PLATFORMS HACK:
 385      lmm_variable_new(..., total_route_size) */
 386   if (action->latency > 0)
 387     action->variable =
 388       lmm_variable_new(network_maxmin_system, action, 0.0, -1.0, xbt_dynar_length(route));
 389   else
 390     action->variable =
 391       lmm_variable_new(network_maxmin_system, action, 1.0, -1.0, xbt_dynar_length(route));
 392
 393   if (action->rate < 0) {
 394     if (action->lat_current > 0)
 395       lmm_update_variable_bound(network_maxmin_system, action->variable,
 396                                 sg_tcp_gamma / (2.0 * action->lat_current));
 397     else
 398       lmm_update_variable_bound(network_maxmin_system, action->variable,
 399                                 -1.0);
 400   } else {
 401     if (action->lat_current > 0)
 402       lmm_update_variable_bound(network_maxmin_system, action->variable,
 403                                 min(action->rate,
 404                                     sg_tcp_gamma / (2.0 *
 405                                                     action->lat_current)));
 406     else
 407       lmm_update_variable_bound(network_maxmin_system, action->variable,
 408                                 action->rate);
 409   }
 410
 411   xbt_dynar_foreach(route,i,link) {
 412     lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
 413                action->variable, 1.0);
 414   }
 415   /* LARGE PLATFORMS HACK:
 416      expand also with src->link and dst->link */
 417
 418   XBT_OUT;
 419
 420   return (surf_action_t) action;
 421 }
 422
 423 static double get_link_bandwidth(const void *link)
 424 {
 425   return ((link_CM02_t) link)->lmm_resource.power.current;
 426 }
 427
 428 static double get_link_latency(const void *link)
 429 {
 430   return ((link_CM02_t) link)->lat_current;
 431 }
 432
 433 static int link_shared(const void *link)
 434 {
 435   return lmm_constraint_is_shared(((surf_resource_lmm_t) link)->constraint);
 436 }
 437
 438 static void action_suspend(surf_action_t action)
 439 {
 440   ((surf_action_network_CM02_t) action)->suspended = 1;
 441   lmm_update_variable_weight(network_maxmin_system,
 442                              ((surf_action_network_CM02_t) action)->variable,
 443                              0.0);
 444 }
 445
 446 static void action_resume(surf_action_t action)
 447 {
 448   if (((surf_action_network_CM02_t) action)->suspended) {
 449     lmm_update_variable_weight(network_maxmin_system,
 450                                ((surf_action_network_CM02_t)
 451                                 action)->variable,
 452                                ((surf_action_network_CM02_t) action)->weight);
 453     ((surf_action_network_CM02_t) action)->suspended = 0;
 454   }
 455 }
 456
 457 static int action_is_suspended(surf_action_t action)
 458 {
 459   return ((surf_action_network_CM02_t) action)->suspended;
 460 }
 461
 462 static void action_set_max_duration(surf_action_t action, double duration)
 463 {
 464   action->max_duration = duration;
 465 }
 466
 467 static void finalize(void)
 468 {
 469   surf_model_exit(surf_network_model);
 470   surf_network_model = NULL;
 471
 472   used_routing->finalize();
 473   host_count = 0;
 474   lmm_system_free(network_maxmin_system);
 475   network_maxmin_system = NULL;
 476 }
 477
 478 static void surf_network_model_init_internal(void)
 479 {
 480   surf_network_model = surf_model_init();
 481
 482   surf_network_model->name = "network";
 483   surf_network_model->action_unref = action_unref;
 484   surf_network_model->action_cancel = action_cancel;
 485   surf_network_model->action_recycle = action_recycle;
 486
 487   surf_network_model->model_private->resource_used = resource_used;
 488   surf_network_model->model_private->share_resources = share_resources;
 489   surf_network_model->model_private->update_actions_state =
 490     update_actions_state;
 491   surf_network_model->model_private->update_resource_state =
 492     update_resource_state;
 493   surf_network_model->model_private->finalize = finalize;
 494
 495   surf_network_model->suspend = action_suspend;
 496   surf_network_model->resume = action_resume;
 497   surf_network_model->is_suspended = action_is_suspended;
 498   surf_cpu_model->set_max_duration = action_set_max_duration;
 499
 500   surf_network_model->extension.network.communicate = communicate;
 501   surf_network_model->extension.network.get_link_bandwidth =
 502     get_link_bandwidth;
 503   surf_network_model->extension.network.get_link_latency = get_link_latency;
 504   surf_network_model->extension.network.link_shared = link_shared;
 505
 506   if (!network_maxmin_system)
 507     network_maxmin_system = lmm_system_new();
 508
 509   routing_model_create(sizeof(link_CM02_t),
 510       link_new(xbt_strdup("__loopback__"),
 511           498000000, NULL, 0.000015, NULL,
 512           SURF_RESOURCE_ON, NULL, SURF_LINK_FATPIPE, NULL));
 513 }
 514
 515 /************************************************************************/
 516 /* New model based on optimizations discussed during this thesis        */
 517 /************************************************************************/
 518 void surf_network_model_init_LegrandVelho(const char *filename)
 519 {
 520
 521   if (surf_network_model)
 522     return;
 523   surf_network_model_init_internal();
 524   define_callbacks(filename);
 525   xbt_dynar_push(model_list, &surf_network_model);
 526   network_solve = lmm_solve;
 527
 528   latency_factor = 10.4;
 529   bandwidth_factor = 0.92;
 530   weight_S_parameter = 8775;
 531
 532   update_model_description(surf_network_model_description,
 533                            "LegrandVelho", surf_network_model);
 534 }
 535
 536 /***************************************************************************/
 537 /* The nice TCP sharing model designed by Loris Marchal and Henri Casanova */
 538 /***************************************************************************/
 539 /* @TechReport{      rr-lip2002-40, */
 540 /*   author        = {Henri Casanova and Loris Marchal}, */
 541 /*   institution   = {LIP}, */
 542 /*   title         = {A Network Model for Simulation of Grid Application}, */
 543 /*   number        = {2002-40}, */
 544 /*   month         = {oct}, */
 545 /*   year          = {2002} */
 546 /* } */
 547 void surf_network_model_init_CM02(const char *filename)
 548 {
 549
 550   if (surf_network_model)
 551     return;
 552   surf_network_model_init_internal();
 553   define_callbacks(filename);
 554   xbt_dynar_push(model_list, &surf_network_model);
 555   network_solve = lmm_solve;
 556
 557   update_model_description(surf_network_model_description,
 558                            "CM02", surf_network_model);
 559 }
 560
 561 void surf_network_model_init_Reno(const char *filename)
 562 {
 563   if (surf_network_model)
 564     return;
 565   surf_network_model_init_internal();
 566   define_callbacks(filename);
 567
 568   xbt_dynar_push(model_list, &surf_network_model);
 569   lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi);
 570   network_solve = lagrange_solve;
 571
 572   latency_factor = 10.4;
 573   bandwidth_factor = 0.92;
 574   weight_S_parameter = 8775;
 575
 576   update_model_description(surf_network_model_description,
 577                            "Reno", surf_network_model);
 578 }
 579
 580
 581 void surf_network_model_init_Reno2(const char *filename)
 582 {
 583   if (surf_network_model)
 584     return;
 585   surf_network_model_init_internal();
 586   define_callbacks(filename);
 587
 588   xbt_dynar_push(model_list, &surf_network_model);
 589   lmm_set_default_protocol_function(func_reno2_f, func_reno2_fp,
 590                                     func_reno2_fpi);
 591   network_solve = lagrange_solve;
 592
 593   latency_factor = 10.4;
 594   bandwidth_factor = 0.92;
 595   weight_S_parameter = 8775;
 596
 597   update_model_description(surf_network_model_description,
 598                            "Reno2", surf_network_model);
 599 }
 600
 601 void surf_network_model_init_Vegas(const char *filename)
 602 {
 603   if (surf_network_model)
 604     return;
 605   surf_network_model_init_internal();
 606   define_callbacks(filename);
 607
 608   xbt_dynar_push(model_list, &surf_network_model);
 609   lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
 610                                     func_vegas_fpi);
 611   network_solve = lagrange_solve;
 612
 613   latency_factor = 10.4;
 614   bandwidth_factor = 0.92;
 615   weight_S_parameter = 8775;
 616
 617   update_model_description(surf_network_model_description,
 618                            "Vegas", surf_network_model);
 619 }