cpp-ify and simpifly functions used by graphicator

this actually doesn't not need instr at all. Then we can further
simplify the graphicator itself.

diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp
index 963a71e..23f1d74 100644 (file)
--- a/src/instr/instr_interface.cpp
+++ b/src/instr/instr_interface.cpp
@@ -314,7 +314,7 @@ static void instr_user_srcdst_variable(double time, const char *src, const char
  *
  *  The graph topology will have the following properties: all hosts, links and routers of the platform file are mapped
  *  to graph nodes; routes are mapped to edges.
- *  The platform's AS are not represented in the output.
+ *  The platform's zones are not represented in the output.
  *
  *  @param filename The name of the file that will hold the graph.
  *
@@ -322,14 +322,7 @@ static void instr_user_srcdst_variable(double time, const char *src, const char
  */
 int TRACE_platform_graph_export_graphviz (const char *filename)
 {
-  /* returns 1 if successful, 0 otherwise */
-  if (not TRACE_is_enabled())
-    return 0;
-  xbt_graph_t g = instr_routing_platform_graph();
-  if (g == nullptr)
-    return 0;
-  instr_routing_platform_graph_export_graphviz (g, filename);
-  xbt_graph_free_graph(g, xbt_free_f, xbt_free_f, nullptr);
+  simgrid::instr::platform_graph_export_graphviz(filename);
   return 1;
 }
 

diff --git a/src/instr/instr_platform.cpp b/src/instr/instr_platform.cpp
index 0cc9680..f273438 100644 (file)
--- a/src/instr/instr_platform.cpp
+++ b/src/instr/instr_platform.cpp
@@ -20,6 +20,8 @@
 #include "surf/surf.hpp"
 #include "xbt/graph.h"
 
+#include <fstream>
+
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_routing, instr, "Tracing platform hierarchy");
 
 std::string instr_pid(simgrid::s4u::Actor const& proc)
@@ -153,12 +155,127 @@ static void recursiveGraphExtraction(const simgrid::s4u::NetZone* netzone, conta
 }
 
 /*
- * Callbacks
+ * user categories support
  */
+static void recursiveNewVariableType(const std::string& new_typename, const std::string& color,
+                                     simgrid::instr::Type* root)
+{
+  if (root->get_name() == "HOST" || root->get_name() == "VM")
+    root->by_name_or_create(std::string("p") + new_typename, color);
+
+  if (root->get_name() == "LINK")
+    root->by_name_or_create(std::string("b") + new_typename, color);
+
+  for (auto const& elm : root->children_) {
+    recursiveNewVariableType(new_typename, color, elm.second.get());
+  }
+}
+
+void instr_new_variable_type(const std::string& new_typename, const std::string& color)
+{
+  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::get_root()->type_);
+}
+
+static void recursiveNewUserVariableType(const std::string& father_type, const std::string& new_typename,
+                                         const std::string& color, simgrid::instr::Type* root)
+{
+  if (root->get_name() == father_type) {
+    root->by_name_or_create(new_typename, color);
+  }
+  for (auto const& elm : root->children_)
+    recursiveNewUserVariableType(father_type, new_typename, color, elm.second.get());
+}
+
+void instr_new_user_variable_type(const std::string& father_type, const std::string& new_typename,
+                                  const std::string& color)
+{
+  recursiveNewUserVariableType(father_type, new_typename, color, simgrid::instr::Container::get_root()->type_);
+}
+
+static void recursiveNewUserStateType(const std::string& father_type, const std::string& new_typename,
+                                      simgrid::instr::Type* root)
+{
+  if (root->get_name() == father_type)
+    root->by_name_or_create<simgrid::instr::StateType>(new_typename);
+
+  for (auto const& elm : root->children_)
+    recursiveNewUserStateType(father_type, new_typename, elm.second.get());
+}
+
+void instr_new_user_state_type(const std::string& father_type, const std::string& new_typename)
+{
+  recursiveNewUserStateType(father_type, new_typename, simgrid::instr::Container::get_root()->type_);
+}
+
+static void recursiveNewValueForUserStateType(const std::string& type_name, const char* val, const std::string& color,
+                                              simgrid::instr::Type* root)
+{
+  if (root->get_name() == type_name)
+    static_cast<simgrid::instr::StateType*>(root)->add_entity_value(val, color);
+
+  for (auto const& elm : root->children_)
+    recursiveNewValueForUserStateType(type_name, val, color, elm.second.get());
+}
+
+void instr_new_value_for_user_state_type(const std::string& type_name, const char* value, const std::string& color)
+{
+  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::get_root()->type_);
+}
+
+static void recursiveXBTGraphExtraction(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t>* nodes,
+                                        std::map<std::string, xbt_edge_t>* edges, const_sg_netzone_t netzone)
+{
+  // bottom-up recursion
+  for (auto const& netzone_child : netzone->get_children())
+    recursiveXBTGraphExtraction(graph, nodes, edges, netzone_child);
+
+  netzone->get_impl()->get_graph(graph, nodes, edges);
+}
 
 namespace simgrid {
 namespace instr {
 
+void platform_graph_export_graphviz(const std::string& output_filename)
+{
+  xbt_graph_t g                            = xbt_graph_new_graph(0, nullptr);
+  std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>();
+  std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>();
+  recursiveXBTGraphExtraction(g, nodes, edges, s4u::Engine::get_instance()->get_netzone_root());
+
+  std::ofstream fs;
+  fs.open(output_filename, std::ofstream::out);
+  xbt_assert(not fs.fail(), "Failed to open %s", output_filename.c_str());
+
+  if (g->directed)
+    fs << "digraph test {" << std::endl;
+  else
+    fs << "graph test {" << std::endl;
+
+  fs << "  graph [overlap=scale]" << std::endl;
+
+  fs << "  node [shape=box, style=filled]" << std::endl;
+  fs << "  node [width=.3, height=.3, style=filled, color=skyblue]" << std::endl << std::endl;
+
+  for (auto const& elm : *nodes)
+    fs << "  \"" << instr_node_name(elm.second) << "\";" << std::endl;
+
+  for (auto const& elm : *edges) {
+    const char* src_s = instr_node_name(elm.second->src);
+    const char* dst_s = instr_node_name(elm.second->dst);
+    if (g->directed)
+      fs << "  \"" << src_s << "\" -> \"" << dst_s << "\";" << std::endl;
+    else
+      fs << "  \"" << src_s << "\" -- \"" << dst_s << "\";" << std::endl;
+  }
+  fs << "}" << std::endl;
+  fs.close();
+
+  xbt_graph_free_graph(g, xbt_free_f, xbt_free_f, nullptr);
+  delete nodes;
+  delete edges;
+}
+
+/* Callbacks */
 static std::vector<NetZoneContainer*> currentContainer; /* push and pop, used only in creation */
 static void on_netzone_creation(s4u::NetZone const& netzone)
 {
@@ -417,132 +534,3 @@ void define_callbacks()
 }
 } // namespace instr
 } // namespace simgrid
