src/surf/network.c

   1 /* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "network_private.h"
   8 #include "xbt/log.h"
   9 #include "xbt/str.h"
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network, surf,
  12                                 "Logging specific to the SURF network module");
  13
  14 surf_model_t surf_network_model = NULL;
  15 static lmm_system_t network_maxmin_system = NULL;
  16 static void (*network_solve) (lmm_system_t) = NULL;
  17
  18 double sg_sender_gap = 0.0;
  19 double sg_latency_factor = 1.0; /* default value; can be set by model or from command line */
  20 double sg_bandwidth_factor = 1.0;       /* default value; can be set by model or from command line */
  21 double sg_weight_S_parameter = 0.0;     /* default value; can be set by model or from command line */
  22
  23 double sg_tcp_gamma = 0.0;
  24 int sg_network_fullduplex = 0;
  25
  26 xbt_dict_t gap_lookup = NULL;
  27
  28 static double net_get_link_bandwidth(const void *link);
  29
  30 static void gap_append(double size, const link_CM02_t link, surf_action_network_CM02_t action) {
  31    const char* src = link->lmm_resource.generic_resource.name;
  32    xbt_fifo_t fifo;
  33    surf_action_network_CM02_t last_action;
  34    double bw;
  35
  36    if(sg_sender_gap > 0.0) {
  37       if(!gap_lookup) {
  38          gap_lookup = xbt_dict_new();
  39       }
  40       fifo = (xbt_fifo_t)xbt_dict_get_or_null(gap_lookup, src);
  41       action->sender.gap = 0.0;
  42       if(fifo && xbt_fifo_size(fifo) > 0) {
  43          /* Compute gap from last send */
  44          last_action = (surf_action_network_CM02_t)xbt_fifo_get_item_content(xbt_fifo_get_last_item(fifo));
  45          bw = net_get_link_bandwidth(link);
  46          action->sender.gap = last_action->sender.gap + max(sg_sender_gap, last_action->sender.size / bw);
  47          action->latency += action->sender.gap;
  48       }
  49       /* Append action as last send */
  50       action->sender.link_name = link->lmm_resource.generic_resource.name;
  51       fifo = (xbt_fifo_t)xbt_dict_get_or_null(gap_lookup, action->sender.link_name);
  52       if(!fifo) {
  53          fifo = xbt_fifo_new();
  54          xbt_dict_set(gap_lookup, action->sender.link_name, fifo, NULL);
  55       }
  56       action->sender.fifo_item = xbt_fifo_push(fifo, action);
  57       action->sender.size = size;
  58    }
  59 }
  60
  61 static void gap_unknown(surf_action_network_CM02_t action) {
  62    action->sender.gap = 0.0;
  63    action->sender.link_name = NULL;
  64    action->sender.fifo_item = NULL;
  65    action->sender.size = 0.0;
  66 }
  67
  68 static void gap_remove(surf_action_network_CM02_t action) {
  69    xbt_fifo_t fifo;
  70    size_t size;
  71
  72    if(sg_sender_gap > 0.0 && action->sender.link_name && action->sender.fifo_item) {
  73       fifo = (xbt_fifo_t)xbt_dict_get_or_null(gap_lookup, action->sender.link_name);
  74       xbt_fifo_remove_item(fifo, action->sender.fifo_item);
  75       size = xbt_fifo_size(fifo);
  76       if(size == 0) {
  77          xbt_fifo_free(fifo);
  78          xbt_dict_remove(gap_lookup, action->sender.link_name);
  79          size = xbt_dict_size(gap_lookup);
  80          if(size == 0) {
  81             xbt_dict_free(&gap_lookup);
  82          }
  83       }
  84    }
  85 }
  86
  87 /******************************************************************************/
  88 /*                           Factors callbacks                                */
  89 /******************************************************************************/
  90 static double constant_latency_factor(double size)
  91 {
  92   return sg_latency_factor;
  93 }
  94
  95 static double constant_bandwidth_factor(double size)
  96 {
  97   return sg_bandwidth_factor;
  98 }
  99
 100 static double constant_bandwidth_constraint(double rate, double bound,
 101                                             double size)
 102 {
 103   return rate;
 104 }
 105
 106 /**********************/
 107 /*   SMPI callbacks   */
 108 /**********************/
 109 static double smpi_latency_factor(double size)
 110 {
 111   /* 1 B <= size <= 1 KiB */
 112   if (size <= 1024.0) {
 113     return 1.0056;
 114   }
 115
 116   /* 2 KiB <= size <= 32 KiB */
 117   if (size <= 32768.0) {
 118     return 1.8805;
 119   }
 120
 121   /* 64 KiB <= size <= 4 MiB */
 122   return 22.7111;
 123 }
 124
 125 static double smpi_bandwidth_factor(double size)
 126 {
 127   /* 1 B <= size <= 1 KiB */
 128   if (size <= 1024.0) {
 129     return 0.2758;
 130   }
 131
 132   /* 2 KiB <= size <= 32 KiB */
 133   if (size <= 32768.0) {
 134     return 0.5477;
 135   }
 136
 137   /* 64 KiB <= size <= 4 MiB */
 138   return 0.9359;
 139 }
 140
 141 static double smpi_bandwidth_constraint(double rate, double bound,
 142                                         double size)
 143 {
 144   return rate < 0 ? bound : min(bound, rate * smpi_bandwidth_factor(size));
 145 }
 146
 147
 148 static double (*latency_factor_callback) (double) =
 149     &constant_latency_factor;
 150 static double (*bandwidth_factor_callback) (double) =
 151     &constant_bandwidth_factor;
 152 static double (*bandwidth_constraint_callback) (double, double, double) =
 153     &constant_bandwidth_constraint;
 154
 155
 156 static void* net_create_resource(char *name,
 157                                 double bw_initial,
 158                                 tmgr_trace_t bw_trace,
 159                                 double lat_initial,
 160                                 tmgr_trace_t lat_trace,
 161                                 e_surf_resource_state_t
 162                                 state_initial,
 163                                 tmgr_trace_t state_trace,
 164                                 e_surf_link_sharing_policy_t
 165                                 policy, xbt_dict_t properties)
 166 {
 167   link_CM02_t nw_link = (link_CM02_t)
 168       surf_resource_lmm_new(sizeof(s_link_CM02_t),
 169                             surf_network_model, name, properties,
 170                             network_maxmin_system,
 171                             sg_bandwidth_factor * bw_initial,
 172                             history,
 173                             state_initial, state_trace,
 174                             bw_initial, bw_trace);
 175
 176   xbt_assert(!xbt_lib_get_or_null(link_lib, name, SURF_LINK_LEVEL),
 177               "Link '%s' declared several times in the platform file.",
 178               name);
 179
 180   nw_link->lat_current = lat_initial;
 181   if (lat_trace)
 182     nw_link->lat_event =
 183         tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
 184
 185   if (policy == SURF_LINK_FATPIPE)
 186     lmm_constraint_shared(nw_link->lmm_resource.constraint);
 187
 188   xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, nw_link);
 189
 190   return nw_link;
 191 }
 192
 193 static void net_parse_link_init(void)
 194 {
 195   char *name_link;
 196   double bw_initial;
 197   tmgr_trace_t bw_trace;
 198   double lat_initial;
 199   tmgr_trace_t lat_trace;
 200   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
 201   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
 202   tmgr_trace_t state_trace;
 203   XBT_DEBUG("link_CM02");
 204   name_link = xbt_strdup(A_surfxml_link_id);
 205   surf_parse_get_double(&bw_initial, A_surfxml_link_bandwidth);
 206   bw_trace = tmgr_trace_new(A_surfxml_link_bandwidth_file);
 207   surf_parse_get_double(&lat_initial, A_surfxml_link_latency);
 208   lat_trace = tmgr_trace_new(A_surfxml_link_latency_file);
 209
 210   xbt_assert((A_surfxml_link_state == A_surfxml_link_state_ON)
 211               || (A_surfxml_link_state ==
 212                   A_surfxml_link_state_OFF), "Invalid state");
 213   if (A_surfxml_link_state == A_surfxml_link_state_ON)
 214     state_initial_link = SURF_RESOURCE_ON;
 215   else if (A_surfxml_link_state == A_surfxml_link_state_OFF)
 216     state_initial_link = SURF_RESOURCE_OFF;
 217
 218   if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
 219     policy_initial_link = SURF_LINK_SHARED;
 220   else
 221           {
 222           if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FATPIPE)
 223                   policy_initial_link = SURF_LINK_FATPIPE;
 224           else if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_FULLDUPLEX)
 225                   policy_initial_link = SURF_LINK_FULLDUPLEX;
 226           }
 227
 228   state_trace = tmgr_trace_new(A_surfxml_link_state_file);
 229
 230   if(policy_initial_link == SURF_LINK_FULLDUPLEX)
 231   {
 232     net_create_resource(bprintf("%s_UP",name_link), bw_initial, bw_trace,
 233                        lat_initial, lat_trace, state_initial_link, state_trace,
 234                        policy_initial_link, xbt_dict_new());
 235     net_create_resource(bprintf("%s_DOWN",name_link), bw_initial, bw_trace,
 236                        lat_initial, lat_trace, state_initial_link, state_trace,
 237                        policy_initial_link, xbt_dict_new());
 238   }
 239   else
 240   {
 241     net_create_resource(name_link, bw_initial, bw_trace,
 242                        lat_initial, lat_trace, state_initial_link, state_trace,
 243                        policy_initial_link, xbt_dict_new());
 244   }
 245
 246 }
 247
 248 static void net_add_traces(void)
 249 {
 250   xbt_dict_cursor_t cursor = NULL;
 251   char *trace_name, *elm;
 252
 253   static int called = 0;
 254   if (called)
 255     return;
 256   called = 1;
 257
 258   /* connect all traces relative to network */
 259   xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
 260     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 261     link_CM02_t link =
 262         xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
 263
 264     xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
 265                 trace_name, elm);
 266     xbt_assert(trace,
 267                 "Cannot connect trace %s to link %s: trace undefined",
 268                 trace_name, elm);
 269
 270     link->lmm_resource.state_event =
 271         tmgr_history_add_trace(history, trace, 0.0, 0, link);
 272   }
 273
 274   xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
 275     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 276     link_CM02_t link =
 277                 xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
 278
 279     xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
 280                 trace_name, elm);
 281     xbt_assert(trace,
 282                 "Cannot connect trace %s to link %s: trace undefined",
 283                 trace_name, elm);
 284
 285     link->lmm_resource.power.event =
 286         tmgr_history_add_trace(history, trace, 0.0, 0, link);
 287   }
 288
 289   xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
 290     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 291     link_CM02_t link =
 292                 xbt_lib_get_or_null(link_lib, elm, SURF_LINK_LEVEL);
 293
 294     xbt_assert(link, "Cannot connect trace %s to link %s: link undefined",
 295                 trace_name, elm);
 296     xbt_assert(trace,
 297                 "Cannot connect trace %s to link %s: trace undefined",
 298                 trace_name, elm);
 299
 300     link->lat_event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
 301   }
 302 }
 303
 304 static void net_define_callbacks(const char *file)
 305 {
 306   /* Figuring out the network links */
 307   surfxml_add_callback(STag_surfxml_link_cb_list, &net_parse_link_init);
 308   surfxml_add_callback(ETag_surfxml_platform_cb_list, &net_add_traces);
 309 }
 310
 311 static int net_resource_used(void *resource_id)
 312 {
 313   return lmm_constraint_used(network_maxmin_system,
 314                              ((surf_resource_lmm_t)
 315                               resource_id)->constraint);
 316 }
 317
 318 static int net_action_unref(surf_action_t action)
 319 {
 320   action->refcount--;
 321   if (!action->refcount) {
 322     xbt_swag_remove(action, action->state_set);
 323     if (((surf_action_network_CM02_t) action)->variable)
 324       lmm_variable_free(network_maxmin_system,
 325                         ((surf_action_network_CM02_t) action)->variable);
 326 #ifdef HAVE_TRACING
 327     xbt_free(((surf_action_network_CM02_t) action)->src_name);
 328     xbt_free(((surf_action_network_CM02_t) action)->dst_name);
 329     if (action->category)
 330       xbt_free(action->category);
 331 #endif
 332     surf_action_free(&action);
 333     return 1;
 334   }
 335   return 0;
 336 }
 337
 338 static void net_action_cancel(surf_action_t action)
 339 {
 340   surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
 341 }
 342
 343 void net_action_recycle(surf_action_t action)
 344 {
 345   return;
 346 }
 347
 348 #ifdef HAVE_LATENCY_BOUND_TRACKING
 349 int net_get_link_latency_limited(surf_action_t action)
 350 {
 351   return action->latency_limited;
 352 }
 353 #endif
 354
 355 double net_action_get_remains(surf_action_t action)
 356 {
 357   return action->remains;
 358 }
 359
 360 static double net_share_resources(double now)
 361 {
 362   s_surf_action_network_CM02_t s_action;
 363   surf_action_network_CM02_t action = NULL;
 364   xbt_swag_t running_actions =
 365       surf_network_model->states.running_action_set;
 366   double min;
 367
 368   min = generic_maxmin_share_resources(running_actions,
 369                                        xbt_swag_offset(s_action,
 370                                                        variable),
 371                                        network_maxmin_system,
 372                                        network_solve);
 373
 374 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + xbt_swag_offset(s_action, variable)  )))
 375
 376   xbt_swag_foreach(action, running_actions) {
 377 #ifdef HAVE_LATENCY_BOUND_TRACKING
 378     if (lmm_is_variable_limited_by_latency(action->variable)) {
 379       (action->generic_action).latency_limited = 1;
 380     } else {
 381       (action->generic_action).latency_limited = 0;
 382     }
 383 #endif
 384     if (action->latency > 0) {
 385       if (min < 0)
 386         min = action->latency;
 387       else if (action->latency < min)
 388         min = action->latency;
 389     }
 390   }
 391
 392   XBT_DEBUG("Min of share resources %f", min);
 393
 394   return min;
 395 }
 396
 397 static void net_update_actions_state(double now, double delta)
 398 {
 399   double deltap = 0.0;
 400   surf_action_network_CM02_t action = NULL;
 401   surf_action_network_CM02_t next_action = NULL;
 402   xbt_swag_t running_actions =
 403       surf_network_model->states.running_action_set;
 404   /*
 405      xbt_swag_t failed_actions =
 406      surf_network_model->states.failed_action_set;
 407    */
 408
 409   xbt_swag_foreach_safe(action, next_action, running_actions) {
 410     deltap = delta;
 411     if (action->latency > 0) {
 412       if (action->latency > deltap) {
 413         double_update(&(action->latency), deltap);
 414         deltap = 0.0;
 415       } else {
 416         double_update(&(deltap), action->latency);
 417         action->latency = 0.0;
 418       }
 419       if ((action->latency == 0.0) && !(action->suspended))
 420         lmm_update_variable_weight(network_maxmin_system, action->variable,
 421                                    action->weight);
 422     }
 423 #ifdef HAVE_TRACING
 424     if (TRACE_is_enabled()) {
 425       xbt_dynar_t route = global_routing->get_route(action->src_name,
 426                                                     action->dst_name);
 427       link_CM02_t link;
 428       unsigned int i;
 429       xbt_dynar_foreach(route, i, link) {
 430         TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
 431                                         action->generic_action.data,
 432                                         (surf_action_t) action,
 433                                         lmm_variable_getvalue
 434                                         (action->variable), now - delta,
 435                                         delta);
 436       }
 437     }
 438 #endif
 439     if(!lmm_get_number_of_cnst_from_var(network_maxmin_system, action->variable)) {
 440                                 /* There is actually no link used, hence an infinite bandwidth.
 441                                  * This happens often when using models like vivaldi.
 442                                  * In such case, just make sure that the action completes immediately.
 443                                  */
 444         double_update(&(action->generic_action.remains),
 445                         action->generic_action.remains);
 446     }
 447     double_update(&(action->generic_action.remains),
 448                   lmm_variable_getvalue(action->variable) * deltap);
 449     if (action->generic_action.max_duration != NO_MAX_DURATION)
 450       double_update(&(action->generic_action.max_duration), delta);
 451
 452     if ((action->generic_action.remains <= 0) &&
 453         (lmm_get_variable_weight(action->variable) > 0)) {
 454       action->generic_action.finish = surf_get_clock();
 455       surf_network_model->action_state_set((surf_action_t) action,
 456                                            SURF_ACTION_DONE);
 457       gap_remove(action);
 458     } else if ((action->generic_action.max_duration != NO_MAX_DURATION)
 459                && (action->generic_action.max_duration <= 0)) {
 460       action->generic_action.finish = surf_get_clock();
 461       surf_network_model->action_state_set((surf_action_t) action,
 462                                            SURF_ACTION_DONE);
 463       gap_remove(action);
 464     }
 465   }
 466
 467   return;
 468 }
 469
 470 static void net_update_resource_state(void *id,
 471                                       tmgr_trace_event_t event_type,
 472                                       double value, double date)
 473 {
 474   link_CM02_t nw_link = id;
 475   /*   printf("[" "%lg" "] Asking to update network card \"%s\" with value " */
 476   /*     "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
 477   /*     value, event_type); */
 478
 479   if (event_type == nw_link->lmm_resource.power.event) {
 480     double delta =
 481         sg_weight_S_parameter / value - sg_weight_S_parameter /
 482         (nw_link->lmm_resource.power.peak *
 483          nw_link->lmm_resource.power.scale);
 484     lmm_variable_t var = NULL;
 485     lmm_element_t elem = NULL;
 486     surf_action_network_CM02_t action = NULL;
 487
 488     nw_link->lmm_resource.power.peak = value;
 489     lmm_update_constraint_bound(network_maxmin_system,
 490                                 nw_link->lmm_resource.constraint,
 491                                 sg_bandwidth_factor *
 492                                 (nw_link->lmm_resource.power.peak *
 493                                  nw_link->lmm_resource.power.scale));
 494 #ifdef HAVE_TRACING
 495     TRACE_surf_link_set_bandwidth(date, nw_link->lmm_resource.generic_resource.name,
 496                                   sg_bandwidth_factor *
 497                                   (nw_link->lmm_resource.power.peak *
 498                                    nw_link->lmm_resource.power.scale));
 499 #endif
 500     if (sg_weight_S_parameter > 0) {
 501       while ((var = lmm_get_var_from_cnst
 502               (network_maxmin_system, nw_link->lmm_resource.constraint,
 503                &elem))) {
 504         action = lmm_variable_id(var);
 505         action->weight += delta;
 506         if (!(action->suspended))
 507           lmm_update_variable_weight(network_maxmin_system,
 508                                      action->variable, action->weight);
 509       }
 510     }
 511     if (tmgr_trace_event_free(event_type))
 512       nw_link->lmm_resource.power.event = NULL;
 513   } else if (event_type == nw_link->lat_event) {
 514     double delta = value - nw_link->lat_current;
 515     lmm_variable_t var = NULL;
 516     lmm_element_t elem = NULL;
 517     surf_action_network_CM02_t action = NULL;
 518
 519     nw_link->lat_current = value;
 520     while ((var = lmm_get_var_from_cnst
 521             (network_maxmin_system, nw_link->lmm_resource.constraint,
 522              &elem))) {
 523       action = lmm_variable_id(var);
 524       action->lat_current += delta;
 525       action->weight += delta;
 526       if (action->rate < 0)
 527         lmm_update_variable_bound(network_maxmin_system, action->variable,
 528                                   sg_tcp_gamma / (2.0 *
 529                                                   action->lat_current));
 530       else {
 531         lmm_update_variable_bound(network_maxmin_system, action->variable,
 532                                   min(action->rate,
 533                                       sg_tcp_gamma / (2.0 *
 534                                                       action->lat_current)));
 535
 536         if (action->rate < sg_tcp_gamma / (2.0 * action->lat_current)) {
 537           XBT_INFO("Flow is limited BYBANDWIDTH");
 538         } else {
 539           XBT_INFO("Flow is limited BYLATENCY, latency of flow is %f",
 540                 action->lat_current);
 541         }
 542       }
 543       if (!(action->suspended))
 544         lmm_update_variable_weight(network_maxmin_system, action->variable,
 545                                    action->weight);
 546
 547     }
 548     if (tmgr_trace_event_free(event_type))
 549       nw_link->lat_event = NULL;
 550   } else if (event_type == nw_link->lmm_resource.state_event) {
 551     if (value > 0)
 552       nw_link->lmm_resource.state_current = SURF_RESOURCE_ON;
 553     else {
 554       lmm_constraint_t cnst = nw_link->lmm_resource.constraint;
 555       lmm_variable_t var = NULL;
 556       lmm_element_t elem = NULL;
 557
 558       nw_link->lmm_resource.state_current = SURF_RESOURCE_OFF;
 559       while ((var = lmm_get_var_from_cnst
 560               (network_maxmin_system, cnst, &elem))) {
 561         surf_action_t action = lmm_variable_id(var);
 562
 563         if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
 564             surf_action_state_get(action) == SURF_ACTION_READY) {
 565           action->finish = date;
 566           surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
 567         }
 568       }
 569     }
 570     if (tmgr_trace_event_free(event_type))
 571       nw_link->lmm_resource.state_event = NULL;
 572   } else {
 573     XBT_CRITICAL("Unknown event ! \n");
 574     xbt_abort();
 575   }
 576
 577   return;
 578 }
 579
 580
 581 static surf_action_t net_communicate(const char *src_name,
 582                                      const char *dst_name, double size,
 583                                      double rate)
 584 {
 585   unsigned int i;
 586   link_CM02_t link;
 587   int failed = 0;
 588   surf_action_network_CM02_t action = NULL;
 589   double bandwidth_bound;
 590   double latency=0.0;
 591   /* LARGE PLATFORMS HACK:
 592      Add a link_CM02_t *link and a int link_nb to network_card_CM02_t. It will represent local links for this node
 593      Use the cluster_id for ->id */
 594
 595   xbt_dynar_t back_route = NULL;
 596   int constraints_per_variable = 0;
 597   xbt_dynar_t route;
 598   // I will need this route for some time so require for no cleanup
 599   global_routing->get_route_latency(src_name, dst_name, &route, &latency, 0);
 600
 601   if (sg_network_fullduplex == 1) {
 602     back_route = global_routing->get_route(dst_name, src_name);
 603   }
 604
 605   /* LARGE PLATFORMS HACK:
 606      total_route_size = route_size + src->link_nb + dst->nb */
 607
 608   XBT_IN("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 609   /* LARGE PLATFORMS HACK:
 610      assert on total_route_size */
 611   xbt_assert(xbt_dynar_length(route) || latency,
 612               "You're trying to send data from %s to %s but there is no connection at all between these two hosts.",
 613               src_name, dst_name);
 614
 615   xbt_dynar_foreach(route, i, link) {
 616     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
 617       failed = 1;
 618       break;
 619     }
 620   }
 621   action =
 622       surf_action_new(sizeof(s_surf_action_network_CM02_t), size,
 623                       surf_network_model, failed);
 624 #ifdef HAVE_LATENCY_BOUND_TRACKING
 625   (action->generic_action).latency_limited = 0;
 626 #endif
 627   action->weight = action->latency = latency;
 628
 629   xbt_swag_insert(action, action->generic_action.state_set);
 630   action->rate = rate;
 631
 632   bandwidth_bound = -1.0;
 633
 634   xbt_dynar_foreach(route, i, link) {
 635     action->weight +=
 636         sg_weight_S_parameter /
 637         (link->lmm_resource.power.peak * link->lmm_resource.power.scale);
 638     if (bandwidth_bound < 0.0)
 639       bandwidth_bound =
 640           (*bandwidth_factor_callback) (size) *
 641           (link->lmm_resource.power.peak * link->lmm_resource.power.scale);
 642     else
 643       bandwidth_bound =
 644           min(bandwidth_bound,
 645               (*bandwidth_factor_callback) (size) *
 646               (link->lmm_resource.power.peak *
 647                link->lmm_resource.power.scale));
 648   }
 649   /* LARGE PLATFORMS HACK:
 650      Add src->link and dst->link latencies */
 651   action->lat_current = action->latency;
 652   action->latency *= (*latency_factor_callback) (size);
 653   action->rate =
 654       (*bandwidth_constraint_callback) (action->rate, bandwidth_bound,
 655                                         size);
 656
 657   if(xbt_dynar_length(route) > 0) {
 658     link = *(link_CM02_t*)xbt_dynar_get_ptr(route, 0);
 659     gap_append(size, link, action);
 660     XBT_DEBUG("Comm %p: %s -> %s gap=%f (lat=%f)",
 661            action, src_name, dst_name, action->sender.gap, action->latency);
 662   } else {
 663     gap_unknown(action);
 664   }
 665
 666
 667   /* LARGE PLATFORMS HACK:
 668      lmm_variable_new(..., total_route_size) */
 669   if (back_route != NULL) {
 670     constraints_per_variable =
 671         xbt_dynar_length(route) + xbt_dynar_length(back_route);
 672   } else {
 673     constraints_per_variable = xbt_dynar_length(route);
 674   }
 675
 676   if (action->latency > 0)
 677     action->variable =
 678         lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
 679                          constraints_per_variable);
 680   else
 681     action->variable =
 682         lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
 683                          constraints_per_variable);
 684
 685   if (action->rate < 0) {
 686     if (action->lat_current > 0)
 687       lmm_update_variable_bound(network_maxmin_system, action->variable,
 688                                 sg_tcp_gamma / (2.0 *
 689                                                 action->lat_current));
 690     else
 691       lmm_update_variable_bound(network_maxmin_system, action->variable,
 692                                 -1.0);
 693   } else {
 694     if (action->lat_current > 0)
 695       lmm_update_variable_bound(network_maxmin_system, action->variable,
 696                                 min(action->rate,
 697                                     sg_tcp_gamma / (2.0 *
 698                                                     action->lat_current)));
 699     else
 700       lmm_update_variable_bound(network_maxmin_system, action->variable,
 701                                 action->rate);
 702   }
 703
 704   xbt_dynar_foreach(route, i, link) {
 705     lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
 706                action->variable, 1.0);
 707   }
 708
 709   if (sg_network_fullduplex == 1) {
 710     XBT_DEBUG("Fullduplex active adding backward flow using 5%c", '%');
 711     xbt_dynar_foreach(back_route, i, link) {
 712       lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
 713                  action->variable, .05);
 714     }
 715   }
 716   /* LARGE PLATFORMS HACK:
 717      expand also with src->link and dst->link */
 718 #ifdef HAVE_TRACING
 719   if (TRACE_is_enabled()) {
 720     action->src_name = xbt_strdup(src_name);
 721     action->dst_name = xbt_strdup(dst_name);
 722   } else {
 723     action->src_name = action->dst_name = NULL;
 724   }
 725 #endif
 726
 727   xbt_dynar_free(&route);
 728   XBT_OUT();
 729
 730   return (surf_action_t) action;
 731 }
 732
 733 static xbt_dynar_t net_get_route(const char *src, const char *dst)
 734 {
 735   return global_routing->get_route(src, dst);
 736 }
 737
 738 static double net_get_link_bandwidth(const void *link)
 739 {
 740   surf_resource_lmm_t lmm = (surf_resource_lmm_t) link;
 741   return lmm->power.peak * lmm->power.scale;
 742 }
 743
 744 static double net_get_link_latency(const void *link)
 745 {
 746   return ((link_CM02_t) link)->lat_current;
 747 }
 748
 749 static int net_link_shared(const void *link)
 750 {
 751   return
 752       lmm_constraint_is_shared(((surf_resource_lmm_t) link)->constraint);
 753 }
 754
 755 static void net_action_suspend(surf_action_t action)
 756 {
 757   ((surf_action_network_CM02_t) action)->suspended = 1;
 758   lmm_update_variable_weight(network_maxmin_system,
 759                              ((surf_action_network_CM02_t)
 760                               action)->variable, 0.0);
 761 }
 762
 763 static void net_action_resume(surf_action_t action)
 764 {
 765   if (((surf_action_network_CM02_t) action)->suspended) {
 766     lmm_update_variable_weight(network_maxmin_system,
 767                                ((surf_action_network_CM02_t)
 768                                 action)->variable,
 769                                ((surf_action_network_CM02_t)
 770                                 action)->weight);
 771     ((surf_action_network_CM02_t) action)->suspended = 0;
 772   }
 773 }
 774
 775 static int net_action_is_suspended(surf_action_t action)
 776 {
 777   return ((surf_action_network_CM02_t) action)->suspended;
 778 }
 779
 780 void net_action_set_max_duration(surf_action_t action, double duration)
 781 {
 782   action->max_duration = duration;
 783 }
 784
 785 #ifdef HAVE_TRACING
 786 static void net_action_set_category(surf_action_t action, const char *category)
 787 {
 788   action->category = xbt_strdup (category);
 789 }
 790 #endif
 791
 792 static void net_finalize(void)
 793 {
 794   surf_model_exit(surf_network_model);
 795   surf_network_model = NULL;
 796
 797   global_routing->finalize();
 798
 799   lmm_system_free(network_maxmin_system);
 800   network_maxmin_system = NULL;
 801 }
 802
 803 static void surf_network_model_init_internal(void)
 804 {
 805   surf_network_model = surf_model_init();
 806
 807   surf_network_model->name = "network";
 808   surf_network_model->action_unref = net_action_unref;
 809   surf_network_model->action_cancel = net_action_cancel;
 810   surf_network_model->action_recycle = net_action_recycle;
 811   surf_network_model->get_remains = net_action_get_remains;
 812 #ifdef HAVE_LATENCY_BOUND_TRACKING
 813   surf_network_model->get_latency_limited = net_get_link_latency_limited;
 814 #endif
 815
 816   surf_network_model->model_private->resource_used = net_resource_used;
 817   surf_network_model->model_private->share_resources = net_share_resources;
 818   surf_network_model->model_private->update_actions_state =
 819       net_update_actions_state;
 820   surf_network_model->model_private->update_resource_state =
 821       net_update_resource_state;
 822   surf_network_model->model_private->finalize = net_finalize;
 823
 824   surf_network_model->suspend = net_action_suspend;
 825   surf_network_model->resume = net_action_resume;
 826   surf_network_model->is_suspended = net_action_is_suspended;
 827   surf_network_model->set_max_duration = net_action_set_max_duration;
 828 #ifdef HAVE_TRACING
 829   surf_network_model->set_category = net_action_set_category;
 830 #endif
 831
 832   surf_network_model->extension.network.communicate = net_communicate;
 833   surf_network_model->extension.network.get_route = net_get_route;
 834   surf_network_model->extension.network.get_link_bandwidth =
 835       net_get_link_bandwidth;
 836   surf_network_model->extension.network.get_link_latency =
 837       net_get_link_latency;
 838   surf_network_model->extension.network.link_shared = net_link_shared;
 839   surf_network_model->extension.network.add_traces = net_add_traces;
 840   surf_network_model->extension.network.create_resource =
 841       net_create_resource;
 842
 843   if (!network_maxmin_system)
 844     network_maxmin_system = lmm_system_new();
 845
 846   routing_model_create(sizeof(link_CM02_t),
 847       net_create_resource(xbt_strdup("__loopback__"),
 848           498000000, NULL, 0.000015, NULL,
 849             SURF_RESOURCE_ON, NULL,
 850             SURF_LINK_FATPIPE, NULL),
 851             net_get_link_latency);
 852 }
 853
 854
 855
 856 /************************************************************************/
 857 /* New model based on LV08 and experimental results of MPI ping-pongs   */
 858 /************************************************************************/
 859 void surf_network_model_init_SMPI(const char *filename)
 860 {
 861
 862   if (surf_network_model)
 863     return;
 864   surf_network_model_init_internal();
 865   latency_factor_callback = &smpi_latency_factor;
 866   bandwidth_factor_callback = &smpi_bandwidth_factor;
 867   bandwidth_constraint_callback = &smpi_bandwidth_constraint;
 868   net_define_callbacks(filename);
 869   xbt_dynar_push(model_list, &surf_network_model);
 870   network_solve = lmm_solve;
 871
 872   xbt_cfg_setdefault_double(_surf_cfg_set, "network/sender_gap", 10e-6);
 873   xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
 874
 875   update_model_description(surf_network_model_description,
 876                            "SMPI", surf_network_model);
 877 }
 878
 879 /************************************************************************/
 880 /* New model based on optimizations discussed during this thesis        */
 881 /************************************************************************/
 882 void surf_network_model_init_LegrandVelho(const char *filename)
 883 {
 884
 885   if (surf_network_model)
 886     return;
 887   surf_network_model_init_internal();
 888   net_define_callbacks(filename);
 889   xbt_dynar_push(model_list, &surf_network_model);
 890   network_solve = lmm_solve;
 891
 892   xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
 893   xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
 894                             0.92);
 895   xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
 896
 897   update_model_description(surf_network_model_description,
 898                            "LV08_fullupdate", surf_network_model);
 899 }
 900
 901 /***************************************************************************/
 902 /* The nice TCP sharing model designed by Loris Marchal and Henri Casanova */
 903 /***************************************************************************/
 904 /* @TechReport{      rr-lip2002-40, */
 905 /*   author        = {Henri Casanova and Loris Marchal}, */
 906 /*   institution   = {LIP}, */
 907 /*   title         = {A Network Model for Simulation of Grid Application}, */
 908 /*   number        = {2002-40}, */
 909 /*   month         = {oct}, */
 910 /*   year          = {2002} */
 911 /* } */
 912 void surf_network_model_init_CM02(const char *filename)
 913 {
 914
 915   if (surf_network_model)
 916     return;
 917   surf_network_model_init_internal();
 918   net_define_callbacks(filename);
 919   xbt_dynar_push(model_list, &surf_network_model);
 920   network_solve = lmm_solve;
 921
 922   update_model_description(surf_network_model_description,
 923                            "CM02", surf_network_model);
 924 }
 925
 926 void surf_network_model_init_Reno(const char *filename)
 927 {
 928   if (surf_network_model)
 929     return;
 930   surf_network_model_init_internal();
 931   net_define_callbacks(filename);
 932
 933   xbt_dynar_push(model_list, &surf_network_model);
 934   lmm_set_default_protocol_function(func_reno_f, func_reno_fp,
 935                                     func_reno_fpi);
 936   network_solve = lagrange_solve;
 937
 938   xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
 939   xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
 940                             0.92);
 941   xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
 942
 943   update_model_description(surf_network_model_description,
 944                            "Reno", surf_network_model);
 945 }
 946
 947
 948 void surf_network_model_init_Reno2(const char *filename)
 949 {
 950   if (surf_network_model)
 951     return;
 952   surf_network_model_init_internal();
 953   net_define_callbacks(filename);
 954
 955   xbt_dynar_push(model_list, &surf_network_model);
 956   lmm_set_default_protocol_function(func_reno2_f, func_reno2_fp,
 957                                     func_reno2_fpi);
 958   network_solve = lagrange_solve;
 959
 960   xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
 961   xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
 962                             0.92);
 963   xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S_parameter",
 964                             8775);
 965
 966   update_model_description(surf_network_model_description,
 967                            "Reno2", surf_network_model);
 968 }
 969
 970 void surf_network_model_init_Vegas(const char *filename)
 971 {
 972   if (surf_network_model)
 973     return;
 974   surf_network_model_init_internal();
 975   net_define_callbacks(filename);
 976
 977   xbt_dynar_push(model_list, &surf_network_model);
 978   lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
 979                                     func_vegas_fpi);
 980   network_solve = lagrange_solve;
 981
 982   xbt_cfg_setdefault_double(_surf_cfg_set, "network/latency_factor", 10.4);
 983   xbt_cfg_setdefault_double(_surf_cfg_set, "network/bandwidth_factor",
 984                             0.92);
 985   xbt_cfg_setdefault_double(_surf_cfg_set, "network/weight_S", 8775);
 986
 987   update_model_description(surf_network_model_description,
 988                            "Vegas", surf_network_model);
 989 }