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_latency_factor = 1.0;    /* default value; can be set by model or from command line */
  19 double sg_bandwidth_factor = 1.0;  /* default value; can be set by model or from command line */
  20 double sg_weight_S_parameter = 0.0;/* default value; can be set by model or from command line */
  21
  22 double sg_tcp_gamma = 0.0;
  23
  24
  25 /******************************************************************************/
  26 /*                           Factors callbacks                                */
  27 /******************************************************************************/
  28 static double constant_latency_factor(double size)
  29 {
  30   return sg_latency_factor;
  31 }
  32
  33 static double constant_bandwidth_factor(double size)
  34 {
  35   return sg_bandwidth_factor;
  36 }
  37
  38 static double constant_bandwidth_constraint(double rate, double bound, double size)
  39 {
  40   return rate;
  41 }
  42
  43 /**********************/
  44 /*   SMPI callbacks   */
  45 /**********************/
  46 static double smpi_latency_factor(double size)
  47 {
  48   /* 1 B <= size <= 1 KiB */
  49   if (size <= 1024.0) {
  50     return 1.0056;
  51   }
  52
  53   /* 2 KiB <= size <= 32 KiB */
  54   if (size <= 32768.0) {
  55     return 1.8805;
  56   }
  57
  58   /* 64 KiB <= size <= 4 MiB */
  59   return 22.7111;
  60 }
  61
  62 static double smpi_bandwidth_factor(double size)
  63 {
  64   /* 1 B <= size <= 1 KiB */
  65   if (size <= 1024.0) {
  66     return 0.2758;
  67   }
  68
  69   /* 2 KiB <= size <= 32 KiB */
  70   if (size <= 32768.0) {
  71     return 0.5477;
  72   }
  73
  74   /* 64 KiB <= size <= 4 MiB */
  75   return 0.9359;
  76 }
  77
  78 static double smpi_bandwidth_constraint(double rate, double bound, double size)
  79 {
  80   return rate < 0 ? bound : min(bound, rate * smpi_bandwidth_factor(size));
  81 }
  82
  83
  84 static double (*latency_factor_callback)(double) = &constant_latency_factor;
  85 static double (*bandwidth_factor_callback)(double) = &constant_bandwidth_factor;
  86 static double (*bandwidth_constraint_callback)(double, double, double) = &constant_bandwidth_constraint;
  87
  88
  89 static link_CM02_t net_link_new(char *name,
  90                             double bw_initial,
  91                             tmgr_trace_t bw_trace,
  92                             double lat_initial,
  93                             tmgr_trace_t lat_trace,
  94                             e_surf_resource_state_t
  95                             state_initial,
  96                             tmgr_trace_t state_trace,
  97                             e_surf_link_sharing_policy_t
  98                             policy, xbt_dict_t properties)
  99 {
 100   link_CM02_t nw_link = (link_CM02_t)
 101     surf_resource_lmm_new(sizeof(s_link_CM02_t),
 102                           surf_network_model, name, properties,
 103                           network_maxmin_system,
 104                           sg_bandwidth_factor * bw_initial,
 105                           history,
 106                           state_initial, state_trace,
 107                           bw_initial, bw_trace);
 108
 109   xbt_assert1(!xbt_dict_get_or_null(surf_network_model->resource_set, name),
 110               "Link '%s' declared several times in the platform file.", name);
 111
 112   nw_link->lat_current = lat_initial;
 113   if (lat_trace)
 114     nw_link->lat_event =
 115       tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
 116
 117   if (policy == SURF_LINK_FATPIPE)
 118     lmm_constraint_shared(nw_link->lmm_resource.constraint);
 119
 120   xbt_dict_set(surf_network_model->resource_set, name, nw_link,
 121                surf_resource_free);
 122 #ifdef HAVE_TRACING
 123   TRACE_surf_link_declaration (name, bw_initial, lat_initial);
 124 #endif
 125
 126   return nw_link;
 127 }
 128
 129 static void net_parse_link_init(void)
 130 {
 131   char *name_link;
 132   double bw_initial;
 133   tmgr_trace_t bw_trace;
 134   double lat_initial;
 135   tmgr_trace_t lat_trace;
 136   e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
 137   e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
 138   tmgr_trace_t state_trace;
 139
 140   name_link = xbt_strdup(A_surfxml_link_id);
 141   surf_parse_get_double(&bw_initial, A_surfxml_link_bandwidth);
 142   bw_trace = tmgr_trace_new(A_surfxml_link_bandwidth_file);
 143   surf_parse_get_double(&lat_initial, A_surfxml_link_latency);
 144   lat_trace = tmgr_trace_new(A_surfxml_link_latency_file);
 145
 146   xbt_assert0((A_surfxml_link_state == A_surfxml_link_state_ON)
 147               || (A_surfxml_link_state ==
 148                   A_surfxml_link_state_OFF), "Invalid state");
 149   if (A_surfxml_link_state == A_surfxml_link_state_ON)
 150     state_initial_link = SURF_RESOURCE_ON;
 151   else if (A_surfxml_link_state == A_surfxml_link_state_OFF)
 152     state_initial_link = SURF_RESOURCE_OFF;
 153
 154   if (A_surfxml_link_sharing_policy == A_surfxml_link_sharing_policy_SHARED)
 155     policy_initial_link = SURF_LINK_SHARED;
 156   else if (A_surfxml_link_sharing_policy ==
 157            A_surfxml_link_sharing_policy_FATPIPE)
 158     policy_initial_link = SURF_LINK_FATPIPE;
 159
 160   state_trace = tmgr_trace_new(A_surfxml_link_state_file);
 161
 162   net_link_new(name_link, bw_initial, bw_trace,
 163            lat_initial, lat_trace, state_initial_link, state_trace,
 164            policy_initial_link, xbt_dict_new());
 165
 166 }
 167
 168 static void net_add_traces(void)
 169 {
 170   xbt_dict_cursor_t cursor = NULL;
 171   char *trace_name, *elm;
 172
 173   static int called = 0;
 174   if (called)
 175     return;
 176   called = 1;
 177
 178   /* connect all traces relative to network */
 179   xbt_dict_foreach(trace_connect_list_link_avail, cursor, trace_name, elm) {
 180     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 181     link_CM02_t link =
 182       xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 183
 184     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 185                 trace_name, elm);
 186     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 187                 trace_name, elm);
 188
 189     link->lmm_resource.state_event =
 190       tmgr_history_add_trace(history, trace, 0.0, 0, link);
 191   }
 192
 193   xbt_dict_foreach(trace_connect_list_bandwidth, cursor, trace_name, elm) {
 194     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 195     link_CM02_t link =
 196       xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 197
 198     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 199                 trace_name, elm);
 200     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 201                 trace_name, elm);
 202
 203     link->lmm_resource.power.event =
 204       tmgr_history_add_trace(history, trace, 0.0, 0, link);
 205   }
 206
 207   xbt_dict_foreach(trace_connect_list_latency, cursor, trace_name, elm) {
 208     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
 209     link_CM02_t link =
 210       xbt_dict_get_or_null(surf_network_model->resource_set, elm);
 211
 212     xbt_assert2(link, "Cannot connect trace %s to link %s: link undefined",
 213                 trace_name, elm);
 214     xbt_assert2(trace, "Cannot connect trace %s to link %s: trace undefined",
 215                 trace_name, elm);
 216
 217     link->lat_event = tmgr_history_add_trace(history, trace, 0.0, 0, link);
 218   }
 219 }
 220
 221 static void net_define_callbacks(const char *file)
 222 {
 223   /* Figuring out the network links */
 224   surfxml_add_callback(STag_surfxml_link_cb_list, &net_parse_link_init);
 225   surfxml_add_callback(ETag_surfxml_platform_cb_list, &net_add_traces);
 226 }
 227
 228 static int net_resource_used(void *resource_id)
 229 {
 230   return lmm_constraint_used(network_maxmin_system,
 231                              ((surf_resource_lmm_t) resource_id)->constraint);
 232 }
 233
 234 static int net_action_unref(surf_action_t action)
 235 {
 236   action->refcount--;
 237   if (!action->refcount) {
 238     xbt_swag_remove(action, action->state_set);
 239     if (((surf_action_network_CM02_t) action)->variable)
 240       lmm_variable_free(network_maxmin_system,
 241                         ((surf_action_network_CM02_t) action)->variable);
 242     free(action);
 243     return 1;
 244   }
 245   return 0;
 246 }
 247
 248 static void net_action_cancel(surf_action_t action)
 249 {
 250   surf_network_model->action_state_set((surf_action_t) action,
 251                                        SURF_ACTION_FAILED);
 252   return;
 253 }
 254
 255 static void net_action_recycle(surf_action_t action)
 256 {
 257   return;
 258 }
 259
 260 static double net_action_get_remains(surf_action_t action)
 261 {
 262   return action->remains;
 263 }
 264
 265 static double net_share_resources(double now)
 266 {
 267   s_surf_action_network_CM02_t s_action;
 268   surf_action_network_CM02_t action = NULL;
 269   xbt_swag_t running_actions = surf_network_model->states.running_action_set;
 270   double min;
 271
 272   min = generic_maxmin_share_resources(running_actions,
 273                                        xbt_swag_offset(s_action,
 274                                                        variable),
 275                                        network_maxmin_system, network_solve);
 276
 277 #define VARIABLE(action) (*((lmm_variable_t*)(((char *) (action)) + xbt_swag_offset(s_action, variable)  )))
 278
 279   xbt_swag_foreach(action, running_actions) {
 280     if (action->latency > 0) {
 281       if (min < 0)
 282         min = action->latency;
 283       else if (action->latency < min)
 284         min = action->latency;
 285     }
 286   }
 287
 288   return min;
 289 }
 290
 291 static void net_update_actions_state(double now, double delta)
 292 {
 293   double deltap = 0.0;
 294   surf_action_network_CM02_t action = NULL;
 295   surf_action_network_CM02_t next_action = NULL;
 296   xbt_swag_t running_actions = surf_network_model->states.running_action_set;
 297   /*
 298      xbt_swag_t failed_actions =
 299      surf_network_model->states.failed_action_set;
 300    */
 301
 302   xbt_swag_foreach_safe(action, next_action, running_actions) {
 303
 304 #ifdef HAVE_TRACING
 305     xbt_dynar_t route = used_routing->get_route(action->src, action->dst);
 306     link_CM02_t link;
 307     unsigned int i;
 308     xbt_dynar_foreach(route, i, link) {
 309         TRACE_surf_link_set_utilization (link->lmm_resource.generic_resource.name,
 310           action->generic_action.data, lmm_variable_getvalue(action->variable), now-delta, delta);
 311     }
 312 #endif
 313
 314     deltap = delta;
 315     if (action->latency > 0) {
 316       if (action->latency > deltap) {
 317         double_update(&(action->latency), deltap);
 318         deltap = 0.0;
 319       } else {
 320         double_update(&(deltap), action->latency);
 321         action->latency = 0.0;
 322       }
 323       if ((action->latency == 0.0) && !(action->suspended))
 324         lmm_update_variable_weight(network_maxmin_system, action->variable,
 325                                    action->weight);
 326     }
 327     double_update(&(action->generic_action.remains),
 328                   lmm_variable_getvalue(action->variable) * deltap);
 329     if (action->generic_action.max_duration != NO_MAX_DURATION)
 330       double_update(&(action->generic_action.max_duration), delta);
 331
 332     if ((action->generic_action.remains <= 0) &&
 333         (lmm_get_variable_weight(action->variable) > 0)) {
 334       action->generic_action.finish = surf_get_clock();
 335       surf_network_model->action_state_set((surf_action_t) action,
 336                                            SURF_ACTION_DONE);
 337     } else if ((action->generic_action.max_duration != NO_MAX_DURATION)
 338                && (action->generic_action.max_duration <= 0)) {
 339       action->generic_action.finish = surf_get_clock();
 340       surf_network_model->action_state_set((surf_action_t) action,
 341                                            SURF_ACTION_DONE);
 342     }
 343   }
 344
 345   return;
 346 }
 347
 348 static void net_update_resource_state(void *id,
 349                                   tmgr_trace_event_t event_type,
 350                                   double value, double date)
 351 {
 352   link_CM02_t nw_link = id;
 353   /*   printf("[" "%lg" "] Asking to update network card \"%s\" with value " */
 354   /*     "%lg" " for event %p\n", surf_get_clock(), nw_link->name, */
 355   /*     value, event_type); */
 356
 357   if (event_type == nw_link->lmm_resource.power.event) {
 358     double delta =
 359       sg_weight_S_parameter / value - sg_weight_S_parameter /
 360       (nw_link->lmm_resource.power.peak * nw_link->lmm_resource.power.scale);
 361     lmm_variable_t var = NULL;
 362     lmm_element_t elem = NULL;
 363     surf_action_network_CM02_t action = NULL;
 364
 365     nw_link->lmm_resource.power.peak = value;
 366     lmm_update_constraint_bound(network_maxmin_system,
 367                                 nw_link->lmm_resource.constraint,
 368                                 sg_bandwidth_factor *
 369                                 (nw_link->lmm_resource.power.peak *
 370                                  nw_link->lmm_resource.power.scale));
 371 #ifdef HAVE_TRACING
 372     TRACE_surf_link_set_bandwidth (date, nw_link->lmm_resource.generic_resource.name, sg_bandwidth_factor * (nw_link->lmm_resource.power.peak * nw_link->lmm_resource.power.scale));
 373 #endif
 374     if (sg_weight_S_parameter > 0) {
 375       while ((var = lmm_get_var_from_cnst
 376               (network_maxmin_system, nw_link->lmm_resource.constraint,
 377                &elem))) {
 378         action = lmm_variable_id(var);
 379         action->weight += delta;
 380         if (!(action->suspended))
 381           lmm_update_variable_weight(network_maxmin_system, action->variable,
 382                                      action->weight);
 383       }
 384     }
 385     if (tmgr_trace_event_free(event_type))
 386       nw_link->lmm_resource.power.event = NULL;
 387   } else if (event_type == nw_link->lat_event) {
 388     double delta = value - nw_link->lat_current;
 389     lmm_variable_t var = NULL;
 390     lmm_element_t elem = NULL;
 391     surf_action_network_CM02_t action = NULL;
 392
 393     nw_link->lat_current = value;
 394     while ((var = lmm_get_var_from_cnst
 395             (network_maxmin_system, nw_link->lmm_resource.constraint,
 396              &elem))) {
 397       action = lmm_variable_id(var);
 398       action->lat_current += delta;
 399       action->weight += delta;
 400       if (action->rate < 0)
 401         lmm_update_variable_bound(network_maxmin_system, action->variable,
 402                                   sg_tcp_gamma / (2.0 * action->lat_current));
 403       else
 404         lmm_update_variable_bound(network_maxmin_system, action->variable,
 405                                   min(action->rate,
 406                                       sg_tcp_gamma / (2.0 *
 407                                                       action->lat_current)));
 408       if (!(action->suspended))
 409         lmm_update_variable_weight(network_maxmin_system, action->variable,
 410                                    action->weight);
 411
 412     }
 413     if (tmgr_trace_event_free(event_type))
 414       nw_link->lat_event = NULL;
 415   } else if (event_type == nw_link->lmm_resource.state_event) {
 416     if (value > 0)
 417       nw_link->lmm_resource.state_current = SURF_RESOURCE_ON;
 418     else {
 419       lmm_constraint_t cnst = nw_link->lmm_resource.constraint;
 420       lmm_variable_t var = NULL;
 421       lmm_element_t elem = NULL;
 422
 423       nw_link->lmm_resource.state_current = SURF_RESOURCE_OFF;
 424       while ((var = lmm_get_var_from_cnst
 425               (network_maxmin_system, cnst, &elem))) {
 426         surf_action_t action = lmm_variable_id(var);
 427
 428         if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
 429             surf_action_state_get(action) == SURF_ACTION_READY) {
 430           action->finish = date;
 431           surf_network_model->action_state_set(action, SURF_ACTION_FAILED);
 432         }
 433       }
 434     }
 435     if (tmgr_trace_event_free(event_type))
 436       nw_link->lmm_resource.state_event = NULL;
 437   } else {
 438     CRITICAL0("Unknown event ! \n");
 439     xbt_abort();
 440   }
 441
 442   return;
 443 }
 444
 445 static surf_action_t net_communicate(const char *src_name, const char *dst_name,
 446                                  int src, int dst, double size, double rate)
 447 {
 448   unsigned int i;
 449   link_CM02_t link;
 450   int failed = 0;
 451   surf_action_network_CM02_t action = NULL;
 452   double bandwidth_bound;
 453   /* LARGE PLATFORMS HACK:
 454      Add a link_CM02_t *link and a int link_nb to network_card_CM02_t. It will represent local links for this node
 455      Use the cluster_id for ->id */
 456   xbt_dynar_t route = used_routing->get_route(src, dst);
 457   /* LARGE PLATFORMS HACK:
 458      total_route_size = route_size + src->link_nb + dst->nb */
 459
 460   XBT_IN4("(%s,%s,%g,%g)", src_name, dst_name, size, rate);
 461   /* LARGE PLATFORMS HACK:
 462      assert on total_route_size */
 463   xbt_assert2(xbt_dynar_length(route),
 464               "You're trying to send data from %s to %s but there is no connection between these two hosts.",
 465               src_name, dst_name);
 466
 467   xbt_dynar_foreach(route, i, link) {
 468     if (link->lmm_resource.state_current == SURF_RESOURCE_OFF) {
 469       failed = 1;
 470       break;
 471     }
 472   }
 473   action =
 474     surf_action_new(sizeof(s_surf_action_network_CM02_t), size,
 475                     surf_network_model, failed);
 476
 477   xbt_swag_insert(action, action->generic_action.state_set);
 478   action->rate = rate;
 479
 480   action->latency = 0.0;
 481   action->weight = 0.0;
 482   bandwidth_bound = -1.0;
 483   xbt_dynar_foreach(route, i, link) {
 484     action->latency += link->lat_current;
 485     action->weight +=
 486       link->lat_current +
 487       sg_weight_S_parameter /
 488       (link->lmm_resource.power.peak * link->lmm_resource.power.scale);
 489     if(bandwidth_bound < 0.0)
 490       bandwidth_bound = (*bandwidth_factor_callback)(size) * (link->lmm_resource.power.peak * link->lmm_resource.power.scale);
 491     else
 492       bandwidth_bound = min(bandwidth_bound, (*bandwidth_factor_callback)(size) * (link->lmm_resource.power.peak * link->lmm_resource.power.scale));
 493   }
 494   /* LARGE PLATFORMS HACK:
 495      Add src->link and dst->link latencies */
 496   action->lat_current = action->latency;
 497   action->latency *= (*latency_factor_callback)(size);
 498   action->rate = (*bandwidth_constraint_callback)(action->rate, bandwidth_bound, size);
 499
 500   /* LARGE PLATFORMS HACK:
 501      lmm_variable_new(..., total_route_size) */
 502   if (action->latency > 0)
 503     action->variable =
 504       lmm_variable_new(network_maxmin_system, action, 0.0, -1.0,
 505                        xbt_dynar_length(route));
 506   else
 507     action->variable =
 508       lmm_variable_new(network_maxmin_system, action, 1.0, -1.0,
 509                        xbt_dynar_length(route));
 510
 511   if (action->rate < 0) {
 512     if (action->lat_current > 0)
 513       lmm_update_variable_bound(network_maxmin_system, action->variable,
 514                                 sg_tcp_gamma / (2.0 * action->lat_current));
 515     else
 516       lmm_update_variable_bound(network_maxmin_system, action->variable,
 517                                 -1.0);
 518   } else {
 519     if (action->lat_current > 0)
 520       lmm_update_variable_bound(network_maxmin_system, action->variable,
 521                                 min(action->rate,
 522                                     sg_tcp_gamma / (2.0 *
 523                                                     action->lat_current)));
 524     else
 525       lmm_update_variable_bound(network_maxmin_system, action->variable,
 526                                 action->rate);
 527   }
 528
 529   xbt_dynar_foreach(route, i, link) {
 530     lmm_expand(network_maxmin_system, link->lmm_resource.constraint,
 531                action->variable, 1.0);
 532   }
 533   /* LARGE PLATFORMS HACK:
 534      expand also with src->link and dst->link */
 535
 536   /* saving the src and dst of this communication */
 537   action->src = src;
 538   action->dst = dst;
 539
 540   XBT_OUT;
 541
 542   return (surf_action_t) action;
 543 }
 544
 545 static double net_get_link_bandwidth(const void *link)
 546 {
 547   surf_resource_lmm_t lmm = (surf_resource_lmm_t) link;
 548   return lmm->power.peak * lmm->power.scale;
 549 }
 550
 551 static double net_get_link_latency(const void *link)
 552 {
 553   return ((link_CM02_t) link)->lat_current;
 554 }
 555
 556 static int net_link_shared(const void *link)
 557 {
 558   return lmm_constraint_is_shared(((surf_resource_lmm_t) link)->constraint);
 559 }
 560
 561 static void net_action_suspend(surf_action_t action)
 562 {
 563   ((surf_action_network_CM02_t) action)->suspended = 1;
 564   lmm_update_variable_weight(network_maxmin_system,
 565                              ((surf_action_network_CM02_t) action)->variable,
 566                              0.0);
 567 }
 568
 569 static void net_action_resume(surf_action_t action)
 570 {
 571   if (((surf_action_network_CM02_t) action)->suspended) {
 572     lmm_update_variable_weight(network_maxmin_system,
 573                                ((surf_action_network_CM02_t)
 574                                 action)->variable,
 575                                ((surf_action_network_CM02_t) action)->weight);
 576     ((surf_action_network_CM02_t) action)->suspended = 0;
 577   }
 578 }
 579
 580 static int net_action_is_suspended(surf_action_t action)
 581 {
 582   return ((surf_action_network_CM02_t) action)->suspended;
 583 }
 584
 585 static void net_action_set_max_duration(surf_action_t action, double duration)
 586 {
 587   action->max_duration = duration;
 588 }
 589
 590
 591 /**
 592  * FIXME : this should be done in the binding code !!
 593  */
 594 void network_create_resource(char *name,
 595         double initial_bandwidth,double initial_latency)
 596 {
 597
 598         char *name_link;
 599         double bw_initial;
 600         tmgr_trace_t bw_trace;
 601         double lat_initial;
 602         tmgr_trace_t lat_trace;
 603         e_surf_resource_state_t state_initial_link = SURF_RESOURCE_ON;
 604         e_surf_link_sharing_policy_t policy_initial_link = SURF_LINK_SHARED;
 605         tmgr_trace_t state_trace;
 606
 607
 608         name_link = (char*)name;
 609         bw_initial = initial_bandwidth;
 610         bw_trace = tmgr_trace_new("");
 611         lat_initial = initial_latency;
 612         lat_trace = tmgr_trace_new("");
 613         // FIXME Hard Coded Values
 614         state_initial_link = SURF_RESOURCE_ON;
 615         policy_initial_link = SURF_LINK_SHARED;
 616         state_trace = tmgr_trace_new("");
 617
 618         net_link_new(name_link, bw_initial, bw_trace,
 619                    lat_initial, lat_trace, state_initial_link, state_trace,
 620                    policy_initial_link, xbt_dict_new());
 621 }
 622
 623 static void net_finalize(void)
 624 {
 625   surf_model_exit(surf_network_model);
 626   surf_network_model = NULL;
 627
 628   used_routing->finalize();
 629   lmm_system_free(network_maxmin_system);
 630   network_maxmin_system = NULL;
 631 }
 632
 633 static void surf_network_model_init_internal(void)
 634 {
 635   surf_network_model = surf_model_init();
 636
 637   surf_network_model->name = "network";
 638   surf_network_model->action_unref = net_action_unref;
 639   surf_network_model->action_cancel = net_action_cancel;
 640   surf_network_model->action_recycle = net_action_recycle;
 641   surf_network_model->get_remains = net_action_get_remains;
 642
 643   surf_network_model->model_private->resource_used = net_resource_used;
 644   surf_network_model->model_private->share_resources = net_share_resources;
 645   surf_network_model->model_private->update_actions_state =
 646     net_update_actions_state;
 647   surf_network_model->model_private->update_resource_state =
 648     net_update_resource_state;
 649   surf_network_model->model_private->finalize = net_finalize;
 650
 651   surf_network_model->suspend = net_action_suspend;
 652   surf_network_model->resume = net_action_resume;
 653   surf_network_model->is_suspended = net_action_is_suspended;
 654   surf_cpu_model->set_max_duration = net_action_set_max_duration;
 655
 656   surf_network_model->extension.network.communicate = net_communicate;
 657   surf_network_model->extension.network.get_link_bandwidth =
 658     net_get_link_bandwidth;
 659   surf_network_model->extension.network.get_link_latency = net_get_link_latency;
 660   surf_network_model->extension.network.link_shared = net_link_shared;
 661   surf_network_model->extension.network.create_resource = network_create_resource;
 662   surf_network_model->extension.network.add_traces = net_add_traces;
 663
 664   if (!network_maxmin_system)
 665     network_maxmin_system = lmm_system_new();
 666
 667   routing_model_create(sizeof(link_CM02_t),
 668                        net_link_new(xbt_strdup("__loopback__"),
 669                                 498000000, NULL, 0.000015, NULL,
 670                                 SURF_RESOURCE_ON, NULL, SURF_LINK_FATPIPE,
 671                                 NULL));
 672 }
 673
 674
 675
 676 /************************************************************************/
 677 /* New model based on LV08 and experimental results of MPI ping-pongs   */
 678 /************************************************************************/
 679 void surf_network_model_init_SMPI(const char *filename)
 680 {
 681
 682   if (surf_network_model)
 683     return;
 684   surf_network_model_init_internal();
 685   latency_factor_callback = &smpi_latency_factor;
 686   bandwidth_factor_callback = &smpi_bandwidth_factor;
 687   bandwidth_constraint_callback = &smpi_bandwidth_constraint;
 688   net_define_callbacks(filename);
 689   xbt_dynar_push(model_list, &surf_network_model);
 690   network_solve = lmm_solve;
 691
 692   xbt_cfg_setdefault_double(_surf_cfg_set,"network/weight_S", 8775);
 693
 694   update_model_description(surf_network_model_description,
 695                            "SMPI", surf_network_model);
 696 }
 697
 698 /************************************************************************/
 699 /* New model based on optimizations discussed during this thesis        */
 700 /************************************************************************/
 701 void surf_network_model_init_LegrandVelho(const char *filename)
 702 {
 703
 704   if (surf_network_model)
 705     return;
 706   surf_network_model_init_internal();
 707   net_define_callbacks(filename);
 708   xbt_dynar_push(model_list, &surf_network_model);
 709   network_solve = lmm_solve;
 710
 711   xbt_cfg_setdefault_double(_surf_cfg_set,"network/latency_factor",10.4);
 712   xbt_cfg_setdefault_double(_surf_cfg_set,"network/bandwidth_factor", 0.92);
 713   xbt_cfg_setdefault_double(_surf_cfg_set,"network/weight_S", 8775);
 714
 715   update_model_description(surf_network_model_description,
 716                            "LV08", surf_network_model);
 717 }
 718
 719 /***************************************************************************/
 720 /* The nice TCP sharing model designed by Loris Marchal and Henri Casanova */
 721 /***************************************************************************/
 722 /* @TechReport{      rr-lip2002-40, */
 723 /*   author        = {Henri Casanova and Loris Marchal}, */
 724 /*   institution   = {LIP}, */
 725 /*   title         = {A Network Model for Simulation of Grid Application}, */
 726 /*   number        = {2002-40}, */
 727 /*   month         = {oct}, */
 728 /*   year          = {2002} */
 729 /* } */
 730 void surf_network_model_init_CM02(const char *filename)
 731 {
 732
 733   if (surf_network_model)
 734     return;
 735   surf_network_model_init_internal();
 736   net_define_callbacks(filename);
 737   xbt_dynar_push(model_list, &surf_network_model);
 738   network_solve = lmm_solve;
 739
 740   update_model_description(surf_network_model_description,
 741                            "CM02", surf_network_model);
 742 }
 743
 744 void surf_network_model_init_Reno(const char *filename)
 745 {
 746   if (surf_network_model)
 747     return;
 748   surf_network_model_init_internal();
 749   net_define_callbacks(filename);
 750
 751   xbt_dynar_push(model_list, &surf_network_model);
 752   lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi);
 753   network_solve = lagrange_solve;
 754
 755   xbt_cfg_setdefault_double(_surf_cfg_set,"network/latency_factor", 10.4);
 756   xbt_cfg_setdefault_double(_surf_cfg_set,"network/bandwidth_factor", 0.92);
 757   xbt_cfg_setdefault_double(_surf_cfg_set,"network/weight_S", 8775);
 758
 759   update_model_description(surf_network_model_description,
 760                            "Reno", surf_network_model);
 761 }
 762
 763
 764 void surf_network_model_init_Reno2(const char *filename)
 765 {
 766   if (surf_network_model)
 767     return;
 768   surf_network_model_init_internal();
 769   net_define_callbacks(filename);
 770
 771   xbt_dynar_push(model_list, &surf_network_model);
 772   lmm_set_default_protocol_function(func_reno2_f, func_reno2_fp,
 773                                     func_reno2_fpi);
 774   network_solve = lagrange_solve;
 775
 776   xbt_cfg_setdefault_double(_surf_cfg_set,"network/latency_factor", 10.4);
 777   xbt_cfg_setdefault_double(_surf_cfg_set,"network/bandwidth_factor", 0.92);
 778   xbt_cfg_setdefault_double(_surf_cfg_set,"network/weight_S_parameter", 8775);
 779
 780   update_model_description(surf_network_model_description,
 781                            "Reno2", surf_network_model);
 782 }
 783
 784 void surf_network_model_init_Vegas(const char *filename)
 785 {
 786   if (surf_network_model)
 787     return;
 788   surf_network_model_init_internal();
 789   net_define_callbacks(filename);
 790
 791   xbt_dynar_push(model_list, &surf_network_model);
 792   lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp,
 793                                     func_vegas_fpi);
 794   network_solve = lagrange_solve;
 795
 796   xbt_cfg_setdefault_double(_surf_cfg_set,"network/latency_factor", 10.4);
 797   xbt_cfg_setdefault_double(_surf_cfg_set,"network/bandwidth_factor", 0.92);
 798   xbt_cfg_setdefault_double(_surf_cfg_set,"network/weight_S", 8775);
 799
 800   update_model_description(surf_network_model_description,
 801                            "Vegas", surf_network_model);
 802 }
 803
 804