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 / nw_link->lmm_resource.power.current;
 267     lmm_variable_t var = NULL;
 268     lmm_element_t elem = NULL;
 269     surf_action_network_CM02_t action = NULL;
 270
 271     nw_link->lmm_resource.power.current = value;
 272     lmm_update_constraint_bound(network_maxmin_system, nw_link->lmm_resource.constraint,
 273                                 bandwidth_factor * nw_link->lmm_resource.power.current);
 274     if (weight_S_parameter > 0) {
 275       while ((var = lmm_get_var_from_cnst
 276               (network_maxmin_system, nw_link->lmm_resource.constraint, &elem))) {
 277         action = lmm_variable_id(var);
 278         action->weight += delta;
 279         if (!(action->suspended))
 280           lmm_update_variable_weight(network_maxmin_system, action->variable,
 281                                      action->weight);
 282       }
 283     }
 284   } else if (event_type == nw_link->lat_event) {
 285     double delta = value - nw_link->lat_current;
 286     lmm_variable_t var = NULL;
 287     lmm_element_t elem = NULL;
 288     surf_action_network_CM02_t action = NULL;
 289
 290     nw_link->lat_current = value;
 291     while ((var = lmm_get_var_from_cnst
 292             (network_maxmin_system, nw_link->lmm_resource.constraint, &elem))) {
 293       action = lmm_variable_id(var);
 294       action->lat_current += delta;
 295       action->weight += delta;
 296       if (action->rate < 0)
 297         lmm_update_variable_bound(network_maxmin_system, action->variable,
 298                                   sg_tcp_gamma / (2.0 * action->lat_current));
 299       else
 300         lmm_update_variable_bound(network_maxmin_system, action->variable,
 301                                   min(action->rate,
 302                                       sg_tcp_gamma / (2.0 *
 303                                                       action->lat_current)));
 304       if (!(action->suspended))
 305         lmm_update_variable_weight(network_maxmin_system, action->variable,
 306                                    action->weight);
 307
 308     }
 309   } else if (event_type == nw_link->lmm_resource.state_event) {
 310     if (value > 0)
 311       nw_link->lmm_resource.state_current = SURF_RESOURCE_ON;
 312     else {
 313       lmm_constraint_t cnst = nw_link->lmm_resource.constraint;
 314       lmm_variable_t var = NULL;
 315       lmm_element_t elem = NULL;
 316
 317       nw_link->lmm_resource.state_current = SURF_RESOURCE_OFF;
 318       while ((var = lmm_get_var_from_cnst
 319               (network_maxmin_system, cnst, &elem))) {
 320         surf_action_t action = lmm_variable_id(var);
 321
 322         if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
 323             surf_action_state_get(action) == SURF_ACTION_READY) {
 324           action->finish = date;
 325           surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
 326         }
 327       }
 328     }
 329   } else {
 330     CRITICAL0("Unknown event ! \n");
 331     xbt_abort();
 332   }
 333
 334   return;
 335 }
 336
 337 static surf_action_t communicate(const char *src_name, const char *dst_name,int src, int dst, double size,
 338                                  double rate)
 339 {
 340   surf_action_network_CM02_t action = NULL;
 341   /* LARGE PLATFORMS HACK:
 342      Add a link_CM02_t *link and a int link_nb to network_card_CM02_t. It will represent local links for this node
 343      Use the cluster_id for ->id */
 344   xbt_dynar_t route = used_routing->get_route(src, dst);
 345   /* LARGE PLATFORMS HACK:
 346      total_route_size = route_size + src->link_nb + dst->nb */
 347   unsigned int i;
 348
 349   XBT_IN4("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 350   /* LARGE PLATFORMS HACK:
 351      assert on total_route_size */
 352   xbt_assert2(xbt_dynar_length(route),
 353               "You're trying to send data from %s to %s but there is no connection between these two hosts.",
 354               src_name, dst_name);
 355
 356   link_CM02_t link;
 357   int failed=0;
 358   xbt_dynar_foreach(route,i,link) {
 359     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
 360       failed = 1;
 361       break;
 362     }
 363   }
 364   action = surf_action_new(sizeof(s_surf_action_network_CM02_t),size,surf_network_model,failed);
 365
 366   xbt_swag_insert(action, action->generic_action.state_set);
 367   action->rate = rate;
 368
 369   action->latency = 0.0;
 370   action->weight = 0.0;
 371   xbt_dynar_foreach(route,i,link) {
 372     action->latency += link->lat_current;
 373     action->weight +=
 374       link->lat_current + weight_S_parameter / link->lmm_resource.power.current;
 375   }
 376   /* LARGE PLATFORMS HACK:
 377      Add src->link and dst->link latencies */
 378   action->lat_current = action->latency;
 379   action->latency *= latency_factor;
 380
 381   /* LARGE PLATFORMS HACK:
 382      lmm_variable_new(..., total_route_size) */
 383   if (action->latency > 0)
 384     action->variable =
 385       lmm_variable_new(network_maxmin_system, action, 0.0, -1.0, xbt_dynar_length(route));
 386   else
 387     action->variable =
 388       lmm_variable_new(network_maxmin_system, action, 1.0, -1.0, xbt_dynar_length(route));
 389
 390   if (action->rate < 0) {
 391     if (action->lat_current > 0)
 392       lmm_update_variable_bound(network_maxmin_system, action->variable,
 393                                 sg_tcp_gamma / (2.0 * action->lat_current));
 394     else
 395       lmm_update_variable_bound(network_maxmin_system, action->variable,
 396                                 -1.0);
 397   } else {
 398     if (action->lat_current > 0)
 399       lmm_update_variable_bound(network_maxmin_system, action->variable,
 400                                 min(action->rate,
 401                                     sg_tcp_gamma / (2.0 *
 402                                                     action->lat_current)));
 403     else
 404       lmm_update_variable_bound(network_maxmin_system, action->variable,
 405                                 action->rate);
 406   }
 407
 408   xbt_dynar_foreach(route,i,link) {
 409     lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
 410                action->variable, 1.0);
 411   }
 412   /* LARGE PLATFORMS HACK:
 413      expand also with src->link and dst->link */
 414
 415   XBT_OUT;
 416
 417   return (surf_action_t) action;
 418 }
 419
 420 static double get_link_bandwidth(const void *link)
 421 {
 422   return ((link_CM02_t) link)->lmm_resource.power.current;
 423 }
 424
 425 static double get_link_latency(const void *link)
 426 {
 427   return ((link_CM02_t) link)->lat_current;
 428 }
 429
 430 static int link_shared(const void *link)
 431 {
 432   return lmm_constraint_is_shared(((surf_resource_lmm_t) link)->constraint);
 433 }
 434
 435 static void action_suspend(surf_action_t action)
 436 {
 437   ((surf_action_network_CM02_t) action)->suspended = 1;
 438   lmm_update_variable_weight(network_maxmin_system,
 439                              ((surf_action_network_CM02_t) action)->variable,
 440                              0.0);
 441 }
 442
 443 static void action_resume(surf_action_t action)
 444 {
 445   if (((surf_action_network_CM02_t) action)->suspended) {
 446     lmm_update_variable_weight(network_maxmin_system,
 447                                ((surf_action_network_CM02_t)
 448                                 action)->variable,
 449                                ((surf_action_network_CM02_t) action)->weight);
 450     ((surf_action_network_CM02_t) action)->suspended = 0;
 451   }
 452 }
 453
 454 static int action_is_suspended(surf_action_t action)
 455 {
 456   return ((surf_action_network_CM02_t) action)->suspended;
 457 }
 458
 459 static void action_set_max_duration(surf_action_t action, double duration)
 460 {
 461   action->max_duration = duration;
 462 }
 463
 464 static void finalize(void)
 465 {
 466   surf_model_exit(surf_network_model);
 467   surf_network_model = NULL;
 468
 469   used_routing->finalize();
 470   lmm_system_free(network_maxmin_system);
 471   network_maxmin_system = NULL;
 472 }
 473
 474 static void surf_network_model_init_internal(void)
 475 {
 476   surf_network_model = surf_model_init();
 477
 478   surf_network_model->name = "network";
 479   surf_network_model->action_unref = action_unref;
 480   surf_network_model->action_cancel = action_cancel;
 481   surf_network_model->action_recycle = action_recycle;
 482
 483   surf_network_model->model_private->resource_used = resource_used;
 484   surf_network_model->model_private->share_resources = share_resources;
 485   surf_network_model->model_private->update_actions_state =
 486     update_actions_state;
 487   surf_network_model->model_private->update_resource_state =
 488     update_resource_state;
 489   surf_network_model->model_private->finalize = finalize;
 490
 491   surf_network_model->suspend = action_suspend;
 492   surf_network_model->resume = action_resume;
 493   surf_network_model->is_suspended = action_is_suspended;
 494   surf_cpu_model->set_max_duration = action_set_max_duration;
 495
 496   surf_network_model->extension.network.communicate = communicate;
 497   surf_network_model->extension.network.get_link_bandwidth =
 498     get_link_bandwidth;
 499   surf_network_model->extension.network.get_link_latency = get_link_latency;
 500   surf_network_model->extension.network.link_shared = link_shared;
 501
 502   if (!network_maxmin_system)
 503     network_maxmin_system = lmm_system_new();
 504
 505   routing_model_create(sizeof(link_CM02_t),
 506       link_new(xbt_strdup("__loopback__"),
 507           498000000, NULL, 0.000015, NULL,
 508           SURF_RESOURCE_ON, NULL, SURF_LINK_FATPIPE, NULL));
 509 }
 510
 511 /************************************************************************/
 512 /* New model based on optimizations discussed during this thesis        */
 513 /************************************************************************/
 514 void surf_network_model_init_LegrandVelho(const char *filename)
 515 {
 516
 517   if (surf_network_model)
 518     return;
 519   surf_network_model_init_internal();
 520   define_callbacks(filename);
 521   xbt_dynar_push(model_list, &surf_network_model);
 522   network_solve = lmm_solve;
 523
 524   latency_factor = 10.4;
 525   bandwidth_factor = 0.92;
 526   weight_S_parameter = 8775;
 527
 528   update_model_description(surf_network_model_description,
 529                            "LegrandVelho", surf_network_model);
 530 }
 531
 532 /***************************************************************************/
 533 /* The nice TCP sharing model designed by Loris Marchal and Henri Casanova */
 534 /***************************************************************************/
 535 /* @TechReport{      rr-lip2002-40, */
 536 /*   author        = {Henri Casanova and Loris Marchal}, */
 537 /*   institution   = {LIP}, */
 538 /*   title         = {A Network Model for Simulation of Grid Application}, */
 539 /*   number        = {2002-40}, */
 540 /*   month         = {oct}, */
 541 /*   year          = {2002} */
 542 /* } */
 543 void surf_network_model_init_CM02(const char *filename)
 544 {
 545
 546   if (surf_network_model)
 547     return;
 548   surf_network_model_init_internal();
 549   define_callbacks(filename);
 550   xbt_dynar_push(model_list, &surf_network_model);
 551   network_solve = lmm_solve;
 552
 553   update_model_description(surf_network_model_description,
 554                            "CM02", surf_network_model);
 555 }
 556
 557 void surf_network_model_init_Reno(const char *filename)
 558 {
 559   if (surf_network_model)
 560     return;
 561   surf_network_model_init_internal();
 562   define_callbacks(filename);
 563
 564   xbt_dynar_push(model_list, &surf_network_model);
 565   lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi);
 566   network_solve = lagrange_solve;
 567
 568   latency_factor = 10.4;
 569   bandwidth_factor = 0.92;
 570   weight_S_parameter = 8775;
 571
 572   update_model_description(surf_network_model_description,
 573                            "Reno", surf_network_model);
 574 }
 575
 576
 577 void surf_network_model_init_Reno2(const char *filename)
 578 {
 579   if (surf_network_model)
 580     return;
 581   surf_network_model_init_internal();
 582   define_callbacks(filename);
 583
 584   xbt_dynar_push(model_list, &surf_network_model);
 585   lmm_set_default_protocol_function(func_reno2_f, func_reno2_fp,
 586                                     func_reno2_fpi);
 587   network_solve = lagrange_solve;
 588
 589   latency_factor = 10.4;
 590   bandwidth_factor = 0.92;
 591   weight_S_parameter = 8775;
 592
 593   update_model_description(surf_network_model_description,
 594                            "Reno2", surf_network_model);
 595 }
 596
 597 void surf_network_model_init_Vegas(const char *filename)
 598 {
 599   if (surf_network_model)
 600     return;
 601   surf_network_model_init_internal();
 602   define_callbacks(filename);
 603
 604   xbt_dynar_push(model_list, &surf_network_model);
 605   lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
 606                                     func_vegas_fpi);
 607   network_solve = lagrange_solve;
 608
 609   latency_factor = 10.4;
 610   bandwidth_factor = 0.92;
 611   weight_S_parameter = 8775;
 612
 613   update_model_description(surf_network_model_description,
 614                            "Vegas", surf_network_model);
 615 }