Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
kill another dict in instr
[simgrid.git] / src / surf / instr_routing.cpp
1 /* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "src/instr/instr_private.hpp"
7
8 #include "simgrid/s4u/Engine.hpp"
9 #include "simgrid/s4u/Host.hpp"
10 #include "src/kernel/routing/NetZoneImpl.hpp"
11 #include "src/kernel/routing/NetPoint.hpp"
12 #include "src/surf/network_interface.hpp"
13 #include "src/surf/xml/platf_private.hpp"
14 #include "surf/surf.h"
15 #include "xbt/graph.h"
16
17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_routing, instr, "Tracing platform hierarchy");
18
19 static int platform_created = 0;            /* indicate whether the platform file has been traced */
20 static std::vector<container_t> currentContainer; /* push and pop, used only in creation */
21
22 static const char *instr_node_name (xbt_node_t node)
23 {
24   void *data = xbt_graph_node_get_data(node);
25   return static_cast<char*>(data);
26 }
27
28 static container_t lowestCommonAncestor (container_t a1, container_t a2)
29 {
30   //this is only an optimization (since most of a1 and a2 share the same parent)
31   if (a1->father_ == a2->father_)
32     return a1->father_;
33
34   //create an array with all ancestors of a1
35   std::vector<container_t> ancestors_a1;
36   container_t p = a1->father_;
37   while (p){
38     ancestors_a1.push_back(p);
39     p = p->father_;
40   }
41
42   //create an array with all ancestors of a2
43   std::vector<container_t> ancestors_a2;
44   p = a2->father_;
45   while (p){
46     ancestors_a2.push_back(p);
47     p = p->father_;
48   }
49
50   //find the lowest ancestor
51   p = nullptr;
52   int i = ancestors_a1.size() - 1;
53   int j = ancestors_a2.size() - 1;
54   while (i >= 0 && j >= 0){
55     container_t a1p = ancestors_a1.at(i);
56     container_t a2p = ancestors_a2.at(j);
57     if (a1p == a2p){
58       p = a1p;
59     }else{
60       break;
61     }
62     i--;
63     j--;
64   }
65   return p;
66 }
67
68 static void linkContainers(container_t src, container_t dst, std::set<std::string>* filter)
69 {
70   //ignore loopback
71   if (src->name_ == "__loopback__" || dst->name_ == "__loopback__") {
72     XBT_DEBUG ("  linkContainers: ignoring loopback link");
73     return;
74   }
75
76   //find common father
77   container_t father = lowestCommonAncestor (src, dst);
78   if (not father) {
79     xbt_die ("common father unknown, this is a tracing problem");
80   }
81
82   // check if we already register this pair (we only need one direction)
83   std::string aux1 = src->name_ + dst->name_;
84   std::string aux2 = dst->name_ + src->name_;
85   if (filter->find(aux1) != filter->end()) {
86     XBT_DEBUG("  linkContainers: already registered %s <-> %s (1)", src->name_.c_str(), dst->name_.c_str());
87     return;
88   }
89   if (filter->find(aux2) != filter->end()) {
90     XBT_DEBUG("  linkContainers: already registered %s <-> %s (2)", dst->name_.c_str(), src->name_.c_str());
91     return;
92   }
93
94   // ok, not found, register it
95   filter->insert(aux1);
96   filter->insert(aux2);
97
98   //declare type
99   char link_typename[INSTR_DEFAULT_STR_SIZE];
100   snprintf(link_typename, INSTR_DEFAULT_STR_SIZE, "%s-%s%s-%s%s", father->type_->name_, src->type_->name_,
101            src->type_->id_, dst->type_->name_, dst->type_->id_);
102   simgrid::instr::Type* link_type = father->type_->getChildOrNull(link_typename);
103   if (link_type == nullptr)
104     link_type = simgrid::instr::Type::linkNew(link_typename, father->type_, src->type_, dst->type_);
105
106   //register EDGE types for triva configuration
107   trivaEdgeTypes.insert(link_type->name_);
108
109   //create the link
110   static long long counter = 0;
111
112   char key[INSTR_DEFAULT_STR_SIZE];
113   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter);
114   counter++;
115
116   new simgrid::instr::StartLinkEvent(SIMIX_get_clock(), father, link_type, src, "topology", key);
117   new simgrid::instr::EndLinkEvent(SIMIX_get_clock(), father, link_type, dst, "topology", key);
118
119   XBT_DEBUG("  linkContainers %s <-> %s", src->name_.c_str(), dst->name_.c_str());
120 }
121
122 static void recursiveGraphExtraction(simgrid::s4u::NetZone* netzone, container_t container,
123                                      std::set<std::string>* filter)
124 {
125   if (not TRACE_platform_topology()) {
126     XBT_DEBUG("Graph extraction disabled by user.");
127     return;
128   }
129   XBT_DEBUG("Graph extraction for NetZone = %s", netzone->getCname());
130   if (not netzone->getChildren()->empty()) {
131     //bottom-up recursion
132     for (auto const& nz_son : *netzone->getChildren()) {
133       container_t child_container = container->children_.at(nz_son->getCname());
134       recursiveGraphExtraction(nz_son, child_container, filter);
135     }
136   }
137
138   xbt_graph_t graph = xbt_graph_new_graph (0, nullptr);
139   xbt_dict_t nodes = xbt_dict_new_homogeneous(nullptr);
140   xbt_dict_t edges = xbt_dict_new_homogeneous(nullptr);
141   xbt_edge_t edge = nullptr;
142
143   xbt_dict_cursor_t cursor = nullptr;
144   char *edge_name;
145
146   static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->getGraph(graph, nodes, edges);
147   xbt_dict_foreach(edges,cursor,edge_name,edge) {
148     linkContainers(simgrid::instr::Container::byName(static_cast<const char*>(edge->src->data)),
149                    simgrid::instr::Container::byName(static_cast<const char*>(edge->dst->data)), filter);
150   }
151   xbt_dict_free (&nodes);
152   xbt_dict_free (&edges);
153   xbt_graph_free_graph(graph, xbt_free_f, xbt_free_f, nullptr);
154 }
155
156 /*
157  * Callbacks
158  */
159 static void sg_instr_AS_begin(simgrid::s4u::NetZone& netzone)
160 {
161   const char* id = netzone.getCname();
162
163   if (PJ_container_get_root() == nullptr){
164     container_t root = new simgrid::instr::Container(id, simgrid::instr::INSTR_AS, nullptr);
165     PJ_container_set_root (root);
166
167     if (TRACE_smpi_is_enabled()) {
168       simgrid::instr::Type* mpi = root->type_->getChildOrNull("MPI");
169       if (mpi == nullptr){
170         mpi = simgrid::instr::Type::containerNew("MPI", root->type_);
171         if (not TRACE_smpi_is_grouped())
172           simgrid::instr::Type::stateNew("MPI_STATE", mpi);
173         simgrid::instr::Type::linkNew("MPI_LINK", PJ_type_get_root(), mpi, mpi);
174       }
175     }
176
177     if (TRACE_needs_platform()){
178       currentContainer.push_back(root);
179     }
180     return;
181   }
182
183   if (TRACE_needs_platform()){
184     container_t father = currentContainer.back();
185     container_t container = new simgrid::instr::Container(id, simgrid::instr::INSTR_AS, father);
186     currentContainer.push_back(container);
187   }
188 }
189
190 static void sg_instr_AS_end(simgrid::s4u::NetZone& /*netzone*/)
191 {
192   if (TRACE_needs_platform()){
193     currentContainer.pop_back();
194   }
195 }
196
197 static void instr_routing_parse_start_link(simgrid::s4u::Link& link)
198 {
199   if (currentContainer.empty()) // No ongoing parsing. Are you creating the loopback?
200     return;
201   container_t father = currentContainer.back();
202
203   double bandwidth_value = link.bandwidth();
204   double latency_value   = link.latency();
205
206   container_t container = new simgrid::instr::Container(link.name(), simgrid::instr::INSTR_LINK, father);
207
208   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
209     simgrid::instr::Type* bandwidth = container->type_->getChildOrNull("bandwidth");
210     if (bandwidth == nullptr)
211       bandwidth                   = simgrid::instr::Type::variableNew("bandwidth", "", container->type_);
212     simgrid::instr::Type* latency = container->type_->getChildOrNull("latency");
213     if (latency == nullptr)
214       latency = simgrid::instr::Type::variableNew("latency", "", container->type_);
215     new simgrid::instr::SetVariableEvent(0, container, bandwidth, bandwidth_value);
216     new simgrid::instr::SetVariableEvent(0, container, latency, latency_value);
217   }
218   if (TRACE_uncategorized()) {
219     simgrid::instr::Type* bandwidth_used = container->type_->getChildOrNull("bandwidth_used");
220     if (bandwidth_used == nullptr)
221       simgrid::instr::Type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type_);
222   }
223 }
224
225 static void sg_instr_new_host(simgrid::s4u::Host& host)
226 {
227   container_t father = currentContainer.back();
228   container_t container = new simgrid::instr::Container(host.getCname(), simgrid::instr::INSTR_HOST, father);
229
230   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
231     simgrid::instr::Type* speed = container->type_->getChildOrNull("power");
232     if (speed == nullptr){
233       speed = simgrid::instr::Type::variableNew("power", "", container->type_);
234     }
235
236     double current_speed_state = host.getSpeed();
237     new simgrid::instr::SetVariableEvent(0, container, speed, current_speed_state);
238   }
239   if (TRACE_uncategorized()){
240     simgrid::instr::Type* speed_used = container->type_->getChildOrNull("power_used");
241     if (speed_used == nullptr){
242       simgrid::instr::Type::variableNew("power_used", "0.5 0.5 0.5", container->type_);
243     }
244   }
245
246   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()){
247     simgrid::instr::Type* mpi = container->type_->getChildOrNull("MPI");
248     if (mpi == nullptr){
249       mpi = simgrid::instr::Type::containerNew("MPI", container->type_);
250       simgrid::instr::Type::stateNew("MPI_STATE", mpi);
251     }
252   }
253
254   if (TRACE_msg_process_is_enabled()) {
255     simgrid::instr::Type* msg_process = container->type_->getChildOrNull("MSG_PROCESS");
256     if (msg_process == nullptr){
257       msg_process                 = simgrid::instr::Type::containerNew("MSG_PROCESS", container->type_);
258       simgrid::instr::Type* state = simgrid::instr::Type::stateNew("MSG_PROCESS_STATE", msg_process);
259       simgrid::instr::Value::byNameOrCreate("suspend", "1 0 1", state);
260       simgrid::instr::Value::byNameOrCreate("sleep", "1 1 0", state);
261       simgrid::instr::Value::byNameOrCreate("receive", "1 0 0", state);
262       simgrid::instr::Value::byNameOrCreate("send", "0 0 1", state);
263       simgrid::instr::Value::byNameOrCreate("task_execute", "0 1 1", state);
264       simgrid::instr::Type::linkNew("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
265       simgrid::instr::Type::linkNew("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
266     }
267   }
268
269   if (TRACE_msg_vm_is_enabled()) {
270     simgrid::instr::Type* msg_vm = container->type_->getChildOrNull("MSG_VM");
271     if (msg_vm == nullptr){
272       msg_vm                      = simgrid::instr::Type::containerNew("MSG_VM", container->type_);
273       simgrid::instr::Type* state = simgrid::instr::Type::stateNew("MSG_VM_STATE", msg_vm);
274       simgrid::instr::Value::byNameOrCreate("suspend", "1 0 1", state);
275       simgrid::instr::Value::byNameOrCreate("sleep", "1 1 0", state);
276       simgrid::instr::Value::byNameOrCreate("receive", "1 0 0", state);
277       simgrid::instr::Value::byNameOrCreate("send", "0 0 1", state);
278       simgrid::instr::Value::byNameOrCreate("task_execute", "0 1 1", state);
279       simgrid::instr::Type::linkNew("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
280       simgrid::instr::Type::linkNew("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm);
281     }
282   }
283 }
284
285 static void sg_instr_new_router(simgrid::kernel::routing::NetPoint * netpoint)
286 {
287   if (not netpoint->isRouter())
288     return;
289   if (TRACE_is_enabled() && TRACE_needs_platform()) {
290     container_t father = currentContainer.back();
291     new simgrid::instr::Container(netpoint->cname(), simgrid::instr::INSTR_ROUTER, father);
292   }
293 }
294
295 static void instr_routing_parse_end_platform ()
296 {
297   currentContainer.clear();
298   std::set<std::string>* filter = new std::set<std::string>;
299   XBT_DEBUG ("Starting graph extraction.");
300   recursiveGraphExtraction(simgrid::s4u::Engine::getInstance()->getNetRoot(), PJ_container_get_root(), filter);
301   XBT_DEBUG ("Graph extraction finished.");
302   delete filter;
303   platform_created = 1;
304   TRACE_paje_dump_buffer(1);
305 }
306
307 void instr_routing_define_callbacks ()
308 {
309   //always need the call backs to ASes (we need only the root AS),
310   //to create the rootContainer and the rootType properly
311   if (not TRACE_is_enabled())
312     return;
313   if (TRACE_needs_platform()) {
314     simgrid::s4u::Link::onCreation.connect(instr_routing_parse_start_link);
315     simgrid::s4u::onPlatformCreated.connect(instr_routing_parse_end_platform);
316     simgrid::s4u::Host::onCreation.connect(sg_instr_new_host);
317   }
318   simgrid::s4u::NetZone::onCreation.connect(sg_instr_AS_begin);
319   simgrid::s4u::NetZone::onSeal.connect(sg_instr_AS_end);
320   simgrid::kernel::routing::NetPoint::onCreation.connect(&sg_instr_new_router);
321 }
322 /*
323  * user categories support
324  */
325 static void recursiveNewVariableType(const char* new_typename, const char* color, simgrid::instr::Type* root)
326 {
327
328   if (not strcmp(root->name_, "HOST")) {
329     char tnstr[INSTR_DEFAULT_STR_SIZE];
330     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
331     simgrid::instr::Type::variableNew(tnstr, color == nullptr ? "" : color, root);
332   }
333   if (not strcmp(root->name_, "MSG_VM")) {
334     char tnstr[INSTR_DEFAULT_STR_SIZE];
335     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
336     simgrid::instr::Type::variableNew(tnstr, color == nullptr ? "" : color, root);
337   }
338   if (not strcmp(root->name_, "LINK")) {
339     char tnstr[INSTR_DEFAULT_STR_SIZE];
340     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "b%s", new_typename);
341     simgrid::instr::Type::variableNew(tnstr, color == nullptr ? "" : color, root);
342   }
343   for (auto elm : root->children_) {
344     recursiveNewVariableType(new_typename, color == nullptr ? "" : color, elm.second);
345   }
346 }
347
348 void instr_new_variable_type (const char *new_typename, const char *color)
349 {
350   recursiveNewVariableType (new_typename, color, PJ_type_get_root());
351 }
352
353 static void recursiveNewUserVariableType(const char* father_type, const char* new_typename, const char* color,
354                                          simgrid::instr::Type* root)
355 {
356   if (not strcmp(root->name_, father_type)) {
357     simgrid::instr::Type::variableNew(new_typename, color == nullptr ? "" : color, root);
358   }
359   for (auto elm : root->children_)
360     recursiveNewUserVariableType(father_type, new_typename, color, elm.second);
361 }
362
363 void instr_new_user_variable_type  (const char *father_type, const char *new_typename, const char *color)
364 {
365   recursiveNewUserVariableType (father_type, new_typename, color, PJ_type_get_root());
366 }
367
368 static void recursiveNewUserStateType(const char* father_type, const char* new_typename, simgrid::instr::Type* root)
369 {
370   if (not strcmp(root->name_, father_type)) {
371     simgrid::instr::Type::stateNew(new_typename, root);
372   }
373   for (auto elm : root->children_)
374     recursiveNewUserStateType(father_type, new_typename, elm.second);
375 }
376
377 void instr_new_user_state_type (const char *father_type, const char *new_typename)
378 {
379   recursiveNewUserStateType (father_type, new_typename, PJ_type_get_root());
380 }
381
382 static void recursiveNewValueForUserStateType(const char* type_name, const char* val, const char* color,
383                                               simgrid::instr::Type* root)
384 {
385   if (not strcmp(root->name_, type_name))
386     simgrid::instr::Value::byNameOrCreate(val, color, root);
387
388   for (auto elm : root->children_)
389     recursiveNewValueForUserStateType(type_name, val, color, elm.second);
390 }
391
392 void instr_new_value_for_user_state_type (const char *type_name, const char *value, const char *color)
393 {
394   recursiveNewValueForUserStateType (type_name, value, color, PJ_type_get_root());
395 }
396
397 int instr_platform_traced ()
398 {
399   return platform_created;
400 }
401
402 #define GRAPHICATOR_SUPPORT_FUNCTIONS
403
404 static void recursiveXBTGraphExtraction(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges, sg_netzone_t netzone,
405                                         container_t container)
406 {
407   if (not netzone->getChildren()->empty()) {
408     //bottom-up recursion
409     for (auto const& netzone_child : *netzone->getChildren()) {
410       container_t child_container = container->children_.at(netzone_child->getCname());
411       recursiveXBTGraphExtraction(graph, nodes, edges, netzone_child, child_container);
412     }
413   }
414
415   static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->getGraph(graph, nodes, edges);
416 }
417
418 xbt_graph_t instr_routing_platform_graph ()
419 {
420   xbt_graph_t ret = xbt_graph_new_graph (0, nullptr);
421   xbt_dict_t nodes = xbt_dict_new_homogeneous(nullptr);
422   xbt_dict_t edges = xbt_dict_new_homogeneous(nullptr);
423   recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::getInstance()->getNetRoot(),
424                               PJ_container_get_root());
425   xbt_dict_free (&nodes);
426   xbt_dict_free (&edges);
427   return ret;
428 }
429
430 void instr_routing_platform_graph_export_graphviz (xbt_graph_t g, const char *filename)
431 {
432   unsigned int cursor = 0;
433   xbt_node_t node = nullptr;
434   xbt_edge_t edge = nullptr;
435
436   FILE *file = fopen(filename, "w");
437   xbt_assert(file, "Failed to open %s \n", filename);
438
439   if (g->directed)
440     fprintf(file, "digraph test {\n");
441   else
442     fprintf(file, "graph test {\n");
443
444   fprintf(file, "  graph [overlap=scale]\n");
445
446   fprintf(file, "  node [shape=box, style=filled]\n");
447   fprintf(file, "  node [width=.3, height=.3, style=filled, color=skyblue]\n\n");
448
449   xbt_dynar_foreach(g->nodes, cursor, node) {
450     fprintf(file, "  \"%s\";\n", instr_node_name(node));
451   }
452   xbt_dynar_foreach(g->edges, cursor, edge) {
453     const char *src_s = instr_node_name (edge->src);
454     const char *dst_s = instr_node_name (edge->dst);
455     if (g->directed)
456       fprintf(file, "  \"%s\" -> \"%s\";\n", src_s, dst_s);
457     else
458       fprintf(file, "  \"%s\" -- \"%s\";\n", src_s, dst_s);
459   }
460   fprintf(file, "}\n");
461   fclose(file);
462 }