vlib: graphviz upgrade to allow filters

Possibility to draw only the active nodes on the graph.
These are scaled and colored according to their utilization.

Type: improvement
Signed-off-by: Arthur de Kerhor <arthurdekerhor@gmail.com>
Change-Id: I7ddb7b62b3a141cb03750dca24f044138fcc577f

diff --git a/src/vlib/main.c b/src/vlib/main.c
index 02fdc89..41f74b9 100644 (file)
--- a/src/vlib/main.c
+++ b/src/vlib/main.c
@@ -570,13 +570,11 @@ vlib_put_next_frame (vlib_main_t * vm,
 }
 
 /* Sync up runtime (32 bit counters) and main node stats (64 bit counters). */
-never_inline void
-vlib_node_runtime_sync_stats (vlib_main_t * vm,
-                             vlib_node_runtime_t * r,
-                             uword n_calls, uword n_vectors, uword n_clocks)
+void
+vlib_node_runtime_sync_stats_node (vlib_node_t *n, vlib_node_runtime_t *r,
+                                  uword n_calls, uword n_vectors,
+                                  uword n_clocks)
 {
-  vlib_node_t *n = vlib_get_node (vm, r->node_index);
-
   n->stats_total.calls += n_calls + r->calls_since_last_overflow;
   n->stats_total.vectors += n_vectors + r->vectors_since_last_overflow;
   n->stats_total.clocks += n_clocks + r->clocks_since_last_overflow;
@@ -588,6 +586,14 @@ vlib_node_runtime_sync_stats (vlib_main_t * vm,
   r->clocks_since_last_overflow = 0;
 }
 
+void
+vlib_node_runtime_sync_stats (vlib_main_t *vm, vlib_node_runtime_t *r,
+                             uword n_calls, uword n_vectors, uword n_clocks)
+{
+  vlib_node_t *n = vlib_get_node (vm, r->node_index);
+  vlib_node_runtime_sync_stats_node (n, r, n_calls, n_vectors, n_clocks);
+}
+
 always_inline void __attribute__ ((unused))
 vlib_process_sync_stats (vlib_main_t * vm,
                         vlib_process_t * p,

diff --git a/src/vlib/main.h b/src/vlib/main.h
index 3e3590a..860192c 100644 (file)
--- a/src/vlib/main.h
+++ b/src/vlib/main.h
@@ -450,7 +450,6 @@ extern u8 **vlib_thread_stacks;
 /* Number of thread stacks that the application needs */
 u32 vlib_app_num_thread_stacks_needed (void) __attribute__ ((weak));
 
-extern void vlib_node_sync_stats (vlib_main_t * vm, vlib_node_t * n);
 void vlib_add_del_post_mortem_callback (void *cb, int is_add);
 
 vlib_main_t *vlib_get_main_not_inline (void);

diff --git a/src/vlib/node_cli.c b/src/vlib/node_cli.c
index 1c07805..39fca6e 100644 (file)
--- a/src/vlib/node_cli.c
+++ b/src/vlib/node_cli.c
@@ -42,6 +42,7 @@
 #include <fcntl.h>
 #include <vlib/vlib.h>
 #include <vlib/threads.h>
+#include <math.h>
 
 static int
 node_cmp (void *a1, void *a2)
@@ -97,21 +98,42 @@ show_node_graphviz (vlib_main_t * vm,
 {
   clib_error_t *error = 0;
   vlib_node_main_t *nm = &vm->node_main;
+  vlib_node_t **nodes = nm->nodes;
   u8 *chroot_filename = 0;
   int fd;
-  vlib_node_t **nodes = 0;
-  uword i, j;
+  uword *active = 0;
+  u32 i, j;
+  unformat_input_t _line_input, *line_input = &_line_input;
+  u8 filter = 0, calls_filter = 0, vectors_filter = 0, both = 0;
 
-  if (!unformat_user (input, unformat_vlib_tmpfile, &chroot_filename))
-    {
-      fd = -1;
-    }
-  else
+  fd = -1;
+  /* Get a line of input. */
+  if (unformat_user (input, unformat_line_input, line_input))
     {
-      fd =
-       open ((char *) chroot_filename, O_CREAT | O_TRUNC | O_WRONLY, 0664);
+      while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+       {
+         if (unformat (line_input, "filter"))
+           filter = 1;
+         else if (unformat (line_input, "calls") && filter)
+           calls_filter = 1;
+         else if (unformat (line_input, "vectors") && filter)
+           vectors_filter = 1;
+         else if (unformat (line_input, "file %U", unformat_vlib_tmpfile,
+                            &chroot_filename))
+           {
+             fd = open ((char *) chroot_filename,
+                        O_CREAT | O_TRUNC | O_WRONLY, 0664);
+           }
+         else
+           return clib_error_return (0, "unknown input `%U'",
+                                     format_unformat_error, input);
+       }
+      unformat_free (line_input);
     }
 
+  /*both is set to true if calls_filter and vectors_filter are, or neither */
+  both = filter & (!(calls_filter ^ vectors_filter));
+
 #define format__(vm__, fd__, ...) \
   if ((fd) < 0) \
     { \
@@ -124,45 +146,189 @@ show_node_graphviz (vlib_main_t * vm,
 
   format__ (vm, fd, "%s", "digraph {\n");
 
-  nodes = vec_dup (nm->nodes);
-  vec_sort_with_function (nodes, node_cmp);
+  clib_bitmap_alloc (active, vec_len (nodes));
+  clib_bitmap_set_region (active, 0, 1, vec_len (nodes));
+  if (filter)
+    {
+      /*Adding the legend to the dot file*/
+      format__ (vm, fd, "%s",
+               "  rankdir=\"LR\"\n  nodesep=2\n  subgraph cluster_legend {\n "
+               "   label=\"Legend\"\n    style=\"solid\"\n    labelloc = b\n "
+               "   subgraph cluster_colors {\n      label=\"Packets/Call\"\n "
+               "     style=\"solid\"\n      labelloc = b\n");
+      format__ (vm, fd, "%s",
+               "      0 [label=\"No packet\", fixedsize=true shape=circle "
+               "width=2 fontsize=17]\n"
+               "      1 [label=\"1-32\", fillcolor=1 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      2 [label=\"33-64\", fillcolor=2 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      3 [label=\"65-96\", fillcolor=3 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      4 [label=\"97-128\", fillcolor=4 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      5 [label=\"129-160\", fillcolor=5 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      6 [label=\"161-192\", fillcolor=6 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      7 [label=\"193-224\", fillcolor=7 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n"
+               "      8 [label=\"224+\", fillcolor=8 style=filled "
+               "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
+               "fontsize=17]\n");
+      format__ (vm, fd, "%s",
+               "      0 -> 1 -> 2 -> 3 -> 4 [style=\"invis\",weight =100]\n  "
+               "    5 -> 6 -> 7 -> 8 [style=\"invis\",weight =100]\n    }\n  "
+               "  subgraph cluster_size {\n      label=\"Cycles/Packet\"\n   "
+               "   style=\"solid\"\n      labelloc = b\n");
+      format__ (
+       vm, fd, "%s",
+       "      a[label=\"0\",fixedsize=true shape=circle width=1] \n"
+       "      b[label=\"10\",fixedsize=true shape=circle width=2 "
+       "fontsize=17]\n"
+       "      c[label=\"100\",fixedsize=true shape=circle width=3 "
+       "fontsize=20]\n"
+       "      d[label=\"1000\",fixedsize=true shape=circle width=4 "
+       "fontsize=23]\n"
+       "      a -> b -> c -> d  [style=\"invis\",weight =100]\n    }\n  }\n");
 
-  for (i = 0; i < vec_len (nodes); i++)
+      vlib_worker_thread_barrier_sync (vm);
+      for (j = 0; j < vec_len (nm->nodes); j++)
+       {
+         vlib_node_t *n;
+         n = nm->nodes[j];
+         vlib_node_sync_stats (vm, n);
+       }
+
+      /* Updating the stats for multithreaded use cases.
+       * We need to dup the nodes to sum the stats from all threads.*/
+      nodes = vec_dup (nm->nodes);
+      for (i = 1; i < vec_len (vlib_mains); i++)
+       {
+         vlib_node_main_t *nm_clone;
+         vlib_main_t *vm_clone;
+         vlib_node_runtime_t *rt;
+         vlib_node_t *n;
+
+         vm_clone = vlib_mains[i];
+         nm_clone = &vm_clone->node_main;
+
+         for (j = 0; j < vec_len (nm_clone->nodes); j++)
+           {
+             n = nm_clone->nodes[j];
+
+             rt = vlib_node_get_runtime (vm_clone, n->index);
+             /* Sync the stats directly in the duplicated node.*/
+             vlib_node_runtime_sync_stats_node (nodes[j], rt, 0, 0, 0);
+           }
+       }
+      vlib_worker_thread_barrier_release (vm);
+
+      for (i = 0; i < vec_len (nodes); i++)
+       {
+         u64 p, c, l;
+         c = nodes[i]->stats_total.calls - nodes[i]->stats_last_clear.calls;
+         p =
+           nodes[i]->stats_total.vectors - nodes[i]->stats_last_clear.vectors;
+         l = nodes[i]->stats_total.clocks - nodes[i]->stats_last_clear.clocks;
+
+         if ((both && c > 0 && p > 0) || (calls_filter && c > 0) ||
+             (vectors_filter && p > 0))
+           {
+             format__ (vm, fd, "  \"%v\" [shape=circle", nodes[i]->name);
+             /*Changing the size and the font of nodes that receive packets*/
+             if (p > 0)
+               {
+                 f64 x = (f64) l / (f64) p;
+                 f64 size_ratio = (1 + log10 (x + 1));
+                 format__ (vm, fd, " width=%.2f fontsize=%.2f fixedsize=true",
+                           size_ratio, 11 + 3 * size_ratio);
+                 /*Coloring nodes that are indeed called*/
+                 if (c > 0)
+                   {
+                     u64 color = ((p - 1) / (32 * c)) + 1;
+                     color = clib_min (color, 8);
+                     format__ (
+                       vm, fd,
+                       " fillcolor=%u style=filled colorscheme=ylorrd8",
+                       color);
+                   }
+               }
+             format__ (vm, fd, "]\n");
+           }
+         else
+           {
+             clib_bitmap_set (active, i, 0);
+           }
+       }
+    }
+
+  clib_bitmap_foreach (i, active)
     {
       for (j = 0; j < vec_len (nodes[i]->next_nodes); j++)
        {
-         vlib_node_t *x;
-
          if (nodes[i]->next_nodes[j] == VLIB_INVALID_NODE_INDEX)
            continue;
 
-         x = vec_elt (nm->nodes, nodes[i]->next_nodes[j]);
-         format__ (vm, fd, "  \"%v\" -> \"%v\"\n", nodes[i]->name, x->name);
+         if (!filter || clib_bitmap_get (active, nodes[i]->next_nodes[j]))
+           {
+             format__ (vm, fd, "  \"%v\" -> \"%v\"\n", nodes[i]->name,
+                       nodes[nodes[i]->next_nodes[j]]->name);
+           }
        }
     }
 
-  format__ (vm, fd, "%s", "}");
+  format__ (vm, fd, "}\n");
 
   if (fd >= 0)
     {
-      vlib_cli_output (vm,
-                      "vlib graph dumped into `%s'. Run eg. `fdp -Tsvg -O %s'.",
-                      chroot_filename, chroot_filename);
+      /*Dumping all the nodes saturates dot capacities to render a directed
+       * graph. In this case, prefer using he fdp command to generate an
+       * undirected graph. */
+      const char *soft = filter ? "dot" : "fdp";
+      vlib_cli_output (
+       vm, "vlib graph dumped into `%s'. Run eg. `%s -Tsvg -O %s'.",
+       chroot_filename, soft, chroot_filename);
     }
 
-  vec_free (nodes);
+  clib_bitmap_free (active);
   vec_free (chroot_filename);
-  vec_free (nodes);
+  if (filter)
+    vec_free (nodes);
   if (fd >= 0)
     close (fd);
   return error;
 }
 
+/*?
+ * Dump dot files data to draw a graph of all the nodes.
+ * If the argument 'filter' is provided, only the active nodes (since the last
+ * "clear run" comand) are selected and they are scaled and colored according
+ * to their utilization. You can choose to filter nodes that are called,
+ * nodes that receive vectors or both (default).
+ * The 'file' option allows to save data in a temp file.
+ *
+ * @cliexpar
+ * @clistart
+ * show vlib graphviz
+ * show vlib graphviz filter file tmpfile
+ * show vlib graphviz filter calls file tmpfile
+ * @cliend
+ * @cliexcmd{show vlib graphviz [filter][calls][vectors][file <filename>]}
+?*/
 /* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_node_graphviz_command, static) = {
   .path = "show vlib graphviz",
   .short_help = "Dump packet processing node graph as a graphviz dotfile",
   .function = show_node_graphviz,
+  .is_mp_safe = 1,
 };
 /* *INDENT-ON* */
 

diff --git a/src/vlib/node_funcs.h b/src/vlib/node_funcs.h
index 386e916..d65fd2e 100644 (file)
--- a/src/vlib/node_funcs.h
+++ b/src/vlib/node_funcs.h
@@ -1200,6 +1200,12 @@ void vlib_start_process (vlib_main_t * vm, uword process_index);
 
 /* Sync up runtime and main node stats. */
 void vlib_node_sync_stats (vlib_main_t * vm, vlib_node_t * n);
+void vlib_node_runtime_sync_stats (vlib_main_t *vm, vlib_node_runtime_t *r,
+                                  uword n_calls, uword n_vectors,
+                                  uword n_clocks);
+void vlib_node_runtime_sync_stats_node (vlib_node_t *n, vlib_node_runtime_t *r,
+                                       uword n_calls, uword n_vectors,
+                                       uword n_clocks);
 
 /* Node graph initialization function. */
 clib_error_t *vlib_node_main_init (vlib_main_t * vm);

diff --git a/src/vlib/threads.c b/src/vlib/threads.c
index 48e1bab..dd7de73 100644 (file)
--- a/src/vlib/threads.c
+++ b/src/vlib/threads.c
@@ -998,11 +998,6 @@ worker_thread_node_runtime_update_internal (void)
   vlib_node_main_t *nm, *nm_clone;
   vlib_main_t *vm_clone;
   vlib_node_runtime_t *rt;
-  never_inline void
-    vlib_node_runtime_sync_stats (vlib_main_t * vm,
-                                 vlib_node_runtime_t * r,
-                                 uword n_calls,
-                                 uword n_vectors, uword n_clocks);
 
   ASSERT (vlib_get_thread_index () == 0);