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