Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
protect against multiply create hosts in one location only
[simgrid.git] / src / surf / sg_platf.cpp
1 /* Copyright (c) 2006-2014. 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 "xbt/misc.h"
8 #include "xbt/log.h"
9 #include "xbt/str.h"
10 #include "xbt/dict.h"
11 #include "xbt/RngStream.h"
12 #include "simgrid/platf_interface.h"
13 #include "surf/surf_routing.h"
14
15 #include "cpu_interface.hpp"
16 #include "host_interface.hpp"
17
18 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_parse);
19 xbt_dynar_t sg_platf_host_cb_list = NULL;   // of sg_platf_host_cb_t
20 xbt_dynar_t sg_platf_host_link_cb_list = NULL;   // of sg_platf_host_link_cb_t
21 xbt_dynar_t sg_platf_link_cb_list = NULL;   // of sg_platf_link_cb_t
22 xbt_dynar_t sg_platf_router_cb_list = NULL; // of sg_platf_router_cb_t
23 xbt_dynar_t sg_platf_peer_cb_list = NULL; // of sg_platf_peer_cb_t
24 xbt_dynar_t sg_platf_cluster_cb_list = NULL; // of sg_platf_cluster_cb_t
25 xbt_dynar_t sg_platf_cabinet_cb_list = NULL; // of sg_platf_cluster_cb_t
26 xbt_dynar_t sg_platf_AS_begin_cb_list = NULL; //of sg_platf_AS_begin_cb_t
27 xbt_dynar_t sg_platf_AS_end_cb_list = NULL; //of void_f_void_t
28 xbt_dynar_t sg_platf_postparse_cb_list = NULL; // of void_f_void_t
29 xbt_dynar_t sg_platf_prop_cb_list = NULL; // of sg_platf_prop_cb_t
30
31 xbt_dynar_t sg_platf_route_cb_list = NULL; // of sg_platf_route_cb_t
32 xbt_dynar_t sg_platf_ASroute_cb_list = NULL; // of sg_platf_ASroute_cb_t
33 xbt_dynar_t sg_platf_bypassRoute_cb_list = NULL; // of sg_platf_bypassRoute_cb_t
34 xbt_dynar_t sg_platf_bypassASroute_cb_list = NULL; // of sg_platf_bypassASroute_cb_t
35
36 xbt_dynar_t sg_platf_trace_cb_list = NULL;
37 xbt_dynar_t sg_platf_trace_connect_cb_list = NULL;
38
39 xbt_dynar_t sg_platf_storage_cb_list = NULL; // of sg_platf_storage_cb_t
40 xbt_dynar_t sg_platf_storage_type_cb_list = NULL; // of sg_platf_storage_cb_t
41 xbt_dynar_t sg_platf_mstorage_cb_list = NULL; // of sg_platf_storage_cb_t
42 xbt_dynar_t sg_platf_mount_cb_list = NULL; // of sg_platf_storage_cb_t
43
44 xbt_dynar_t sg_platf_process_cb_list = NULL;
45
46 /* ***************************************** */
47 /* TUTORIAL: New TAG                         */
48
49 xbt_dynar_t sg_platf_gpu_cb_list = NULL;
50 /* ***************************************** */
51
52
53 static int surf_parse_models_setup_already_called = 0;
54
55 /* one RngStream for the platform, to respect some statistic rules */
56 static RngStream sg_platf_rng_stream = NULL;
57
58 /** Module management function: creates all internal data structures */
59 void sg_platf_init(void) {
60
61   //FIXME : Ugly, but useful...
62   if(sg_platf_host_cb_list)
63     return; //Already initialized, so do nothing...
64
65   sg_platf_host_cb_list = xbt_dynar_new(sizeof(sg_platf_host_cb_t), NULL);
66   sg_platf_host_link_cb_list = xbt_dynar_new(sizeof(sg_platf_host_link_cb_t), NULL);
67   sg_platf_router_cb_list = xbt_dynar_new(sizeof(sg_platf_router_cb_t), NULL);
68   sg_platf_link_cb_list = xbt_dynar_new(sizeof(sg_platf_link_cb_t), NULL);
69   sg_platf_peer_cb_list = xbt_dynar_new(sizeof(sg_platf_peer_cb_t), NULL);
70   sg_platf_cluster_cb_list = xbt_dynar_new(sizeof(sg_platf_cluster_cb_t), NULL);
71   sg_platf_cabinet_cb_list = xbt_dynar_new(sizeof(sg_platf_cabinet_cb_t), NULL);
72   sg_platf_postparse_cb_list = xbt_dynar_new(sizeof(sg_platf_link_cb_t),NULL);
73   sg_platf_AS_begin_cb_list = xbt_dynar_new(sizeof(sg_platf_AS_cb_t),NULL);
74   sg_platf_AS_end_cb_list = xbt_dynar_new(sizeof(sg_platf_AS_cb_t),NULL);
75   sg_platf_prop_cb_list = xbt_dynar_new(sizeof(sg_platf_prop_cb_t),NULL);
76
77   sg_platf_route_cb_list = xbt_dynar_new(sizeof(sg_platf_route_cb_t), NULL);
78   sg_platf_ASroute_cb_list = xbt_dynar_new(sizeof(sg_platf_route_cb_t), NULL);
79   sg_platf_bypassRoute_cb_list = xbt_dynar_new(sizeof(sg_platf_route_cb_t), NULL);
80   sg_platf_bypassASroute_cb_list = xbt_dynar_new(sizeof(sg_platf_route_cb_t), NULL);
81
82   sg_platf_trace_cb_list = xbt_dynar_new(sizeof(sg_platf_trace_cb_t), NULL);
83   sg_platf_trace_connect_cb_list = xbt_dynar_new(sizeof(sg_platf_trace_connect_cb_t), NULL);
84
85   sg_platf_storage_cb_list = xbt_dynar_new(sizeof(sg_platf_storage_cb_t), NULL);
86   sg_platf_storage_type_cb_list = xbt_dynar_new(sizeof(sg_platf_storage_cb_t), NULL);
87   sg_platf_mstorage_cb_list = xbt_dynar_new(sizeof(sg_platf_storage_cb_t), NULL);
88   sg_platf_mount_cb_list = xbt_dynar_new(sizeof(sg_platf_storage_cb_t), NULL);
89
90   sg_platf_process_cb_list = xbt_dynar_new(sizeof(sg_platf_process_cb_t), NULL);
91
92   /* ***************************************** */
93   /* TUTORIAL: New TAG                         */
94
95   sg_platf_gpu_cb_list = xbt_dynar_new(sizeof(sg_platf_gpu_cb_t), NULL);
96   /* ***************************************** */
97 }
98 /** Module management function: frees all internal data structures */
99 void sg_platf_exit(void) {
100   xbt_dynar_free(&sg_platf_host_cb_list);
101   xbt_dynar_free(&sg_platf_host_link_cb_list);
102   xbt_dynar_free(&sg_platf_router_cb_list);
103   xbt_dynar_free(&sg_platf_link_cb_list);
104   xbt_dynar_free(&sg_platf_postparse_cb_list);
105   xbt_dynar_free(&sg_platf_peer_cb_list);
106   xbt_dynar_free(&sg_platf_cluster_cb_list);
107   xbt_dynar_free(&sg_platf_cabinet_cb_list);
108   xbt_dynar_free(&sg_platf_AS_begin_cb_list);
109   xbt_dynar_free(&sg_platf_AS_end_cb_list);
110   xbt_dynar_free(&sg_platf_prop_cb_list);
111
112   xbt_dynar_free(&sg_platf_trace_cb_list);
113   xbt_dynar_free(&sg_platf_trace_connect_cb_list);
114
115   xbt_dynar_free(&sg_platf_route_cb_list);
116   xbt_dynar_free(&sg_platf_ASroute_cb_list);
117   xbt_dynar_free(&sg_platf_bypassRoute_cb_list);
118   xbt_dynar_free(&sg_platf_bypassASroute_cb_list);
119
120   xbt_dynar_free(&sg_platf_storage_cb_list);
121   xbt_dynar_free(&sg_platf_storage_type_cb_list);
122   xbt_dynar_free(&sg_platf_mstorage_cb_list);
123   xbt_dynar_free(&sg_platf_mount_cb_list);
124
125   xbt_dynar_free(&sg_platf_process_cb_list);
126
127   /* ***************************************** */
128   /* TUTORIAL: New TAG                         */
129
130   xbt_dynar_free(&sg_platf_gpu_cb_list);
131
132   /* ***************************************** */
133
134   /* make sure that we will reinit the models while loading the platf once reinited */
135   surf_parse_models_setup_already_called = 0;
136 }
137
138 void sg_platf_new_host(sg_platf_host_cbarg_t host)
139 {
140
141   xbt_assert(! sg_host_by_name(host->id),
142                      "Refusing to create a second host named '%s'.", host->id);
143
144   RoutingEdge *net = NULL;
145   As* current_routing = routing_get_current();
146   if (current_routing)
147     net = routing_add_host(current_routing, host);
148
149   Cpu *cpu = surf_cpu_model_pm->createCpu(
150         host->id,
151         host->power_peak,
152         host->pstate,
153         host->power_scale,
154         host->power_trace,
155         host->core_amount,
156         host->initial_state,
157         host->state_trace,
158         host->properties);
159   surf_host_model->createHost(host->id, net, cpu);
160
161   unsigned int iterator;
162   sg_platf_host_cb_t fun;
163   xbt_dynar_foreach(sg_platf_host_cb_list, iterator, fun) {
164     fun(host);
165   }
166 }
167 void sg_platf_new_host_link(sg_platf_host_link_cbarg_t h){
168   unsigned int iterator;
169   sg_platf_host_link_cb_t fun;
170   xbt_dynar_foreach(sg_platf_host_link_cb_list, iterator, fun) {
171     fun(h);
172   }
173 }
174 void sg_platf_new_router(sg_platf_router_cbarg_t router) {
175   unsigned int iterator;
176   sg_platf_router_cb_t fun;
177   xbt_dynar_foreach(sg_platf_router_cb_list, iterator, fun) {
178     fun(router);
179   }
180 }
181 void sg_platf_new_link(sg_platf_link_cbarg_t link){
182   unsigned int iterator;
183   sg_platf_link_cb_t fun;
184   xbt_dynar_foreach(sg_platf_link_cb_list, iterator, fun) {
185     fun(link);
186   }
187 }
188
189 void sg_platf_new_peer(sg_platf_peer_cbarg_t peer){
190   unsigned int iterator;
191   sg_platf_peer_cb_t fun;
192   xbt_dynar_foreach(sg_platf_peer_cb_list, iterator, fun) {
193     fun(peer);
194   }
195 }
196 void sg_platf_new_cluster(sg_platf_cluster_cbarg_t cluster){
197   unsigned int iterator;
198   sg_platf_cluster_cb_t fun;
199   xbt_dynar_foreach(sg_platf_cluster_cb_list, iterator, fun) {
200     fun(cluster);
201   }
202 }
203 void sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet){
204   unsigned int iterator;
205   sg_platf_cabinet_cb_t fun;
206   xbt_dynar_foreach(sg_platf_cabinet_cb_list, iterator, fun) {
207     fun(cabinet);
208   }
209 }
210 void sg_platf_new_storage(sg_platf_storage_cbarg_t storage){
211   unsigned int iterator;
212   sg_platf_storage_cb_t fun;
213   xbt_dynar_foreach(sg_platf_storage_cb_list, iterator, fun) {
214     fun(storage);
215   }
216 }
217 void sg_platf_new_storage_type(sg_platf_storage_type_cbarg_t storage_type){
218   unsigned int iterator;
219   sg_platf_storage_type_cb_t fun;
220   xbt_dynar_foreach(sg_platf_storage_type_cb_list, iterator, fun) {
221     fun(storage_type);
222   }
223 }
224 void sg_platf_new_mstorage(sg_platf_mstorage_cbarg_t mstorage){
225   unsigned int iterator;
226   sg_platf_mstorage_cb_t fun;
227   xbt_dynar_foreach(sg_platf_mstorage_cb_list, iterator, fun) {
228     fun(mstorage);
229   }
230 }
231 void sg_platf_new_mount(sg_platf_mount_cbarg_t mount){
232   unsigned int iterator;
233   sg_platf_mount_cb_t fun;
234   xbt_dynar_foreach(sg_platf_mount_cb_list, iterator, fun) {
235     fun(mount);
236   }
237 }
238 void sg_platf_new_route(sg_platf_route_cbarg_t route) {
239   unsigned int iterator;
240   sg_platf_route_cb_t fun;
241   xbt_dynar_foreach(sg_platf_route_cb_list, iterator, fun) {
242     fun(route);
243   }
244 }
245 void sg_platf_new_ASroute(sg_platf_route_cbarg_t ASroute) {
246   unsigned int iterator;
247   sg_platf_route_cb_t fun;
248   xbt_dynar_foreach(sg_platf_ASroute_cb_list, iterator, fun) {
249     fun(ASroute);
250   }
251 }
252 void sg_platf_new_bypassRoute(sg_platf_route_cbarg_t bypassRoute) {
253   unsigned int iterator;
254   sg_platf_route_cb_t fun;
255   xbt_dynar_foreach(sg_platf_bypassRoute_cb_list, iterator, fun) {
256     fun(bypassRoute);
257   }
258 }
259 void sg_platf_new_bypassASroute(sg_platf_route_cbarg_t bypassASroute) {
260   unsigned int iterator;
261   sg_platf_route_cb_t fun;
262   xbt_dynar_foreach(sg_platf_bypassASroute_cb_list, iterator, fun) {
263     fun(bypassASroute);
264   }
265 }
266 void sg_platf_new_prop(sg_platf_prop_cbarg_t prop) {
267   unsigned int iterator;
268   sg_platf_prop_cb_t fun;
269   xbt_dynar_foreach(sg_platf_prop_cb_list, iterator, fun) {
270     fun(prop);
271   }
272 }
273 void sg_platf_new_trace(sg_platf_trace_cbarg_t trace) {
274   unsigned int iterator;
275   sg_platf_trace_cb_t fun;
276   xbt_dynar_foreach(sg_platf_trace_cb_list, iterator, fun) {
277     fun(trace);
278   }
279 }
280 void sg_platf_trace_connect(sg_platf_trace_connect_cbarg_t trace_connect) {
281   unsigned int iterator;
282   sg_platf_trace_connect_cb_t fun;
283   xbt_dynar_foreach(sg_platf_trace_connect_cb_list, iterator, fun) {
284     fun(trace_connect);
285   }
286 }
287 void sg_platf_new_process(sg_platf_process_cbarg_t process){
288   unsigned int iterator;
289   sg_platf_process_cb_t fun;
290   xbt_dynar_foreach(sg_platf_process_cb_list, iterator, fun) {
291     fun(process);
292   }
293 }
294
295 void sg_platf_route_begin (sg_platf_route_cbarg_t route){
296   route->link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
297 }
298 void sg_platf_ASroute_begin (sg_platf_route_cbarg_t ASroute){
299   ASroute->link_list = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
300 }
301
302 void sg_platf_route_end (sg_platf_route_cbarg_t route){
303   sg_platf_new_route(route);
304 }
305 void sg_platf_ASroute_end (sg_platf_route_cbarg_t ASroute){
306   sg_platf_new_ASroute(ASroute);
307 }
308
309 void sg_platf_route_add_link (const char* link_id, sg_platf_route_cbarg_t route){
310   char *link_name = xbt_strdup(link_id);
311   xbt_dynar_push(route->link_list, &link_name);
312 }
313 void sg_platf_ASroute_add_link (const char* link_id, sg_platf_route_cbarg_t ASroute){
314   char *link_name = xbt_strdup(link_id);
315   xbt_dynar_push(ASroute->link_list, &link_name);
316 }
317
318 void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ }
319
320 void sg_platf_end() {
321   unsigned int iterator;
322   void_f_void_t fun;
323   xbt_dynar_foreach(sg_platf_postparse_cb_list, iterator, fun) {
324     fun();
325   }
326 }
327
328 void sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS) {
329   unsigned int iterator;
330   sg_platf_AS_cb_t fun;
331
332   if (!surf_parse_models_setup_already_called && !xbt_dynar_is_empty(sg_platf_AS_begin_cb_list)) {
333     /* Initialize the surf models. That must be done after we got all config, and before we need the models.
334      * That is, after the last <config> tag, if any, and before the first of cluster|peer|AS|trace|trace_connect
335      *
336      * I'm not sure for <trace> and <trace_connect>, there may be a bug here
337      * (FIXME: check it out by creating a file beginning with one of these tags)
338      * but cluster and peer create ASes internally, so putting the code in there is ok.
339      *
340      * We are also guarding against xbt_dynar_length(sg_platf_AS_begin_cb_list) because we don't
341      * want to initialize the models if we are parsing the file to get the deployment. That could happen if
342      * the same file would be used for platf and deploy: it'd contain AS tags even during the deploy parsing.
343      * Removing that guard would result of the models to get re-inited when parsing for deploy.
344      */
345     surf_parse_models_setup_already_called = 1;
346     surf_config_models_setup();
347   }
348
349   xbt_dynar_foreach(sg_platf_AS_begin_cb_list, iterator, fun) {
350     fun(AS);
351   }
352 }
353
354 void sg_platf_new_AS_end() {
355   unsigned int iterator;
356   void_f_void_t fun;
357   xbt_dynar_foreach(sg_platf_AS_end_cb_list, iterator, fun) {
358     fun();
359   }
360 }
361
362 /* ***************************************** */
363 /* TUTORIAL: New TAG                         */
364
365 void sg_platf_new_gpu(sg_platf_gpu_cbarg_t gpu) {
366   unsigned int iterator;
367   void_f_void_t fun;
368   xbt_dynar_foreach(sg_platf_gpu_cb_list, iterator, fun) {
369     fun();
370   }
371 }
372
373 void sg_platf_gpu_add_cb(sg_platf_gpu_cb_t fct) {
374   xbt_dynar_push(sg_platf_gpu_cb_list, &fct);
375 }
376
377 /* ***************************************** */
378
379
380 void sg_platf_host_add_cb(sg_platf_host_cb_t fct) {
381   xbt_dynar_push(sg_platf_host_cb_list, &fct);
382 }
383 void sg_platf_host_link_add_cb(sg_platf_host_link_cb_t fct) {
384   xbt_dynar_push(sg_platf_host_link_cb_list, &fct);
385 }
386 void sg_platf_link_add_cb(sg_platf_link_cb_t fct) {
387   xbt_dynar_push(sg_platf_link_cb_list, &fct);
388 }
389 void sg_platf_router_add_cb(sg_platf_router_cb_t fct) {
390   xbt_dynar_push(sg_platf_router_cb_list, &fct);
391 }
392 void sg_platf_peer_add_cb(sg_platf_peer_cb_t fct) {
393   xbt_dynar_push(sg_platf_peer_cb_list, &fct);
394 }
395 void sg_platf_cluster_add_cb(sg_platf_cluster_cb_t fct) {
396   xbt_dynar_push(sg_platf_cluster_cb_list, &fct);
397 }
398 void sg_platf_cabinet_add_cb(sg_platf_cabinet_cb_t fct) {
399   xbt_dynar_push(sg_platf_cabinet_cb_list, &fct);
400 }
401 void sg_platf_postparse_add_cb(void_f_void_t fct) {
402   xbt_dynar_push(sg_platf_postparse_cb_list, &fct);
403 }
404 void sg_platf_AS_begin_add_cb(sg_platf_AS_cb_t fct) {
405   xbt_dynar_push(sg_platf_AS_begin_cb_list, &fct);
406 }
407 void sg_platf_AS_end_add_cb(sg_platf_AS_cb_t fct) {
408   xbt_dynar_push(sg_platf_AS_end_cb_list, &fct);
409 }
410 void sg_platf_storage_add_cb(sg_platf_storage_cb_t fct) {
411   xbt_dynar_push(sg_platf_storage_cb_list, &fct);
412 }
413 void sg_platf_storage_type_add_cb(sg_platf_storage_type_cb_t fct) {
414   xbt_dynar_push(sg_platf_storage_type_cb_list, &fct);
415 }
416 void sg_platf_mstorage_add_cb(sg_platf_mstorage_cb_t fct) {
417   xbt_dynar_push(sg_platf_mstorage_cb_list, &fct);
418 }
419 void sg_platf_mount_add_cb(sg_platf_mount_cb_t fct) {
420   xbt_dynar_push(sg_platf_mount_cb_list, &fct);
421 }
422 void sg_platf_route_add_cb(sg_platf_route_cb_t fct) {
423   xbt_dynar_push(sg_platf_route_cb_list, &fct);
424 }
425 void sg_platf_ASroute_add_cb(sg_platf_route_cb_t fct) {
426   xbt_dynar_push(sg_platf_ASroute_cb_list, &fct);
427 }
428 void sg_platf_bypassRoute_add_cb(sg_platf_route_cb_t fct) {
429   xbt_dynar_push(sg_platf_bypassRoute_cb_list, &fct);
430 }
431 void sg_platf_bypassASroute_add_cb(sg_platf_route_cb_t fct) {
432   xbt_dynar_push(sg_platf_bypassASroute_cb_list, &fct);
433 }
434 void sg_platf_prop_add_cb(sg_platf_prop_cb_t fct) {
435   xbt_dynar_push(sg_platf_prop_cb_list, &fct);
436 }
437 void sg_platf_trace_add_cb(sg_platf_trace_cb_t fct) {
438   xbt_dynar_push(sg_platf_trace_cb_list, &fct);
439 }
440 void sg_platf_trace_connect_add_cb(sg_platf_trace_connect_cb_t fct) {
441   xbt_dynar_push(sg_platf_trace_connect_cb_list, &fct);
442 }
443 void sg_platf_rng_stream_init(unsigned long seed[6]) {
444   RngStream_SetPackageSeed(seed);
445   sg_platf_rng_stream = RngStream_CreateStream(NULL);
446 }
447 void sg_platf_process_add_cb(sg_platf_process_cb_t fct) {
448   xbt_dynar_push(sg_platf_process_cb_list, &fct);
449 }
450
451 RngStream sg_platf_rng_stream_get(const char* id) {
452   RngStream stream = NULL;
453   unsigned int id_hash;
454
455   stream = RngStream_CopyStream(sg_platf_rng_stream);
456   id_hash = xbt_str_hash(id);
457   RngStream_AdvanceState(stream, 0, (long)id_hash);
458
459   return stream;
460 }