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.h"
   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, xbt_dict_t filter)
  69 {
  70   //ignore loopback
  71   if (strcmp(src->name_, "__loopback__") == 0 || strcmp(dst->name_, "__loopback__") == 0) {
  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   if (filter != nullptr){
  83     //check if we already register this pair (we only need one direction)
  84     char aux1[INSTR_DEFAULT_STR_SIZE];
  85     char aux2[INSTR_DEFAULT_STR_SIZE];
  86     snprintf(aux1, INSTR_DEFAULT_STR_SIZE, "%s%s", src->name_, dst->name_);
  87     snprintf(aux2, INSTR_DEFAULT_STR_SIZE, "%s%s", dst->name_, src->name_);
  88     if (xbt_dict_get_or_null (filter, aux1)){
  89       XBT_DEBUG("  linkContainers: already registered %s <-> %s (1)", src->name_, dst->name_);
  90       return;
  91     }
  92     if (xbt_dict_get_or_null (filter, aux2)){
  93       XBT_DEBUG("  linkContainers: already registered %s <-> %s (2)", dst->name_, src->name_);
  94       return;
  95     }
  96
  97     //ok, not found, register it
  98     xbt_dict_set (filter, aux1, xbt_strdup ("1"), nullptr);
  99     xbt_dict_set (filter, aux2, xbt_strdup ("1"), nullptr);
 100   }
 101
 102   //declare type
 103   char link_typename[INSTR_DEFAULT_STR_SIZE];
 104   snprintf(link_typename, INSTR_DEFAULT_STR_SIZE, "%s-%s%s-%s%s", father->type_->name_, src->type_->name_,
 105            src->type_->id_, dst->type_->name_, dst->type_->id_);
 106   simgrid::instr::Type* link_type = father->type_->getChildOrNull(link_typename);
 107   if (link_type == nullptr)
 108     link_type = simgrid::instr::Type::linkNew(link_typename, father->type_, src->type_, dst->type_);
 109
 110   //register EDGE types for triva configuration
 111   trivaEdgeTypes.insert(link_type->name_);
 112
 113   //create the link
 114   static long long counter = 0;
 115
 116   char key[INSTR_DEFAULT_STR_SIZE];
 117   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter);
 118   counter++;
 119
 120   new simgrid::instr::StartLinkEvent(SIMIX_get_clock(), father, link_type, src, "topology", key);
 121   new simgrid::instr::EndLinkEvent(SIMIX_get_clock(), father, link_type, dst, "topology", key);
 122
 123   XBT_DEBUG("  linkContainers %s <-> %s", src->name_, dst->name_);
 124 }
 125
 126 static void recursiveGraphExtraction(simgrid::s4u::NetZone* netzone, container_t container, xbt_dict_t filter)
 127 {
 128   if (not TRACE_platform_topology()) {
 129     XBT_DEBUG("Graph extraction disabled by user.");
 130     return;
 131   }
 132   XBT_DEBUG("Graph extraction for NetZone = %s", netzone->getCname());
 133   if (not netzone->getChildren()->empty()) {
 134     //bottom-up recursion
 135     for (auto const& nz_son : *netzone->getChildren()) {
 136       container_t child_container = static_cast<container_t>(xbt_dict_get(container->children_, nz_son->getCname()));
 137       recursiveGraphExtraction(nz_son, child_container, filter);
 138     }
 139   }
 140
 141   xbt_graph_t graph = xbt_graph_new_graph (0, nullptr);
 142   xbt_dict_t nodes = xbt_dict_new_homogeneous(nullptr);
 143   xbt_dict_t edges = xbt_dict_new_homogeneous(nullptr);
 144   xbt_edge_t edge = nullptr;
 145
 146   xbt_dict_cursor_t cursor = nullptr;
 147   char *edge_name;
 148
 149   static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->getGraph(graph, nodes, edges);
 150   xbt_dict_foreach(edges,cursor,edge_name,edge) {
 151     linkContainers(
 152           PJ_container_get(static_cast<const char*>(edge->src->data)),
 153           PJ_container_get(static_cast<const char*>(edge->dst->data)), filter);
 154   }
 155   xbt_dict_free (&nodes);
 156   xbt_dict_free (&edges);
 157   xbt_graph_free_graph(graph, xbt_free_f, xbt_free_f, nullptr);
 158 }
 159
 160 /*
 161  * Callbacks
 162  */
 163 static void sg_instr_AS_begin(simgrid::s4u::NetZone& netzone)
 164 {
 165   const char* id = netzone.getCname();
 166
 167   if (PJ_container_get_root() == nullptr){
 168     container_t root = new simgrid::instr::Container(id, simgrid::instr::INSTR_AS, nullptr);
 169     PJ_container_set_root (root);
 170
 171     if (TRACE_smpi_is_enabled()) {
 172       simgrid::instr::Type* mpi = root->type_->getChildOrNull("MPI");
 173       if (mpi == nullptr){
 174         mpi = simgrid::instr::Type::containerNew("MPI", root->type_);
 175         if (not TRACE_smpi_is_grouped())
 176           simgrid::instr::Type::stateNew("MPI_STATE", mpi);
 177         simgrid::instr::Type::linkNew("MPI_LINK", PJ_type_get_root(), mpi, mpi);
 178       }
 179     }
 180
 181     if (TRACE_needs_platform()){
 182       currentContainer.push_back(root);
 183     }
 184     return;
 185   }
 186
 187   if (TRACE_needs_platform()){
 188     container_t father = currentContainer.back();
 189     container_t container = new simgrid::instr::Container(id, simgrid::instr::INSTR_AS, father);
 190     currentContainer.push_back(container);
 191   }
 192 }
 193
 194 static void sg_instr_AS_end(simgrid::s4u::NetZone& /*netzone*/)
 195 {
 196   if (TRACE_needs_platform()){
 197     currentContainer.pop_back();
 198   }
 199 }
 200
 201 static void instr_routing_parse_start_link(simgrid::s4u::Link& link)
 202 {
 203   if (currentContainer.empty()) // No ongoing parsing. Are you creating the loopback?
 204     return;
 205   container_t father = currentContainer.back();
 206
 207   double bandwidth_value = link.bandwidth();
 208   double latency_value   = link.latency();
 209
 210   container_t container = new simgrid::instr::Container(link.name(), simgrid::instr::INSTR_LINK, father);
 211
 212   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
 213     simgrid::instr::Type* bandwidth = container->type_->getChildOrNull("bandwidth");
 214     if (bandwidth == nullptr)
 215       bandwidth = simgrid::instr::Type::variableNew("bandwidth", nullptr, container->type_);
 216     simgrid::instr::Type* latency = container->type_->getChildOrNull("latency");
 217     if (latency == nullptr)
 218       latency = simgrid::instr::Type::variableNew("latency", nullptr, container->type_);
 219     new simgrid::instr::SetVariableEvent(0, container, bandwidth, bandwidth_value);
 220     new simgrid::instr::SetVariableEvent(0, container, latency, latency_value);
 221   }
 222   if (TRACE_uncategorized()) {
 223     simgrid::instr::Type* bandwidth_used = container->type_->getChildOrNull("bandwidth_used");
 224     if (bandwidth_used == nullptr)
 225       simgrid::instr::Type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type_);
 226   }
 227 }
 228
 229 static void sg_instr_new_host(simgrid::s4u::Host& host)
 230 {
 231   container_t father = currentContainer.back();
 232   container_t container = new simgrid::instr::Container(host.getCname(), simgrid::instr::INSTR_HOST, father);
 233
 234   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
 235     simgrid::instr::Type* speed = container->type_->getChildOrNull("power");
 236     if (speed == nullptr){
 237       speed = simgrid::instr::Type::variableNew("power", nullptr, container->type_);
 238     }
 239
 240     double current_speed_state = host.getSpeed();
 241     new simgrid::instr::SetVariableEvent(0, container, speed, current_speed_state);
 242   }
 243   if (TRACE_uncategorized()){
 244     simgrid::instr::Type* speed_used = container->type_->getChildOrNull("power_used");
 245     if (speed_used == nullptr){
 246       simgrid::instr::Type::variableNew("power_used", "0.5 0.5 0.5", container->type_);
 247     }
 248   }
 249
 250   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()){
 251     simgrid::instr::Type* mpi = container->type_->getChildOrNull("MPI");
 252     if (mpi == nullptr){
 253       mpi = simgrid::instr::Type::containerNew("MPI", container->type_);
 254       simgrid::instr::Type::stateNew("MPI_STATE", mpi);
 255     }
 256   }
 257
 258   if (TRACE_msg_process_is_enabled()) {
 259     simgrid::instr::Type* msg_process = container->type_->getChildOrNull("MSG_PROCESS");
 260     if (msg_process == nullptr){
 261       msg_process                 = simgrid::instr::Type::containerNew("MSG_PROCESS", container->type_);
 262       simgrid::instr::Type* state = simgrid::instr::Type::stateNew("MSG_PROCESS_STATE", msg_process);
 263       new simgrid::instr::Value("suspend", "1 0 1", state);
 264       simgrid::instr::Value::get_or_new("sleep", "1 1 0", state);
 265       simgrid::instr::Value::get_or_new("receive", "1 0 0", state);
 266       simgrid::instr::Value::get_or_new("send", "0 0 1", state);
 267       simgrid::instr::Value::get_or_new("task_execute", "0 1 1", state);
 268       simgrid::instr::Type::linkNew("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
 269       simgrid::instr::Type::linkNew("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
 270     }
 271   }
 272
 273   if (TRACE_msg_vm_is_enabled()) {
 274     simgrid::instr::Type* msg_vm = container->type_->getChildOrNull("MSG_VM");
 275     if (msg_vm == nullptr){
 276       msg_vm                      = simgrid::instr::Type::containerNew("MSG_VM", container->type_);
 277       simgrid::instr::Type* state = simgrid::instr::Type::stateNew("MSG_VM_STATE", msg_vm);
 278       new simgrid::instr::Value("suspend", "1 0 1", state);
 279       simgrid::instr::Value::get_or_new("sleep", "1 1 0", state);
 280       simgrid::instr::Value::get_or_new("receive", "1 0 0", state);
 281       simgrid::instr::Value::get_or_new("send", "0 0 1", state);
 282       simgrid::instr::Value::get_or_new("task_execute", "0 1 1", state);
 283       simgrid::instr::Type::linkNew("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
 284       simgrid::instr::Type::linkNew("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm);
 285     }
 286   }
 287
 288 }
 289
 290 static void sg_instr_new_router(simgrid::kernel::routing::NetPoint * netpoint)
 291 {
 292   if (not netpoint->isRouter())
 293     return;
 294   if (TRACE_is_enabled() && TRACE_needs_platform()) {
 295     container_t father = currentContainer.back();
 296     new simgrid::instr::Container(netpoint->cname(), simgrid::instr::INSTR_ROUTER, father);
 297   }
 298 }
 299
 300 static void instr_routing_parse_end_platform ()
 301 {
 302   currentContainer.clear();
 303   xbt_dict_t filter = xbt_dict_new_homogeneous(xbt_free_f);
 304   XBT_DEBUG ("Starting graph extraction.");
 305   recursiveGraphExtraction(simgrid::s4u::Engine::getInstance()->getNetRoot(), PJ_container_get_root(), filter);
 306   XBT_DEBUG ("Graph extraction finished.");
 307   xbt_dict_free(&filter);
 308   platform_created = 1;
 309   TRACE_paje_dump_buffer(1);
 310 }
 311
 312 void instr_routing_define_callbacks ()
 313 {
 314   //always need the call backs to ASes (we need only the root AS),
 315   //to create the rootContainer and the rootType properly
 316   if (not TRACE_is_enabled())
 317     return;
 318   if (TRACE_needs_platform()) {
 319     simgrid::s4u::Link::onCreation.connect(instr_routing_parse_start_link);
 320     simgrid::s4u::onPlatformCreated.connect(instr_routing_parse_end_platform);
 321     simgrid::s4u::Host::onCreation.connect(sg_instr_new_host);
 322   }
 323   simgrid::s4u::NetZone::onCreation.connect(sg_instr_AS_begin);
 324   simgrid::s4u::NetZone::onSeal.connect(sg_instr_AS_end);
 325   simgrid::kernel::routing::NetPoint::onCreation.connect(&sg_instr_new_router);
 326 }
 327 /*
 328  * user categories support
 329  */
 330 static void recursiveNewVariableType(const char* new_typename, const char* color, simgrid::instr::Type* root)
 331 {
 332   if (not strcmp(root->name_, "HOST")) {
 333     char tnstr[INSTR_DEFAULT_STR_SIZE];
 334     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
 335     simgrid::instr::Type::variableNew(tnstr, color, root);
 336   }
 337   if (not strcmp(root->name_, "MSG_VM")) {
 338     char tnstr[INSTR_DEFAULT_STR_SIZE];
 339     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
 340     simgrid::instr::Type::variableNew(tnstr, color, root);
 341   }
 342   if (not strcmp(root->name_, "LINK")) {
 343     char tnstr[INSTR_DEFAULT_STR_SIZE];
 344     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "b%s", new_typename);
 345     simgrid::instr::Type::variableNew(tnstr, color, root);
 346   }
 347   xbt_dict_cursor_t cursor = nullptr;
 348   simgrid::instr::Type* child_type;
 349   char *name;
 350   xbt_dict_foreach (root->children_, cursor, name, child_type) {
 351     recursiveNewVariableType (new_typename, color, child_type);
 352   }
 353 }
 354
 355 void instr_new_variable_type (const char *new_typename, const char *color)
 356 {
 357   recursiveNewVariableType (new_typename, color, PJ_type_get_root());
 358 }
 359
 360 static void recursiveNewUserVariableType(const char* father_type, const char* new_typename, const char* color,
 361                                          simgrid::instr::Type* root)
 362 {
 363   if (not strcmp(root->name_, father_type)) {
 364     simgrid::instr::Type::variableNew(new_typename, color, root);
 365   }
 366   xbt_dict_cursor_t cursor = nullptr;
 367   simgrid::instr::Type* child_type;
 368   char *name;
 369   xbt_dict_foreach (root->children_, cursor, name, child_type) {
 370     recursiveNewUserVariableType (father_type, new_typename, color, child_type);
 371   }
 372 }
 373
 374 void instr_new_user_variable_type  (const char *father_type, const char *new_typename, const char *color)
 375 {
 376   recursiveNewUserVariableType (father_type, new_typename, color, PJ_type_get_root());
 377 }
 378
 379 static void recursiveNewUserStateType(const char* father_type, const char* new_typename, simgrid::instr::Type* root)
 380 {
 381   if (not strcmp(root->name_, father_type)) {
 382     simgrid::instr::Type::stateNew(new_typename, root);
 383   }
 384   xbt_dict_cursor_t cursor = nullptr;
 385   simgrid::instr::Type* child_type;
 386   char *name;
 387   xbt_dict_foreach (root->children_, cursor, name, child_type) {
 388     recursiveNewUserStateType (father_type, new_typename, child_type);
 389   }
 390 }
 391
 392 void instr_new_user_state_type (const char *father_type, const char *new_typename)
 393 {
 394   recursiveNewUserStateType (father_type, new_typename, PJ_type_get_root());
 395 }
 396
 397 static void recursiveNewValueForUserStateType(const char* type_name, const char* val, const char* color,
 398                                               simgrid::instr::Type* root)
 399 {
 400   if (not strcmp(root->name_, type_name)) {
 401     new simgrid::instr::Value(val, color, root);
 402   }
 403   xbt_dict_cursor_t cursor = nullptr;
 404   simgrid::instr::Type* child_type;
 405   char *name;
 406   xbt_dict_foreach (root->children_, cursor, name, child_type) {
 407     recursiveNewValueForUserStateType(type_name, val, color, child_type);
 408   }
 409 }
 410
 411 void instr_new_value_for_user_state_type (const char *type_name, const char *value, const char *color)
 412 {
 413   recursiveNewValueForUserStateType (type_name, value, color, PJ_type_get_root());
 414 }
 415
 416 int instr_platform_traced ()
 417 {
 418   return platform_created;
 419 }
 420
 421 #define GRAPHICATOR_SUPPORT_FUNCTIONS
 422
 423 static void recursiveXBTGraphExtraction(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges, sg_netzone_t netzone,
 424                                         container_t container)
 425 {
 426   if (not netzone->getChildren()->empty()) {
 427     //bottom-up recursion
 428     for (auto const& netzone_child : *netzone->getChildren()) {
 429       container_t child_container =
 430           static_cast<container_t>(xbt_dict_get(container->children_, netzone_child->getCname()));
 431       recursiveXBTGraphExtraction(graph, nodes, edges, netzone_child, child_container);
 432     }
 433   }
 434
 435   static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->getGraph(graph, nodes, edges);
 436 }
 437
 438 xbt_graph_t instr_routing_platform_graph ()
 439 {
 440   xbt_graph_t ret = xbt_graph_new_graph (0, nullptr);
 441   xbt_dict_t nodes = xbt_dict_new_homogeneous(nullptr);
 442   xbt_dict_t edges = xbt_dict_new_homogeneous(nullptr);
 443   recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::getInstance()->getNetRoot(),
 444                               PJ_container_get_root());
 445   xbt_dict_free (&nodes);
 446   xbt_dict_free (&edges);
 447   return ret;
 448 }
 449
 450 void instr_routing_platform_graph_export_graphviz (xbt_graph_t g, const char *filename)
 451 {
 452   unsigned int cursor = 0;
 453   xbt_node_t node = nullptr;
 454   xbt_edge_t edge = nullptr;
 455
 456   FILE *file = fopen(filename, "w");
 457   xbt_assert(file, "Failed to open %s \n", filename);
 458
 459   if (g->directed)
 460     fprintf(file, "digraph test {\n");
 461   else
 462     fprintf(file, "graph test {\n");
 463
 464   fprintf(file, "  graph [overlap=scale]\n");
 465
 466   fprintf(file, "  node [shape=box, style=filled]\n");
 467   fprintf(file, "  node [width=.3, height=.3, style=filled, color=skyblue]\n\n");
 468
 469   xbt_dynar_foreach(g->nodes, cursor, node) {
 470     fprintf(file, "  \"%s\";\n", instr_node_name(node));
 471   }
 472   xbt_dynar_foreach(g->edges, cursor, edge) {
 473     const char *src_s = instr_node_name (edge->src);
 474     const char *dst_s = instr_node_name (edge->dst);
 475     if (g->directed)
 476       fprintf(file, "  \"%s\" -> \"%s\";\n", src_s, dst_s);
 477     else
 478       fprintf(file, "  \"%s\" -- \"%s\";\n", src_s, dst_s);
 479   }
 480   fprintf(file, "}\n");
 481   fclose(file);
 482 }