-
-/*
- * user categories support
- */
-static void recursiveNewVariableType(const std::string& new_typename, const std::string& color,
-                                     simgrid::instr::Type* root)
-{
-  if (root->get_name() == "HOST" || root->get_name() == "VM")
-    root->by_name_or_create(std::string("p") + new_typename, color);
-
-  if (root->get_name() == "LINK")
-    root->by_name_or_create(std::string("b") + new_typename, color);
-
-  for (auto const& elm : root->children_) {
-    recursiveNewVariableType(new_typename, color, elm.second.get());
-  }
-}
-
-void instr_new_variable_type(const std::string& new_typename, const std::string& color)
-{
-  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::get_root()->type_);
-}
-
-static void recursiveNewUserVariableType(const std::string& father_type, const std::string& new_typename,
-                                         const std::string& color, simgrid::instr::Type* root)
-{
-  if (root->get_name() == father_type) {
-    root->by_name_or_create(new_typename, color);
-  }
-  for (auto const& elm : root->children_)
-    recursiveNewUserVariableType(father_type, new_typename, color, elm.second.get());
-}
-
-void instr_new_user_variable_type(const std::string& father_type, const std::string& new_typename,
-                                  const std::string& color)
-{
-  recursiveNewUserVariableType(father_type, new_typename, color, simgrid::instr::Container::get_root()->type_);
-}
-
-static void recursiveNewUserStateType(const std::string& father_type, const std::string& new_typename,
-                                      simgrid::instr::Type* root)
-{
-  if (root->get_name() == father_type)
-    root->by_name_or_create<simgrid::instr::StateType>(new_typename);
-
-  for (auto const& elm : root->children_)
-    recursiveNewUserStateType(father_type, new_typename, elm.second.get());
-}
-
-void instr_new_user_state_type(const std::string& father_type, const std::string& new_typename)
-{
-  recursiveNewUserStateType(father_type, new_typename, simgrid::instr::Container::get_root()->type_);
-}
-
-static void recursiveNewValueForUserStateType(const std::string& type_name, const char* val, const std::string& color,
-                                              simgrid::instr::Type* root)
-{
-  if (root->get_name() == type_name)
-    static_cast<simgrid::instr::StateType*>(root)->add_entity_value(val, color);
-
-  for (auto const& elm : root->children_)
-    recursiveNewValueForUserStateType(type_name, val, color, elm.second.get());
-}
-
-void instr_new_value_for_user_state_type(const std::string& type_name, const char* value, const std::string& color)
-{
-  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::get_root()->type_);
-}
-
-static void recursiveXBTGraphExtraction(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t>* nodes,
-                                        std::map<std::string, xbt_edge_t>* edges, const_sg_netzone_t netzone,
-                                        container_t container)
-{
-  if (not netzone->get_children().empty()) {
-    // bottom-up recursion
-    for (auto const& netzone_child : netzone->get_children()) {
-      container_t child_container = container->children_.at(netzone_child->get_name());
-      recursiveXBTGraphExtraction(graph, nodes, edges, netzone_child, child_container);
-    }
-  }
-
-  netzone->get_impl()->get_graph(graph, nodes, edges);
-}
-
-xbt_graph_t instr_routing_platform_graph()
-{
-  xbt_graph_t ret                          = xbt_graph_new_graph(0, nullptr);
-  std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>();
-  std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>();
-  recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::get_instance()->get_netzone_root(),
-                              simgrid::instr::Container::get_root());
-  delete nodes;
-  delete edges;
-  return ret;
-}
-
-void instr_routing_platform_graph_export_graphviz(const s_xbt_graph_t* g, const char* filename)
-{
-  unsigned int cursor = 0;
-  xbt_node_t node     = nullptr;
-  xbt_edge_t edge     = nullptr;
-
-  FILE* file = fopen(filename, "w");
-  xbt_assert(file, "Failed to open %s \n", filename);
-
-  if (g->directed)
-    fprintf(file, "digraph test {\n");
-  else
-    fprintf(file, "graph test {\n");
-
-  fprintf(file, "  graph [overlap=scale]\n");
-
-  fprintf(file, "  node [shape=box, style=filled]\n");
-  fprintf(file, "  node [width=.3, height=.3, style=filled, color=skyblue]\n\n");
-
-  xbt_dynar_foreach (g->nodes, cursor, node) {
-    fprintf(file, "  \"%s\";\n", instr_node_name(node));
-  }
-  xbt_dynar_foreach (g->edges, cursor, edge) {
-    const char* src_s = instr_node_name(edge->src);
-    const char* dst_s = instr_node_name(edge->dst);
-    if (g->directed)
-      fprintf(file, "  \"%s\" -> \"%s\";\n", src_s, dst_s);
-    else
-      fprintf(file, "  \"%s\" -- \"%s\";\n", src_s, dst_s);
-  }
-  fprintf(file, "}\n");
-  fclose(file);
-}

