Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Change --surf-path into --cfg=path
[simgrid.git] / 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_cfg_set) { /* Only create stuff if not already inited */
115                 _surf_cfg_set = xbt_cfg_new();
116                 _surf_init_status = 1;
117
118                 char *description = xbt_malloc(1024), *p = description;
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
125                 xbt_cfg_register(_surf_cfg_set,
126                                 "workstation_model", xbt_strdup(description),  xbt_cfgelm_string, 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                 xbt_cfg_register(_surf_cfg_set,
135                                 "cpu_model", xbt_strdup(description), xbt_cfgelm_string, 1, 1,
136                                 &_surf_cfg_cb__cpu_model, NULL);
137
138                 sprintf(description,"The model to use for the network. Possible values: ");
139                 p = description;
140                 while (*(++p) != '\0');
141                 for (i=0;surf_network_model_description[i].name;i++)
142                         p+=sprintf(p,"%s%s",(i==0?"":", "),surf_network_model_description[i].name);
143                 xbt_cfg_register(_surf_cfg_set,
144                                 "network_model", description, xbt_cfgelm_string, 1, 1,
145                                 &_surf_cfg_cb__network_model, NULL);
146
147                 xbt_cfg_set_string(_surf_cfg_set, "workstation_model", "CLM03");
148                 xbt_cfg_set_string(_surf_cfg_set, "cpu_model", "Cas01");
149                 xbt_cfg_set_string(_surf_cfg_set, "network_model", "CM02");
150
151                 xbt_cfg_register(_surf_cfg_set,"TCP_gamma","Size of the biggest TCP window",1,1,
152                                         xbt_cfgelm_double,_surf_cfg_cb__tcp_gamma,NULL);
153                 xbt_cfg_set_double(_surf_cfg_set, "TCP_gamma", 20000.0);
154
155                 xbt_cfg_register(_surf_cfg_set,"path","Lookup path for inclusions in platform and deployment XML files",
156                                         xbt_cfgelm_string, 0,0,_surf_cfg_cb__surf_path,NULL);
157                 if (!surf_path) {
158                         /* retrieves the current directory of the        current process */
159                         const char *initial_path = __surf_get_initial_path();
160                         xbt_assert0((initial_path),
161                                         "__surf_get_initial_path() failed! Can't resolves current Windows directory");
162
163                         surf_path = xbt_dynar_new(sizeof(char *), NULL);
164                         xbt_cfg_set_string(_surf_cfg_set,"path", initial_path);
165                 }
166
167                 surf_config_cmd_line(argc,argv);
168         }
169 }
170 void surf_config_finalize(void)
171 {
172         if (!_surf_init_status)
173                 return;                     /* Not initialized yet. Nothing to do */
174
175         xbt_cfg_free(&_surf_cfg_set);
176         _surf_init_status = 0;
177 }
178
179 void surf_config_models_setup(const char *platform_file){
180         char *workstation_model_name;
181         int workstation_id = -1;
182
183         workstation_model_name =
184                 xbt_cfg_get_string(_surf_cfg_set, "workstation_model");
185
186         DEBUG1("Model : %s", workstation_model_name);
187         workstation_id =
188                 find_model_description(surf_workstation_model_description,
189                                 workstation_model_name);
190         if (!strcmp(workstation_model_name, "compound")) {
191                 xbt_ex_t e;
192                 char *network_model_name = NULL;
193                 char *cpu_model_name = NULL;
194                 int network_id = -1;
195                 int cpu_id = -1;
196
197                 TRY {
198                         cpu_model_name = xbt_cfg_get_string(_surf_cfg_set, "cpu_model");
199                 } CATCH(e) {
200                         if (e.category == bound_error) {
201                                 xbt_assert0(0,
202                                                 "Set a cpu model to use with the 'compound' workstation model");
203                                 xbt_ex_free(e);
204                         } else {
205                                 RETHROW;
206                         }
207                 }
208
209                 TRY {
210                         network_model_name = xbt_cfg_get_string(_surf_cfg_set, "network_model");
211                 }
212                 CATCH(e) {
213                         if (e.category == bound_error) {
214                                 xbt_assert0(0,
215                                                 "Set a network model to use with the 'compound' workstation model");
216                                 xbt_ex_free(e);
217                         } else {
218                                 RETHROW;
219                         }
220                 }
221
222                 network_id =
223                         find_model_description(surf_network_model_description,
224                                         network_model_name);
225                 cpu_id =
226                         find_model_description(surf_cpu_model_description, cpu_model_name);
227
228                 surf_cpu_model_description[cpu_id].model_init(platform_file);
229                 surf_network_model_description[network_id].model_init(platform_file);
230         }
231
232         DEBUG0("Call workstation_model_init");
233         surf_workstation_model_description[workstation_id].model_init(platform_file);
234 }
235
236 void surf_config_models_create_elms(void) {
237         char *workstation_model_name = xbt_cfg_get_string(_surf_cfg_set, "workstation_model");
238         int workstation_id =
239                 find_model_description(surf_workstation_model_description,
240                                 workstation_model_name);
241         if (surf_workstation_model_description[workstation_id].create_ws != NULL)
242                 surf_workstation_model_description[workstation_id].create_ws();
243 }