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