diff --git a/src/instr/instr_private.hpp b/src/instr/instr_private.hpp
index 34317ef..9ed7048 100644 (file)
--- a/src/instr/instr_private.hpp
+++ b/src/instr/instr_private.hpp
@@ -32,6 +32,8 @@ namespace instr {
 void init();
 void define_callbacks();
 
+void platform_graph_export_graphviz(const std::string& output_filename);
+
 void resource_set_utilization(const char* type, const char* name, const char* resource, const std::string& category,
                               double value, double now, double delta);
 
@@ -284,8 +286,5 @@ XBT_PRIVATE void dump_comment_file(const std::string& filename);
 
 XBT_PRIVATE std::string TRACE_get_filename();
 
-/* instr_platform */
-xbt_graph_t instr_routing_platform_graph();
-void instr_routing_platform_graph_export_graphviz(const s_xbt_graph_t* g, const char* filename);
 
 #endif

diff --git a/tools/graphicator/CMakeLists.txt b/tools/graphicator/CMakeLists.txt
index 715e159..100ed73 100644 (file)
--- a/tools/graphicator/CMakeLists.txt
+++ b/tools/graphicator/CMakeLists.txt
@@ -7,9 +7,5 @@ ADD_TESH(graphicator --setenv srcdir=${CMAKE_HOME_DIRECTORY} --setenv bindir=${C
 
 install(TARGETS graphicator DESTINATION ${CMAKE_INSTALL_BINDIR}/)
 
-## Clean generated files
-get_directory_property(extra_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
-set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${extra_clean_files};${CMAKE_CURRENT_BINARY_DIR}/simgrid.trace;")
-
 set(tesh_files  ${tesh_files}  ${CMAKE_CURRENT_SOURCE_DIR}/graphicator.tesh  PARENT_SCOPE)
 set(tools_src   ${tools_src}   ${CMAKE_CURRENT_SOURCE_DIR}/graphicator.cpp   PARENT_SCOPE)

diff --git a/tools/graphicator/graphicator.cpp b/tools/graphicator/graphicator.cpp
index 9d90d2b..6f865d3 100644 (file)
--- a/tools/graphicator/graphicator.cpp
+++ b/tools/graphicator/graphicator.cpp
@@ -6,18 +6,13 @@
 
 #include "simgrid/instr.h"
 #include "simgrid/s4u.hpp"
-#include "xbt/graph.h"
 
 int main(int argc, char** argv)
 {
   simgrid::s4u::Engine e(&argc, argv);
-
   xbt_assert(argc == 3, "Usage: %s <platform_file.xml> <graphviz_file.dot>", argv[0]);
 
   e.load_platform(argv[1]);
-  int status = TRACE_platform_graph_export_graphviz(argv[2]);
-
-  xbt_assert(status != 0, "%s expects --cfg=tracing:yes --cfg=tracing/platform:yes", argv[0]);
-  e.run(); /* useless, except for correctly cleaning memory */
+  TRACE_platform_graph_export_graphviz(argv[2]);
   return 0;
 }

diff --git a/tools/graphicator/graphicator.tesh b/tools/graphicator/graphicator.tesh
index 4a2d5bf..e75a5ff 100644 (file)
--- a/tools/graphicator/graphicator.tesh
+++ b/tools/graphicator/graphicator.tesh
@@ -1,8 +1,6 @@
 #!/usr/bin/env tesh
 
-$ ${bindir:=.}/graphicator ${srcdir:=.}/teshsuite/simdag/platforms/one_cluster.xml --cfg=tracing:yes --cfg=tracing/platform:yes test.dot
-> [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing' to 'yes'
-> [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/platform' to 'yes'
+$ ${bindir:=.}/graphicator ${srcdir:=.}/teshsuite/simdag/platforms/one_cluster.xml test.dot
 
 $ cat test.dot
 > graph test {
@@ -10,44 +8,44 @@ $ cat test.dot
 >   node [shape=box, style=filled]
 >   node [width=.3, height=.3, style=filled, color=skyblue]
 >
->   "bobbob_cluster_router.hamburger.edu";
->   "bob_cluster_backbone";
 >   "bob0.hamburger.edu";
->   "bob_cluster_link_0_UP";
->   "bob_cluster_link_0_DOWN";
 >   "bob2.hamburger.edu";
->   "bob_cluster_link_2_UP";
->   "bob_cluster_link_2_DOWN";
 >   "bob3.hamburger.edu";
->   "bob_cluster_link_3_UP";
->   "bob_cluster_link_3_DOWN";
 >   "bob4.hamburger.edu";
->   "bob_cluster_link_4_UP";
->   "bob_cluster_link_4_DOWN";
 >   "bob6.hamburger.edu";
->   "bob_cluster_link_6_UP";
+>   "bob_cluster_backbone";
+>   "bob_cluster_link_0_DOWN";
+>   "bob_cluster_link_0_UP";
+>   "bob_cluster_link_2_DOWN";
+>   "bob_cluster_link_2_UP";
+>   "bob_cluster_link_3_DOWN";
+>   "bob_cluster_link_3_UP";
+>   "bob_cluster_link_4_DOWN";
+>   "bob_cluster_link_4_UP";
 >   "bob_cluster_link_6_DOWN";
->   "bobbob_cluster_router.hamburger.edu" -- "bob_cluster_backbone";
->   "bob0.hamburger.edu" -- "bob_cluster_link_0_UP";
->   "bob_cluster_link_0_UP" -- "bob_cluster_backbone";
->   "bob0.hamburger.edu" -- "bob_cluster_link_0_DOWN";
+>   "bob_cluster_link_6_UP";
+>   "bobbob_cluster_router.hamburger.edu";
 >   "bob_cluster_link_0_DOWN" -- "bob_cluster_backbone";
->   "bob2.hamburger.edu" -- "bob_cluster_link_2_UP";
->   "bob_cluster_link_2_UP" -- "bob_cluster_backbone";
->   "bob2.hamburger.edu" -- "bob_cluster_link_2_DOWN";
+>   "bob_cluster_link_0_UP" -- "bob_cluster_backbone";
 >   "bob_cluster_link_2_DOWN" -- "bob_cluster_backbone";
->   "bob3.hamburger.edu" -- "bob_cluster_link_3_UP";
->   "bob_cluster_link_3_UP" -- "bob_cluster_backbone";
->   "bob3.hamburger.edu" -- "bob_cluster_link_3_DOWN";
+>   "bob_cluster_link_2_UP" -- "bob_cluster_backbone";
 >   "bob_cluster_link_3_DOWN" -- "bob_cluster_backbone";
->   "bob4.hamburger.edu" -- "bob_cluster_link_4_UP";
->   "bob_cluster_link_4_UP" -- "bob_cluster_backbone";
->   "bob4.hamburger.edu" -- "bob_cluster_link_4_DOWN";
+>   "bob_cluster_link_3_UP" -- "bob_cluster_backbone";
 >   "bob_cluster_link_4_DOWN" -- "bob_cluster_backbone";
->   "bob6.hamburger.edu" -- "bob_cluster_link_6_UP";
+>   "bob_cluster_link_4_UP" -- "bob_cluster_backbone";
+>   "bob_cluster_link_6_DOWN" -- "bob_cluster_backbone";
 >   "bob_cluster_link_6_UP" -- "bob_cluster_backbone";
+>   "bobbob_cluster_router.hamburger.edu" -- "bob_cluster_backbone";
+>   "bob0.hamburger.edu" -- "bob_cluster_link_0_DOWN";
+>   "bob0.hamburger.edu" -- "bob_cluster_link_0_UP";
+>   "bob2.hamburger.edu" -- "bob_cluster_link_2_DOWN";
+>   "bob2.hamburger.edu" -- "bob_cluster_link_2_UP";
+>   "bob3.hamburger.edu" -- "bob_cluster_link_3_DOWN";
+>   "bob3.hamburger.edu" -- "bob_cluster_link_3_UP";
+>   "bob4.hamburger.edu" -- "bob_cluster_link_4_DOWN";
+>   "bob4.hamburger.edu" -- "bob_cluster_link_4_UP";
 >   "bob6.hamburger.edu" -- "bob_cluster_link_6_DOWN";
->   "bob_cluster_link_6_DOWN" -- "bob_cluster_backbone";
+>   "bob6.hamburger.edu" -- "bob_cluster_link_6_UP";
 > }
 
 $ rm -f test.dot