src/surf/network_constant.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 "surf_private.h"
   9 #include "network_common.h"
  10 #include "xbt/dict.h"
  11 #include "xbt/str.h"
  12 #include "xbt/log.h"
  13
  14 #define CONSTANT_VALUE 1.0
  15 typedef struct network_card_Constant {
  16   char *name;
  17   int id;
  18 } s_network_card_Constant_t, *network_card_Constant_t;
  19
  20 typedef struct surf_action_network_Constant {
  21   s_surf_action_t generic_action;
  22   double latency;
  23   double lat_current;
  24   lmm_variable_t variable;
  25   double rate;
  26   int suspended;
  27   network_card_Constant_t src;
  28   network_card_Constant_t dst;
  29 } s_surf_action_network_Constant_t, *surf_action_network_Constant_t;
  30
  31 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
  32
  33 static lmm_system_t network_maxmin_system = NULL;
  34 static void (*network_solve) (lmm_system_t) = NULL;
  35
  36 static int card_number = 0;
  37 static int host_number = 0;
  38
  39 static void network_card_free(void *nw_card)
  40 {
  41   free(((network_card_Constant_t) nw_card)->name);
  42   free(nw_card);
  43 }
  44
  45 static int network_card_new(const char *card_name)
  46 {
  47   network_card_Constant_t card =
  48       xbt_dict_get_or_null(network_card_set, card_name);
  49
  50   if (!card) {
  51     card = xbt_new0(s_network_card_Constant_t, 1);
  52     card->name = xbt_strdup(card_name);
  53     card->id = card_number++;
  54     xbt_dict_set(network_card_set, card_name, card, network_card_free);
  55   }
  56   return card->id;
  57 }
  58
  59 static int src_id = -1;
  60 static int dst_id = -1;
  61
  62 static void parse_route_set_endpoints(void)
  63 {
  64   src_id = network_card_new(A_surfxml_route_src);
  65   dst_id = network_card_new(A_surfxml_route_dst);
  66   route_action = A_surfxml_route_action;
  67   route_link_list = xbt_dynar_new(sizeof(char *), &free_string);
  68 }
  69
  70 static void parse_route_set_route(void)
  71 {
  72   char *name;
  73   if (src_id != -1 && dst_id != -1) {
  74     name = bprintf("%x#%x",src_id, dst_id);
  75     manage_route(route_table, name, route_action, 0);
  76     free(name);
  77   }
  78 }
  79
  80 static void count_hosts(void)
  81 {
  82    host_number++;
  83 }
  84
  85 static void define_callbacks(const char *file)
  86 {
  87   /* Figuring out the network links */
  88   surfxml_add_callback(STag_surfxml_host_cb_list, &count_hosts);
  89   surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties);
  90   surfxml_add_callback(STag_surfxml_route_cb_list, &parse_route_set_endpoints);
  91   surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_route_elem);
  92   surfxml_add_callback(ETag_surfxml_route_cb_list, &parse_route_set_route);
  93   surfxml_add_callback(STag_surfxml_platform_cb_list, &init_data);
  94   surfxml_add_callback(STag_surfxml_set_cb_list, &parse_sets);
  95   surfxml_add_callback(STag_surfxml_route_c_multi_cb_list, &parse_route_multi_set_endpoints);
  96   surfxml_add_callback(ETag_surfxml_route_c_multi_cb_list, &parse_route_multi_set_route);
  97   surfxml_add_callback(STag_surfxml_foreach_cb_list, &parse_foreach);
  98   surfxml_add_callback(STag_surfxml_cluster_cb_list, &parse_cluster);
  99   surfxml_add_callback(STag_surfxml_trace_cb_list, &parse_trace_init);
 100   surfxml_add_callback(ETag_surfxml_trace_cb_list, &parse_trace_finalize);
 101   surfxml_add_callback(STag_surfxml_trace_c_connect_cb_list, &parse_trace_c_connect);
 102 }
 103
 104 static void *name_service(const char *name)
 105 {
 106   network_card_Constant_t card = xbt_dict_get_or_null(network_card_set, name);
 107   return card;
 108 }
 109
 110 static const char *get_resource_name(void *resource_id)
 111 {
 112   return ((network_card_Constant_t) resource_id)->name;
 113 }
 114
 115 static int resource_used(void *resource_id)
 116 {
 117   return 0;
 118 }
 119
 120 static int action_free(surf_action_t action)
 121 {
 122   action->using--;
 123   if (!action->using) {
 124     xbt_swag_remove(action, action->state_set);
 125     if (((surf_action_network_Constant_t) action)->variable)
 126       lmm_variable_free(network_maxmin_system,
 127                         ((surf_action_network_Constant_t) action)->variable);
 128     free(action);
 129     return 1;
 130   }
 131   return 0;
 132 }
 133
 134 static void action_use(surf_action_t action)
 135 {
 136   action->using++;
 137 }
 138
 139 static void action_cancel(surf_action_t action)
 140 {
 141   return;
 142 }
 143
 144 static void action_recycle(surf_action_t action)
 145 {
 146   return;
 147 }
 148
 149 static void action_change_state(surf_action_t action,
 150                                 e_surf_action_state_t state)
 151 {
 152 /*   if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */
 153 /*     if(((surf_action_network_Constant_t)action)->variable) { */
 154 /*       lmm_variable_disable(network_maxmin_system, ((surf_action_network_Constant_t)action)->variable); */
 155 /*       ((surf_action_network_Constant_t)action)->variable = NULL; */
 156 /*     } */
 157
 158   surf_action_change_state(action, state);
 159   return;
 160 }
 161
 162 static double share_resources(double now)
 163 {
 164   surf_action_network_Constant_t action = NULL;
 165   xbt_swag_t running_actions =
 166       surf_network_model->common_public->states.running_action_set;
 167   double min = -1.0;
 168
 169   xbt_swag_foreach(action, running_actions) {
 170     if (action->latency > 0) {
 171       if (min < 0)
 172         min = action->latency;
 173       else if (action->latency < min)
 174         min = action->latency;
 175     }
 176   }
 177
 178   return min;
 179 }
 180
 181 static void update_actions_state(double now, double delta)
 182 {
 183   surf_action_network_Constant_t action = NULL;
 184   surf_action_network_Constant_t next_action = NULL;
 185   xbt_swag_t running_actions =
 186       surf_network_model->common_public->states.running_action_set;
 187
 188   xbt_swag_foreach_safe(action, next_action, running_actions) {
 189     if (action->latency > 0) {
 190       if (action->latency > delta) {
 191         double_update(&(action->latency), delta);
 192       } else {
 193         action->latency = 0.0;
 194       }
 195     }
 196     double_update(&(action->generic_action.remains),
 197                   action->generic_action.cost * delta/ CONSTANT_VALUE);
 198     if (action->generic_action.max_duration != NO_MAX_DURATION)
 199       double_update(&(action->generic_action.max_duration), delta);
 200
 201     if (action->generic_action.remains <= 0) {
 202       action->generic_action.finish = surf_get_clock();
 203       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 204     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
 205                (action->generic_action.max_duration <= 0)) {
 206       action->generic_action.finish = surf_get_clock();
 207       action_change_state((surf_action_t) action, SURF_ACTION_DONE);
 208     }
 209   }
 210
 211   return;
 212 }
 213
 214 static void update_resource_state(void *id,
 215                                   tmgr_trace_event_t event_type,
 216                                   double value)
 217 {
 218   DIE_IMPOSSIBLE;
 219 }
 220
 221 static surf_action_t communicate(void *src, void *dst, double size,
 222                                  double rate)
 223 {
 224   surf_action_network_Constant_t action = NULL;
 225   network_card_Constant_t card_src = src;
 226   network_card_Constant_t card_dst = dst;
 227
 228   XBT_IN4("(%s,%s,%g,%g)", card_src->name, card_dst->name, size, rate);
 229
 230   action = xbt_new0(s_surf_action_network_Constant_t, 1);
 231
 232   action->generic_action.using = 1;
 233   action->generic_action.cost = size;
 234   action->generic_action.remains = size;
 235   action->generic_action.max_duration = NO_MAX_DURATION;
 236   action->generic_action.start = surf_get_clock();
 237   action->generic_action.finish = -1.0;
 238   action->generic_action.model_type =
 239       (surf_model_t) surf_network_model;
 240   action->suspended = 0;
 241   action->generic_action.state_set =
 242       surf_network_model->common_public->states.running_action_set;
 243
 244   xbt_swag_insert(action, action->generic_action.state_set);
 245   action->rate = rate;
 246
 247   action->latency = CONSTANT_VALUE;
 248   action->lat_current = action->latency;
 249
 250   XBT_OUT;
 251
 252   return (surf_action_t) action;
 253 }
 254
 255 /* returns an array of link_Constant_t */
 256 static const void **get_route(void *src, void *dst)
 257 {
 258   xbt_assert0(0, "Calling this function does not make any sense");
 259   return (const void **) NULL;
 260 }
 261
 262 static int get_route_size(void *src, void *dst)
 263 {
 264   xbt_assert0(0, "Calling this function does not make any sense");
 265   return 0;
 266 }
 267
 268 static const char *get_link_name(const void *link)
 269 {
 270   DIE_IMPOSSIBLE;
 271 }
 272
 273 static double get_link_bandwidth(const void *link)
 274 {
 275   DIE_IMPOSSIBLE;
 276 }
 277
 278 static double get_link_latency(const void *link)
 279 {
 280   DIE_IMPOSSIBLE;
 281 }
 282
 283 static xbt_dict_t get_properties(void *link)
 284 {
 285   DIE_IMPOSSIBLE;
 286 }
 287
 288 static void action_suspend(surf_action_t action)
 289 {
 290   ((surf_action_network_Constant_t) action)->suspended = 1;
 291   lmm_update_variable_weight(network_maxmin_system,
 292                              ((surf_action_network_Constant_t) action)->
 293                              variable, 0.0);
 294 }
 295
 296 static void action_resume(surf_action_t action)
 297 {
 298   if (((surf_action_network_Constant_t) action)->suspended) {
 299     lmm_update_variable_weight(network_maxmin_system,
 300                                ((surf_action_network_Constant_t) action)->
 301                                variable,
 302                                ((surf_action_network_Constant_t) action)->
 303                                lat_current);
 304     ((surf_action_network_Constant_t) action)->suspended = 0;
 305   }
 306 }
 307
 308 static int action_is_suspended(surf_action_t action)
 309 {
 310   return ((surf_action_network_Constant_t) action)->suspended;
 311 }
 312
 313 static void action_set_max_duration(surf_action_t action, double duration)
 314 {
 315   action->max_duration = duration;
 316 }
 317
 318 static void finalize(void)
 319 {
 320   xbt_dict_free(&network_card_set);
 321   xbt_dict_free(&link_set);
 322   xbt_swag_free(surf_network_model->common_public->states.
 323                 ready_action_set);
 324   xbt_swag_free(surf_network_model->common_public->states.
 325                 running_action_set);
 326   xbt_swag_free(surf_network_model->common_public->states.
 327                 failed_action_set);
 328   xbt_swag_free(surf_network_model->common_public->states.
 329                 done_action_set);
 330   free(surf_network_model->common_public);
 331   free(surf_network_model->common_private);
 332   free(surf_network_model->extension_public);
 333
 334   free(surf_network_model);
 335   surf_network_model = NULL;
 336
 337   card_number = 0;
 338 }
 339
 340 static void surf_network_model_init_internal(void)
 341 {
 342   s_surf_action_t action;
 343
 344   surf_network_model = xbt_new0(s_surf_network_model_t, 1);
 345
 346   surf_network_model->common_private =
 347       xbt_new0(s_surf_model_private_t, 1);
 348   surf_network_model->common_public =
 349       xbt_new0(s_surf_model_public_t, 1);
 350   surf_network_model->extension_public =
 351       xbt_new0(s_surf_network_model_extension_public_t, 1);
 352
 353   surf_network_model->common_public->states.ready_action_set =
 354       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 355   surf_network_model->common_public->states.running_action_set =
 356       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 357   surf_network_model->common_public->states.failed_action_set =
 358       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 359   surf_network_model->common_public->states.done_action_set =
 360       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 361
 362   surf_network_model->common_public->name_service = name_service;
 363   surf_network_model->common_public->get_resource_name =
 364       get_resource_name;
 365   surf_network_model->common_public->action_get_state =
 366       surf_action_get_state;
 367   surf_network_model->common_public->action_get_start_time =
 368       surf_action_get_start_time;
 369   surf_network_model->common_public->action_get_finish_time =
 370       surf_action_get_finish_time;
 371   surf_network_model->common_public->action_free = action_free;
 372   surf_network_model->common_public->action_use = action_use;
 373   surf_network_model->common_public->action_cancel = action_cancel;
 374   surf_network_model->common_public->action_recycle = action_recycle;
 375   surf_network_model->common_public->action_change_state =
 376       action_change_state;
 377   surf_network_model->common_public->action_set_data =
 378       surf_action_set_data;
 379   surf_network_model->common_public->name = "network";
 380
 381   surf_network_model->common_private->resource_used = resource_used;
 382   surf_network_model->common_private->share_resources = share_resources;
 383   surf_network_model->common_private->update_actions_state =
 384       update_actions_state;
 385   surf_network_model->common_private->update_resource_state =
 386       update_resource_state;
 387   surf_network_model->common_private->finalize = finalize;
 388
 389   surf_network_model->common_public->suspend = action_suspend;
 390   surf_network_model->common_public->resume = action_resume;
 391   surf_network_model->common_public->is_suspended = action_is_suspended;
 392   surf_cpu_model->common_public->set_max_duration =
 393       action_set_max_duration;
 394
 395   surf_network_model->extension_public->communicate = communicate;
 396   surf_network_model->extension_public->get_route = get_route;
 397   surf_network_model->extension_public->get_route_size = get_route_size;
 398   surf_network_model->extension_public->get_link_name = get_link_name;
 399   surf_network_model->extension_public->get_link_bandwidth =
 400       get_link_bandwidth;
 401   surf_network_model->extension_public->get_link_latency =
 402       get_link_latency;
 403
 404   surf_network_model->common_public->get_properties =  get_properties;
 405
 406   link_set = xbt_dict_new();
 407   network_card_set = xbt_dict_new();
 408
 409   if (!network_maxmin_system)
 410     network_maxmin_system = lmm_system_new();
 411 }
 412
 413 void surf_network_model_init_Constant(const char *filename)
 414 {
 415
 416   if (surf_network_model)
 417     return;
 418   surf_network_model_init_internal();
 419   define_callbacks(filename);
 420   xbt_dynar_push(model_list, &surf_network_model);
 421   network_solve = lmm_solve;
 422
 423   update_model_description(surf_network_model_description,
 424                               surf_network_model_description_size,
 425                               "Constant",
 426                               (surf_model_t) surf_network_model);
 427 }