Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Do routing parse before tracing parse
[simgrid.git] / src / instr / instr_routing.c
1 /* Copyright (c) 2010. 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 "instr/instr_private.h"
8
9 #ifdef HAVE_TRACING
10 #include "surf/surf_private.h"
11 #include "surf/network_private.h"
12 #include "xbt/graph.h"
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_routing, instr, "Tracing platform hierarchy");
15
16 extern xbt_dict_t defined_types; /* from instr_interface.c */
17
18 static int platform_created = 0;            /* indicate whether the platform file has been traced */
19 static xbt_dynar_t currentContainer = NULL; /* push and pop, used only in creation */
20
21 static container_t lowestCommonAncestor (container_t a1, container_t a2)
22 {
23   //this is only an optimization (since most of a1 and a2 share the same parent)
24   if (a1->father == a2->father) return a1->father;
25
26   //create an array with all ancestors of a1
27   xbt_dynar_t ancestors_a1 = xbt_dynar_new(sizeof(container_t), NULL);
28   container_t p;
29   p = a1->father;
30   while (p){
31     xbt_dynar_push_as (ancestors_a1, container_t, p);
32     p = p->father;
33   }
34
35   //create an array with all ancestors of a2
36   xbt_dynar_t ancestors_a2 = xbt_dynar_new(sizeof(container_t), NULL);
37   p = a2->father;
38   while (p){
39     xbt_dynar_push_as (ancestors_a2, container_t, p);
40     p = p->father;
41   }
42
43   //find the lowest ancestor
44   p = NULL;
45   int i = xbt_dynar_length (ancestors_a1) - 1;
46   int j = xbt_dynar_length (ancestors_a2) - 1;
47   while (i >= 0 && j >= 0){
48     container_t a1p = *(container_t*)xbt_dynar_get_ptr (ancestors_a1, i);
49     container_t a2p = *(container_t*)xbt_dynar_get_ptr (ancestors_a2, j);
50     if (a1p == a2p){
51       p = a1p;
52     }else{
53       break;
54     }
55     i--;
56     j--;
57   }
58   xbt_dynar_free (&ancestors_a1);
59   xbt_dynar_free (&ancestors_a2);
60   return p;
61 }
62
63 static void linkContainers (container_t src, container_t dst, xbt_dict_t filter)
64 {
65   //ignore loopback
66   if (strcmp (src->name, "__loopback__") == 0 || strcmp (dst->name, "__loopback__") == 0)
67     return;
68
69   //find common father
70   container_t father = lowestCommonAncestor (src, dst);
71   if (!father){
72     xbt_die ("common father unknown, this is a tracing problem");
73   }
74
75   if (filter != NULL){
76     //check if we already register this pair (we only need one direction)
77     char aux1[INSTR_DEFAULT_STR_SIZE], aux2[INSTR_DEFAULT_STR_SIZE];
78     snprintf (aux1, INSTR_DEFAULT_STR_SIZE, "%s%s", src->name, dst->name);
79     snprintf (aux2, INSTR_DEFAULT_STR_SIZE, "%s%s", dst->name, src->name);
80     if (xbt_dict_get_or_null (filter, aux1)) return;
81     if (xbt_dict_get_or_null (filter, aux2)) return;
82
83     //ok, not found, register it
84     xbt_dict_set (filter, aux1, xbt_strdup ("1"), NULL);
85     xbt_dict_set (filter, aux2, xbt_strdup ("1"), NULL);
86   }
87
88   //declare type
89   char link_typename[INSTR_DEFAULT_STR_SIZE];
90   snprintf (link_typename, INSTR_DEFAULT_STR_SIZE, "%s-%s%s-%s%s",
91             father->type->name,
92             src->type->name, src->type->id,
93             dst->type->name, dst->type->id);
94   type_t link_type = PJ_type_get_or_null (link_typename, father->type);
95   if (link_type == NULL){
96     link_type = PJ_type_link_new (link_typename, father->type, src->type, dst->type);
97   }
98
99   //register EDGE types for triva configuration
100   xbt_dict_set (trivaEdgeTypes, link_type->name, xbt_strdup("1"), NULL);
101
102   //create the link
103   static long long counter = 0;
104   char key[INSTR_DEFAULT_STR_SIZE];
105   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
106   new_pajeStartLink(SIMIX_get_clock(), father, link_type, src, "G", key);
107   new_pajeEndLink(SIMIX_get_clock(), father, link_type, dst, "G", key);
108 }
109
110 static void recursiveGraphExtraction (AS_t rc, container_t container, xbt_dict_t filter)
111 {
112   if (!xbt_dict_is_empty(rc->routing_sons)){
113     xbt_dict_cursor_t cursor = NULL;
114     AS_t rc_son;
115     char *child_name;
116     //bottom-up recursion
117     xbt_dict_foreach(rc->routing_sons, cursor, child_name, rc_son) {
118       container_t child_container = xbt_dict_get (container->children, rc_son->name);
119       recursiveGraphExtraction (rc_son, child_container, filter);
120     }
121   }
122
123   //let's get routes
124   xbt_dict_cursor_t cursor1 = NULL, cursor2 = NULL;
125   container_t child1, child2;
126   const char *child1_name, *child2_name;
127   xbt_dict_foreach(container->children, cursor1, child1_name, child1) {
128     if (child1->kind == INSTR_LINK) continue;
129     xbt_dict_foreach(container->children, cursor2, child2_name, child2) {
130       if (child2->kind == INSTR_LINK) continue;
131
132       if ((child1->kind == INSTR_HOST || child1->kind == INSTR_ROUTER) &&
133           (child2->kind == INSTR_HOST  || child2->kind == INSTR_ROUTER) &&
134           strcmp (child1_name, child2_name) != 0){
135
136         xbt_dynar_t route = NULL;
137         xbt_ex_t e;
138
139         TRY {
140           routing_get_route_and_latency(child1_name, child2_name, &route, NULL);
141         } CATCH(e) {
142           xbt_ex_free(e);
143         }
144         if (route == NULL) continue;
145
146         if (TRACE_onelink_only()){
147           if (xbt_dynar_length (route) > 1) continue;
148         }
149         container_t previous = child1;
150         int i;
151         for (i = 0; i < xbt_dynar_length(route); i++){
152           link_CM02_t *link = ((link_CM02_t*)xbt_dynar_get_ptr (route, i));
153           char *link_name = (*link)->lmm_resource.generic_resource.name;
154           container_t current = PJ_container_get(link_name);
155           linkContainers(previous, current, filter);
156           previous = current;
157         }
158         linkContainers(previous, child2, filter);
159
160       }else if (child1->kind == INSTR_AS &&
161                 child2->kind == INSTR_AS &&
162                 strcmp(child1_name, child2_name) != 0){
163
164         route_t route = xbt_new0(s_route_t,1);
165         route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
166         rc->get_route_and_latency (rc, child1_name, child2_name, route,NULL);
167         unsigned int cpt;
168         void *link;
169         container_t previous = PJ_container_get(route->src_gateway);
170         xbt_dynar_foreach (route->link_list, cpt, link) {
171           char *link_name = ((link_CM02_t)link)->lmm_resource.generic_resource.name;
172           container_t current = PJ_container_get(link_name);
173           linkContainers (previous, current, filter);
174           previous = current;
175         }
176         container_t last = PJ_container_get(route->dst_gateway);
177         linkContainers (previous, last, filter);
178         generic_free_route(route);
179       }
180     }
181   }
182 }
183
184 /*
185  * Callbacks
186  */
187 static void instr_routing_parse_start_AS (const char*id,const char*routing)
188 {
189   if (PJ_container_get_root() == NULL){
190     PJ_container_alloc ();
191     PJ_type_alloc();
192     container_t root = PJ_container_new (id, INSTR_AS, NULL);
193     PJ_container_set_root (root);
194
195     if (TRACE_smpi_is_enabled()) {
196       if (!TRACE_smpi_is_grouped()){
197         type_t mpi = PJ_type_get_or_null ("MPI", root->type);
198         if (mpi == NULL){
199           mpi = PJ_type_container_new("MPI", root->type);
200           PJ_type_state_new ("MPI_STATE", mpi);
201           PJ_type_link_new ("MPI_LINK", PJ_type_get_root(), mpi, mpi);
202         }
203       }
204     }
205
206     if (TRACE_needs_platform()){
207       currentContainer = xbt_dynar_new (sizeof(container_t), NULL);
208       xbt_dynar_push (currentContainer, &root);
209     }
210     return;
211   }
212
213   if (TRACE_needs_platform()){
214     container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
215     container_t new = PJ_container_new (id, INSTR_AS, father);
216     xbt_dynar_push (currentContainer, &new);
217   }
218 }
219
220 static void instr_routing_parse_end_AS ()
221 {
222   if (TRACE_needs_platform()){
223     xbt_dynar_pop_ptr (currentContainer);
224   }
225 }
226
227 static void instr_routing_parse_start_link (sg_platf_link_cbarg_t link)
228 {
229   container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
230
231   double bandwidth_value = link->bandwidth;
232   double latency_value = link->latency;
233   xbt_dynar_t links_to_create = xbt_dynar_new (sizeof(char*), &xbt_free_ref);
234
235   if (link->policy == SURF_LINK_FULLDUPLEX){
236     char *up = bprintf("%s_UP", link->id);
237     char *down = bprintf("%s_DOWN", link->id);
238     xbt_dynar_push_as (links_to_create, char*, xbt_strdup(up));
239     xbt_dynar_push_as (links_to_create, char*, xbt_strdup(down));
240     free (up);
241     free (down);
242   }else{
243     xbt_dynar_push_as (links_to_create, char*, strdup(link->id));
244   }
245
246   char *link_name = NULL;
247   unsigned int i;
248   xbt_dynar_foreach (links_to_create, i, link_name){
249
250     container_t new = PJ_container_new (link_name, INSTR_LINK, father);
251
252     if (TRACE_categorized() || TRACE_uncategorized()){
253       type_t bandwidth = PJ_type_get_or_null ("bandwidth", new->type);
254       if (bandwidth == NULL){
255         bandwidth = PJ_type_variable_new ("bandwidth", NULL, new->type);
256       }
257       type_t latency = PJ_type_get_or_null ("latency", new->type);
258       if (latency == NULL){
259         latency = PJ_type_variable_new ("latency", NULL, new->type);
260       }
261       new_pajeSetVariable (0, new, bandwidth, bandwidth_value);
262       new_pajeSetVariable (0, new, latency, latency_value);
263     }
264     if (TRACE_uncategorized()){
265       type_t bandwidth_used = PJ_type_get_or_null ("bandwidth_used", new->type);
266       if (bandwidth_used == NULL){
267         bandwidth_used = PJ_type_variable_new ("bandwidth_used", "0.5 0.5 0.5", new->type);
268       }
269     }
270   }
271
272   xbt_dynar_free (&links_to_create);
273 }
274
275 static void instr_routing_parse_start_host (sg_platf_host_cbarg_t host)
276 {
277   container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
278   container_t new = PJ_container_new (host->id, INSTR_HOST, father);
279
280   if (TRACE_categorized() || TRACE_uncategorized()) {
281     type_t power = PJ_type_get_or_null ("power", new->type);
282     if (power == NULL){
283       power = PJ_type_variable_new ("power", NULL, new->type);
284     }
285     new_pajeSetVariable (0, new, power, host->power_peak);
286   }
287   if (TRACE_uncategorized()){
288     type_t power_used = PJ_type_get_or_null ("power_used", new->type);
289     if (power_used == NULL){
290       power_used = PJ_type_variable_new ("power_used", "0.5 0.5 0.5", new->type);
291     }
292   }
293
294   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()){
295     type_t mpi = PJ_type_get_or_null ("MPI", new->type);
296     if (mpi == NULL){
297       mpi = PJ_type_container_new("MPI", new->type);
298       PJ_type_state_new ("MPI_STATE", mpi);
299       PJ_type_link_new ("MPI_LINK", PJ_type_get_root(), mpi, mpi);
300     }
301   }
302
303   if (TRACE_msg_process_is_enabled()) {
304     type_t msg_process = PJ_type_get_or_null ("MSG_PROCESS", new->type);
305     if (msg_process == NULL){
306       msg_process = PJ_type_container_new("MSG_PROCESS", new->type);
307       type_t state = PJ_type_state_new ("MSG_PROCESS_STATE", msg_process);
308       PJ_value_new ("executing", "0 1 0", state);
309       PJ_value_new ("suspend", "1 0 1", state);
310       PJ_value_new ("sleep", "1 1 0", state);
311       PJ_value_new ("receive", "1 0 0", state);
312       PJ_value_new ("send", "0 0 1", state);
313       PJ_value_new ("task_execute", "0 1 1", state);
314       PJ_type_link_new ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
315       PJ_type_link_new ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
316     }
317   }
318 }
319
320 static void instr_routing_parse_start_router (sg_platf_router_cbarg_t router)
321 {
322   container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
323   PJ_container_new (router->id, INSTR_ROUTER, father);
324 }
325
326 static void instr_routing_parse_end_platform ()
327 {
328   xbt_dynar_free(&currentContainer);
329   currentContainer = NULL;
330   xbt_dict_t filter = xbt_dict_new_homogeneous(xbt_free);
331   recursiveGraphExtraction (global_routing->root, PJ_container_get_root(), filter);
332   xbt_dict_free(&filter);
333   platform_created = 1;
334   TRACE_paje_dump_buffer(1);
335 }
336
337 void instr_routing_define_callbacks ()
338 {
339   if (!TRACE_is_enabled()) return;
340   //always need the call backs to ASes (we need only the root AS),
341   //to create the rootContainer and the rootType properly
342   sg_platf_AS_begin_add_cb(instr_routing_parse_start_AS);
343   sg_platf_AS_end_add_cb(instr_routing_parse_end_AS);
344   if (!TRACE_needs_platform()) return;
345   sg_platf_link_add_cb(instr_routing_parse_start_link);
346   sg_platf_host_add_cb(instr_routing_parse_start_host);
347   sg_platf_router_add_cb(instr_routing_parse_start_router);
348
349   sg_platf_postparse_add_cb(instr_routing_parse_end_platform);
350 }
351
352 /*
353  * user categories support
354  */
355 static void recursiveNewVariableType (const char *new_typename, const char *color, type_t root)
356 {
357   if (!strcmp (root->name, "HOST")){
358     char tnstr[INSTR_DEFAULT_STR_SIZE];
359     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
360     PJ_type_variable_new (tnstr, color, root);
361   }
362   if (!strcmp (root->name, "LINK")){
363     char tnstr[INSTR_DEFAULT_STR_SIZE];
364     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "b%s", new_typename);
365     PJ_type_variable_new (tnstr, color, root);
366   }
367   xbt_dict_cursor_t cursor = NULL;
368   type_t child_type;
369   char *name;
370   xbt_dict_foreach(root->children, cursor, name, child_type) {
371     recursiveNewVariableType (new_typename, color, child_type);
372   }
373 }
374
375 void instr_new_variable_type (const char *new_typename, const char *color)
376 {
377   recursiveNewVariableType (new_typename, color, PJ_type_get_root());
378 }
379
380 static void recursiveNewUserVariableType (const char *father_type, const char *new_typename, const char *color, type_t root)
381 {
382   if (!strcmp (root->name, father_type)){
383     PJ_type_variable_new (new_typename, color, root);
384   }
385   xbt_dict_cursor_t cursor = NULL;
386   type_t child_type;
387   char *name;
388   xbt_dict_foreach(root->children, cursor, name, child_type) {
389     recursiveNewUserVariableType (father_type, new_typename, color, child_type);
390   }
391 }
392
393 void instr_new_user_variable_type  (const char *father_type, const char *new_typename, const char *color)
394 {
395   recursiveNewUserVariableType (father_type, new_typename, color, PJ_type_get_root());
396 }
397
398
399
400 int instr_platform_traced ()
401 {
402   return platform_created;
403 }
404
405 #define GRAPHICATOR_SUPPORT_FUNCTIONS
406
407
408 static xbt_node_t new_xbt_graph_node (xbt_graph_t graph, const char *name, xbt_dict_t nodes)
409 {
410   xbt_node_t ret = xbt_dict_get_or_null (nodes, name);
411   if (ret) return ret;
412
413   ret = xbt_graph_new_node (graph, xbt_strdup(name));
414   xbt_dict_set (nodes, name, ret, NULL);
415   return ret;
416 }
417
418 static xbt_edge_t new_xbt_graph_edge (xbt_graph_t graph, xbt_node_t s, xbt_node_t d, xbt_dict_t edges)
419 {
420   xbt_edge_t ret;
421   char *name;
422
423   const char *sn = TRACE_node_name (s);
424   const char *dn = TRACE_node_name (d);
425
426   name = bprintf ("%s%s", sn, dn);
427   ret = xbt_dict_get_or_null (edges, name);
428   if (ret) return ret;
429   free (name);
430   name = bprintf ("%s%s", dn, sn);
431   ret = xbt_dict_get_or_null (edges, name);
432   if (ret) return ret;
433
434   ret = xbt_graph_new_edge(graph, s, d, NULL);
435   xbt_dict_set (edges, name, ret, NULL);
436   return ret;
437 }
438
439 static void recursiveXBTGraphExtraction (xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges,
440     AS_t rc, container_t container)
441 {
442   if (!xbt_dict_is_empty(rc->routing_sons)){
443     xbt_dict_cursor_t cursor = NULL;
444     AS_t rc_son;
445     char *child_name;
446     //bottom-up recursion
447     xbt_dict_foreach(rc->routing_sons, cursor, child_name, rc_son) {
448       container_t child_container = xbt_dict_get (container->children, rc_son->name);
449       recursiveXBTGraphExtraction (graph, nodes, edges, rc_son, child_container);
450     }
451   }
452
453   //let's get routes
454   xbt_dict_cursor_t cursor1 = NULL, cursor2 = NULL;
455   container_t child1, child2;
456   const char *child1_name, *child2_name;
457   xbt_dict_foreach(container->children, cursor1, child1_name, child1) {
458     if (child1->kind == INSTR_LINK) continue;
459     xbt_dict_foreach(container->children, cursor2, child2_name, child2) {
460       if (child2->kind == INSTR_LINK) continue;
461
462       if ((child1->kind == INSTR_HOST || child1->kind == INSTR_ROUTER) &&
463           (child2->kind == INSTR_HOST  || child2->kind == INSTR_ROUTER) &&
464           strcmp (child1_name, child2_name) != 0){
465
466         // FIXME factorize route creation with else branch below (once possible)
467         xbt_dynar_t route=NULL;
468         routing_get_route_and_latency (child1_name, child2_name,&route,NULL);
469         if (TRACE_onelink_only()){
470           if (xbt_dynar_length (route) > 1) continue;
471         }
472         unsigned int cpt;
473         void *link;
474         xbt_node_t current, previous = new_xbt_graph_node(graph, child1_name, nodes);
475         xbt_dynar_foreach (route, cpt, link) {
476           char *link_name = ((link_CM02_t)link)->lmm_resource.generic_resource.name;
477           current = new_xbt_graph_node(graph, link_name, nodes);
478           new_xbt_graph_edge (graph, previous, current, edges);
479           //previous -> current
480           previous = current;
481         }
482         current = new_xbt_graph_node(graph, child2_name, nodes);
483         new_xbt_graph_edge (graph, previous, current, edges);
484
485       }else if (child1->kind == INSTR_AS &&
486                 child2->kind == INSTR_AS &&
487                 strcmp(child1_name, child2_name) != 0){
488
489         route_t route = xbt_new0(s_route_t,1);
490         route->link_list = xbt_dynar_new(global_routing->size_of_link,NULL);
491         rc->get_route_and_latency (rc, child1_name, child2_name,route, NULL);
492         unsigned int cpt;
493         void *link;
494         xbt_node_t current, previous = new_xbt_graph_node(graph, route->src_gateway, nodes);
495         xbt_dynar_foreach (route->link_list, cpt, link) {
496           char *link_name = ((link_CM02_t)link)->lmm_resource.generic_resource.name;
497           current = new_xbt_graph_node(graph, link_name, nodes);
498           //previous -> current
499           previous = current;
500         }
501         current = new_xbt_graph_node(graph, route->dst_gateway, nodes);
502         new_xbt_graph_edge (graph, previous, current, edges);
503         generic_free_route(route);
504       }
505     }
506   }
507
508 }
509
510 xbt_graph_t instr_routing_platform_graph (void)
511 {
512   xbt_graph_t ret = xbt_graph_new_graph (0, NULL);
513   xbt_dict_t nodes = xbt_dict_new_homogeneous(NULL);
514   xbt_dict_t edges = xbt_dict_new_homogeneous(NULL);
515   recursiveXBTGraphExtraction (ret, nodes, edges, global_routing->root, PJ_container_get_root());
516   return ret;
517 }
518
519 void instr_routing_platform_graph_export_graphviz (xbt_graph_t g, const char *filename)
520 {
521   unsigned int cursor = 0;
522   xbt_node_t node = NULL;
523   xbt_edge_t edge = NULL;
524   FILE *file = NULL;
525
526   file = fopen(filename, "w");
527   xbt_assert(file, "Failed to open %s \n", filename);
528
529   if (g->directed)
530     fprintf(file, "digraph test {\n");
531   else
532     fprintf(file, "graph test {\n");
533
534   fprintf(file, "  graph [overlap=scale]\n");
535
536   fprintf(file, "  node [shape=box, style=filled]\n");
537   fprintf(file,
538           "  node [width=.3, height=.3, style=filled, color=skyblue]\n\n");
539
540   xbt_dynar_foreach(g->nodes, cursor, node) {
541     fprintf(file, "  \"%s\";\n", TRACE_node_name(node));
542   }
543   xbt_dynar_foreach(g->edges, cursor, edge) {
544     const char *src_s = TRACE_node_name (edge->src);
545     const char *dst_s = TRACE_node_name (edge->dst);
546     if (g->directed)
547       fprintf(file, "  \"%s\" -> \"%s\";\n", src_s, dst_s);
548     else
549       fprintf(file, "  \"%s\" -- \"%s\";\n", src_s, dst_s);
550   }
551   fprintf(file, "}\n");
552   fclose(file);
553
554 }
555
556 #endif /* HAVE_TRACING */
557