src/surf/surf_config.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2009 The SimGrid team. 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 /* surf_config: configuration infrastructure for the simulation world       */
   9
  10 #include "xbt/config.h"
  11 #include "xbt/str.h"
  12 #include "surf/surf_private.h"
  13
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_config,surf,"About the configuration of surf (and the rest of the simulation)");
  15
  16 xbt_cfg_t _surf_cfg_set = NULL;
  17
  18
  19 /* Parse the command line, looking for options */
  20 static void surf_config_cmd_line(int *argc,char **argv)
  21 {
  22         int i, j;
  23         char *opt;
  24
  25         for (i = 1; i < *argc; i++) {
  26                 int remove_it = 0;
  27                 if (!strncmp(argv[i], "--cfg=", strlen("--cfg="))) {
  28                         opt = strchr(argv[i], '=');
  29                         opt++;
  30
  31                         xbt_cfg_set_parse(_surf_cfg_set,opt);
  32                         DEBUG1("Did apply '%s' as config setting", opt);
  33                         remove_it = 1;
  34                 } else if (!strncmp(argv[i], "--cfg-help", strlen("--cfg-help")+1) ||
  35                                 !strncmp(argv[i], "--help", strlen("--help")+1)) {
  36                         printf("Description of the configuration accepted by this simulator:\n");
  37                         xbt_cfg_help(_surf_cfg_set);
  38                         remove_it=1;
  39                         exit(0);
  40                 }
  41                 if (remove_it) { /*remove this from argv */
  42                         for (j = i + 1; j < *argc; j++) {
  43                                 argv[j - 1] = argv[j];
  44                         }
  45
  46                         argv[j - 1] = NULL;
  47                         (*argc)--;
  48                         i--;                      /* compensate effect of next loop incrementation */
  49                 }
  50         }
  51 }
  52
  53
  54 int _surf_init_status = 0;     /* 0: beginning of time;
  55                                   1: pre-inited (cfg_set created);
  56                                   2: inited (running) */
  57
  58 /* callback of the workstation_model variable */
  59 static void _surf_cfg_cb__workstation_model(const char *name, int pos)
  60 {
  61         char *val;
  62
  63         xbt_assert0(_surf_init_status < 2,
  64                         "Cannot change the model after the initialization");
  65
  66         val = xbt_cfg_get_string(_surf_cfg_set, name);
  67         /* New Module missing */
  68
  69         find_model_description(surf_workstation_model_description, val);
  70 }
  71
  72 /* callback of the cpu_model variable */
  73 static void _surf_cfg_cb__cpu_model(const char *name, int pos)
  74 {
  75         char *val;
  76
  77         xbt_assert0(_surf_init_status < 2,
  78                         "Cannot change the model after the initialization");
  79
  80         val = xbt_cfg_get_string(_surf_cfg_set, name);
  81         /* New Module missing */
  82         find_model_description(surf_cpu_model_description, val);
  83 }
  84
  85 /* callback of the workstation_model variable */
  86 static void _surf_cfg_cb__network_model(const char *name, int pos)
  87 {
  88         char *val;
  89
  90         xbt_assert0(_surf_init_status < 2,
  91                         "Cannot change the model after the initialization");
  92
  93         val = xbt_cfg_get_string(_surf_cfg_set, name);
  94         /* New Module missing */
  95         find_model_description(surf_network_model_description, val);
  96 }
  97
  98 /* callback of the tcp gamma variable */
  99 static void _surf_cfg_cb__tcp_gamma(const char *name, int pos) {
 100         sg_tcp_gamma =  xbt_cfg_get_double(_surf_cfg_set, name);
 101 }
 102
 103 static void _surf_cfg_cb__surf_path(const char *name, int pos) {
 104         char *path = xbt_cfg_get_string_at(_surf_cfg_set, name,pos);
 105     xbt_dynar_push(surf_path, &path);
 106 }
 107
 108
 109
 110 /* create the config set, register what should be and parse the command line*/
 111 void surf_config_init(int *argc, char **argv) {
 112
 113         /* Create the configuration support */
 114         if (_surf_init_status==0) { /* Only create stuff if not already inited */
 115                 _surf_init_status = 1;
 116
 117                 char *description = xbt_malloc(1024), *p = description;
 118                 char *default_value;
 119                 int i;
 120                 sprintf(description,"The model to use for the workstation. Possible values: ");
 121                 while (*(++p) != '\0');
 122                 for (i=0;surf_workstation_model_description[i].name;i++)
 123                         p+=sprintf(p,"%s%s",(i==0?"":", "),surf_workstation_model_description[i].name);
 124                 default_value = xbt_strdup("CLM03");
 125                 xbt_cfg_register(&_surf_cfg_set,
 126                                 "workstation_model", description,  xbt_cfgelm_string, &default_value, 1, 1,
 127                                 &_surf_cfg_cb__workstation_model, NULL);
 128
 129                 sprintf(description,"The model to use for the CPU. Possible values: ");
 130                 p = description;
 131                 while (*(++p) != '\0');
 132                 for (i=0;surf_cpu_model_description[i].name;i++)
 133                         p+=sprintf(p,"%s%s",(i==0?"":", "),surf_cpu_model_description[i].name);
 134                 default_value = xbt_strdup("Cas01");
 135                 xbt_cfg_register(&_surf_cfg_set,
 136                                 "cpu_model", description, xbt_cfgelm_string, &default_value, 1, 1,
 137                                 &_surf_cfg_cb__cpu_model, NULL);
 138
 139                 sprintf(description,"The model to use for the network. Possible values: ");
 140                 p = description;
 141                 while (*(++p) != '\0');
 142                 for (i=0;surf_network_model_description[i].name;i++)
 143                         p+=sprintf(p,"%s%s",(i==0?"":", "),surf_network_model_description[i].name);
 144                 default_value = xbt_strdup("CM02");
 145                 xbt_cfg_register(&_surf_cfg_set,
 146                                 "network_model", description, xbt_cfgelm_string, &default_value, 1, 1,
 147                                 &_surf_cfg_cb__network_model, NULL);
 148                 xbt_free(description);
 149
 150                 xbt_cfg_register(&_surf_cfg_set,"TCP_gamma","Size of the biggest TCP window",
 151                                         xbt_cfgelm_double,NULL,1,1,_surf_cfg_cb__tcp_gamma,NULL);
 152                 xbt_cfg_set_double(_surf_cfg_set,"TCP_gamma",20000.0);
 153
 154                 xbt_cfg_register(&_surf_cfg_set,"path","Lookup path for inclusions in platform and deployment XML files",
 155                                         xbt_cfgelm_string, NULL,0,0,_surf_cfg_cb__surf_path,NULL);
 156                 if (!surf_path) {
 157                         /* retrieves the current directory of the        current process */
 158                         const char *initial_path = __surf_get_initial_path();
 159                         xbt_assert0((initial_path),
 160                                         "__surf_get_initial_path() failed! Can't resolves current Windows directory");
 161
 162                         surf_path = xbt_dynar_new(sizeof(char *), NULL);
 163                         xbt_cfg_set_string(_surf_cfg_set,"path", initial_path);
 164                 }
 165
 166                 surf_config_cmd_line(argc,argv);
 167         }
 168 }
 169 void surf_config_finalize(void)
 170 {
 171         if (!_surf_init_status)
 172                 return;                     /* Not initialized yet. Nothing to do */
 173
 174         xbt_cfg_free(&_surf_cfg_set);
 175         _surf_init_status = 0;
 176 }
 177
 178 void surf_config_models_setup(const char *platform_file){
 179         char *workstation_model_name;
 180         int workstation_id = -1;
 181
 182         workstation_model_name =
 183                 xbt_cfg_get_string(_surf_cfg_set, "workstation_model");
 184
 185         DEBUG1("Model : %s", workstation_model_name);
 186         workstation_id =
 187                 find_model_description(surf_workstation_model_description,
 188                                 workstation_model_name);
 189         if (!strcmp(workstation_model_name, "compound")) {
 190                 xbt_ex_t e;
 191                 char *network_model_name = NULL;
 192                 char *cpu_model_name = NULL;
 193                 int network_id = -1;
 194                 int cpu_id = -1;
 195
 196                 TRY {
 197                         cpu_model_name = xbt_cfg_get_string(_surf_cfg_set, "cpu_model");
 198                 } CATCH(e) {
 199                         if (e.category == bound_error) {
 200                                 xbt_assert0(0,
 201                                                 "Set a cpu model to use with the 'compound' workstation model");
 202                                 xbt_ex_free(e);
 203                         } else {
 204                                 RETHROW;
 205                         }
 206                 }
 207
 208                 TRY {
 209                         network_model_name = xbt_cfg_get_string(_surf_cfg_set, "network_model");
 210                 }
 211                 CATCH(e) {
 212                         if (e.category == bound_error) {
 213                                 xbt_assert0(0,
 214                                                 "Set a network model to use with the 'compound' workstation model");
 215                                 xbt_ex_free(e);
 216                         } else {
 217                                 RETHROW;
 218                         }
 219                 }
 220
 221                 network_id =
 222                         find_model_description(surf_network_model_description,
 223                                         network_model_name);
 224                 cpu_id =
 225                         find_model_description(surf_cpu_model_description, cpu_model_name);
 226
 227                 surf_cpu_model_description[cpu_id].model_init(platform_file);
 228                 surf_network_model_description[network_id].model_init(platform_file);
 229         }
 230
 231         DEBUG0("Call workstation_model_init");
 232         surf_workstation_model_description[workstation_id].model_init(platform_file);
 233 }
 234
 235 void surf_config_models_create_elms(void) {
 236         char *workstation_model_name = xbt_cfg_get_string(_surf_cfg_set, "workstation_model");
 237         int workstation_id =
 238                 find_model_description(surf_workstation_model_description,
 239                                 workstation_model_name);
 240         if (surf_workstation_model_description[workstation_id].create_ws != NULL)
 241                 surf_workstation_model_description[workstation_id].create_ws();
 242 }