Add per-thread, per-node runtime stats serialization

Change-Id: Ic4009cdbac67b7cd53c88079439496b9d9dfaa35
Signed-off-by: Dave Barach <dave@barachs.net>

1 files changed, 300 insertions, 53 deletions

diff --git a/vlib-api/vlibapi/node_serialize.c b/vlib-api/vlibapi/node_serialize.c
index d4fbd502398..907ed4cdf8b 100644
--- a/vlib-api/vlibapi/node_serialize.c
+++ b/vlib-api/vlibapi/node_serialize.c
@@ -16,6 +16,34 @@
 
 #include <vppinfra/serialize.h>
 
+extern void vl_msg_api_barrier_sync(void);
+extern void vl_msg_api_barrier_release(void);
+
+/* serialized representation of state strings */
+
+#define foreach_state_string_code               \
+_(STATE_DONE, "done")                           \
+_(STATE_DISABLED, "disabled")                   \
+_(STATE_TIME_WAIT, "time wait")                 \
+_(STATE_EVENT_WAIT, "event wait")               \
+_(STATE_ANY_WAIT, "any wait")                   \
+_(STATE_POLLING, "polling")                     \
+_(STATE_INTERRUPT_WAIT, "interrupt wait")       \
+_(STATE_INTERNAL, "internal")
+
+typedef enum {
+#define _(a,b) a,
+  foreach_state_string_code
+#undef _
+} state_string_enum_t;
+
+static char *state_strings[] = 
+  {
+#define _(a,b) b,
+    foreach_state_string_code
+#undef _
+  };
+
 /* 
  * Serialize a vlib_node_main_t. Appends the result to vector.
  * Pass 0 to create a new vector, use vec_reset_length(vector)
@@ -23,64 +51,241 @@
  * Switch heaps before/after to serialize into API client shared memory.
  */
 
-u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector)
+u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
+                          u32 max_threads, int include_nexts, 
+                          int include_stats)
 {
   serialize_main_t _sm, *sm=&_sm;
-  vlib_node_t * node;
-  int i, j;
-  u8 * cstemp = 0;
+  vlib_main_t * vm = vlib_get_main();
+  vlib_node_t * n;
+  static vlib_node_t *** node_dups;
+  vlib_node_t ** nodes;
+  static vlib_main_t ** stat_vms;
+  vlib_main_t *stat_vm;
+  u8 * namep;
+  u32 name_bytes;
+  uword i, j, k;
+  u64 l, v, c, d;
+  state_string_enum_t state_code;
+  u32 threads_to_serialize;
+  
+  vec_reset_length(node_dups);
+
+  if (vec_len(stat_vms) == 0)
+    {
+      if (vec_len(vlib_mains) == 0)
+        vec_add1 (stat_vms, vm);
+      else
+        {
+          for (i = 0; i < vec_len (vlib_mains); i++)
+            {
+              stat_vm = vlib_mains[i];
+              if (stat_vm)
+                vec_add1 (stat_vms, stat_vm);
+            }
+        }
+    }
+
+  threads_to_serialize = clib_min (max_threads, vec_len (stat_vms));
+
+  /* 
+   * Barrier sync across stats scraping.
+   * Otherwise, the counts will be grossly inaccurate.
+   */
+  vl_msg_api_barrier_sync();
+
+  for (j = 0; j < threads_to_serialize; j++)
+    {
+      stat_vm = stat_vms[j];
+      nm = &stat_vm->node_main;
+
+      if (include_stats)
+      {
+          for (i = 0; i < vec_len (nm->nodes); i++)
+          {
+              n = nm->nodes[i];
+              vlib_node_sync_stats (stat_vm, n);
+          }
+      }
+
+      nodes = vec_dup (nm->nodes);
+      
+      vec_add1(node_dups, nodes);
+    }
+  vl_msg_api_barrier_release();
   
   serialize_open_vector (sm, vector);
+
+  serialize_likely_small_unsigned_integer (sm, vec_len(stat_vms));
   
-  serialize_likely_small_unsigned_integer (sm, vec_len(nm->nodes));
-  for (i = 0; i < vec_len (nm->nodes); i++)
+  for (j = 0; j < vec_len (stat_vms); j++)
     {
-      node = nm->nodes[i];
-      vec_reset_length (cstemp);
-      cstemp = vec_dup(node->name);
-      vec_add1(cstemp, 0);
-      serialize_cstring (sm, (char *)cstemp);
-      serialize_likely_small_unsigned_integer (sm, vec_len(node->next_nodes));
-      for (j = 0; j < vec_len (node->next_nodes); j++)
-        serialize_likely_small_unsigned_integer (sm, node->next_nodes[j]);
+      stat_vm = stat_vms[j];
+      nodes = node_dups[j];
+
+      serialize_likely_small_unsigned_integer (sm, vec_len(nodes));
+
+      for (i = 0; i < vec_len (nodes); i++)
+        {
+          n = nodes[i];
+
+          l = n->stats_total.clocks - n->stats_last_clear.clocks;
+          v = n->stats_total.vectors - n->stats_last_clear.vectors;
+          c = n->stats_total.calls - n->stats_last_clear.calls;
+          d = n->stats_total.suspends 
+            - n->stats_last_clear.suspends;
+
+          state_code = STATE_INTERNAL;
+
+          if (n->type == VLIB_NODE_TYPE_PROCESS)
+            {
+              vlib_process_t * p = vlib_get_process_from_node (vm, n);
+
+              switch (p->flags 
+                      & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
+                         | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
+                {
+                default:
+                  if (! (p->flags & VLIB_PROCESS_IS_RUNNING))
+                    state_code = STATE_DONE;
+                  break;
+                      
+                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
+                  state_code = STATE_TIME_WAIT;
+                  break;
+
+                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
+                  state_code = STATE_EVENT_WAIT;
+                  break;
+                      
+                case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
+                      | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
+                  state_code = STATE_ANY_WAIT;
+                  break;
+                }
+            }      
+          else if (n->type != VLIB_NODE_TYPE_INTERNAL)
+            {
+              state_code = STATE_POLLING;
+              if (n->state == VLIB_NODE_STATE_DISABLED)
+                state_code = STATE_DISABLED;
+              else if (n->state == VLIB_NODE_STATE_INTERRUPT)
+                state_code = STATE_INTERRUPT_WAIT;
+            }
+
+          /* See unserialize_cstring */
+          name_bytes = vec_len (n->name);
+          serialize_likely_small_unsigned_integer(sm, name_bytes);
+          namep = serialize_get (sm, name_bytes);
+          memcpy (namep, n->name, name_bytes);
+
+          serialize_likely_small_unsigned_integer (sm, (u64)state_code);
+          serialize_likely_small_unsigned_integer (sm, n->type);
+
+          if (include_nexts)
+            {
+              serialize_likely_small_unsigned_integer 
+                (sm, vec_len(n->next_nodes));
+              for (k = 0; k < vec_len (n->next_nodes); k++)
+                serialize_likely_small_unsigned_integer (sm, n->next_nodes[k]);
+            }
+          else
+            serialize_likely_small_unsigned_integer (sm, 0);
+  
+          if (include_stats)
+            {
+              /* stats present */
+              serialize_likely_small_unsigned_integer (sm, 1);
+              /* total clocks */
+              serialize_integer(sm, l, 8);
+              /* Total calls */
+              serialize_integer(sm, c, 8);
+              /* Total vectors */
+              serialize_integer(sm, v, 8);
+              /* Total suspends */
+              serialize_integer(sm, d, 8);
+            }
+          else /* no stats */
+            serialize_likely_small_unsigned_integer (sm, 0);
+        }
+      vec_free (nodes);
     }
-  vec_free(cstemp);
-    
   return (serialize_close_vector (sm));
 }
 
-vlib_node_t ** vlib_node_unserialize (u8 * vector)
+vlib_node_t *** vlib_node_unserialize (u8 * vector)
 {
   serialize_main_t _sm, *sm=&_sm;
   u32 nnodes, nnexts;
+  u32 nstat_vms;
   vlib_node_t * node;
-  vlib_node_t ** nodes = 0;
-  int i, j;
+  vlib_node_t ** nodes;
+  vlib_node_t *** nodes_by_thread = 0;
+  int i, j, k;
+  u64 l, v, c, d;
+  state_string_enum_t state_code;
+  int stats_present;
 
   serialize_open_vector (sm, vector);
   
-  nnodes = unserialize_likely_small_unsigned_integer (sm);
+  nstat_vms = unserialize_likely_small_unsigned_integer (sm);
 
-  vec_validate (nodes, nnodes-1);
+  vec_validate (nodes_by_thread, nstat_vms - 1);
+  _vec_len (nodes_by_thread) = 0;
 
-  for (i = 0; i < nnodes; i++)
+  for (i = 0; i < nstat_vms; i++)
     {
-      node = 0;
-      vec_validate (node,0);
-      nodes[i] = node;
-      unserialize_cstring (sm, (char **)&node->name);
-
-      nnexts = unserialize_likely_small_unsigned_integer (sm);
-      if (nnexts > 0)
-          vec_validate (node->next_nodes, nnexts-1);
-      for (j = 0; j < vec_len (node->next_nodes); j++)
-        node->next_nodes[j] =
-          unserialize_likely_small_unsigned_integer (sm);
+      nnodes = unserialize_likely_small_unsigned_integer (sm);
+
+      nodes = 0;
+      vec_validate (nodes, nnodes-1);
+      vec_add1 (nodes_by_thread, nodes);
+
+      for (j = 0; j < nnodes; j++)
+        {
+          node = 0;
+          vec_validate (node,0);
+          nodes[j] = node;
+
+          unserialize_cstring (sm, (char **)&(node->name));
+          state_code = unserialize_likely_small_unsigned_integer (sm);
+          node->state_string = (u8 *) state_strings[state_code];
+
+          node->type = 
+            unserialize_likely_small_unsigned_integer (sm);
+          nnexts = unserialize_likely_small_unsigned_integer (sm);
+          if (nnexts > 0)
+            vec_validate (node->next_nodes, nnexts-1);
+          for (k = 0; k < nnexts; k++)
+            node->next_nodes[k] =
+                unserialize_likely_small_unsigned_integer (sm);
+
+          stats_present = unserialize_likely_small_unsigned_integer (sm);
+
+          if (stats_present)
+            {
+              /* total clocks */
+              unserialize_integer (sm, &l, 8);
+              node->stats_total.clocks = l;
+              node->stats_last_clear.clocks = 0;
+              
+              /* Total calls */
+              unserialize_integer (sm, &c, 8);
+              node->stats_total.calls = c;
+              
+              /* Total vectors */
+              unserialize_integer (sm, &v, 8);
+              node->stats_total.vectors = v;
+              
+              /* Total suspends */
+              unserialize_integer (sm, &d, 8);
+              node->stats_total.suspends = d;
+            }
+        }
     }
-  return nodes;    
+  return nodes_by_thread;    
 }
 
-
 #if CLIB_DEBUG > 0
 
 static clib_error_t *
@@ -90,52 +295,94 @@ test_node_serialize_command_fn (vlib_main_t * vm,
 {
   vlib_node_main_t * nm = &vm->node_main;
   u8 * vector = 0;
+  vlib_node_t *** nodes_by_thread;
   vlib_node_t ** nodes;
   vlib_node_t * node;
   vlib_node_t * next_node;
-  int i, j;
+  int i, j, k;
+  u32 max_threads = (u32) ~0;
+  int include_nexts = 0;
+  int include_stats = 0; 
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) 
+    {
+      if (unformat (input, "max-threads %d", &max_threads))
+        ;
+      else if (unformat (input, "stats"))
+        include_stats = 1;
+      else if (unformat (input, "nexts"))
+        include_nexts = 1;
+      else
+        break;
+    }
 
   /* 
    * Keep the number of memcpy ops to a minimum (e.g. 1).
    * The current size of the serialized vector is
    * slightly under 4K.
    */
-  vec_validate (vector, 4095);
+  vec_validate (vector, 16383);
   vec_reset_length (vector);
 
-  vector = vlib_node_serialize (nm, vector);
+  vector = vlib_node_serialize (nm, vector, max_threads, 
+                                include_nexts, include_stats);
+
+  vlib_cli_output (vm, "result vector %d bytes", vec_len(vector));
 
-  nodes = vlib_node_unserialize (vector);
+  nodes_by_thread = vlib_node_unserialize (vector);
 
   vec_free (vector);
   
-  for (i = 0; i < vec_len(nodes); i++) 
+  for (i = 0; i < vec_len(nodes_by_thread); i++) 
     {
-      node = nodes[i];
-      
-      vlib_cli_output (vm, "[%d] %s", i, node->name);
-      for (j = 0; j < vec_len (node->next_nodes); j++)
+      nodes = nodes_by_thread[i];
+
+      vlib_cli_output (vm, "thread %d", i);
+
+      for (j = 0; j < vec_len(nodes); j++)
         {
-          if (node->next_nodes[j] != ~0)
-            next_node = nodes[node->next_nodes[j]];
-          vlib_cli_output (vm, "  [%d] %s", j, next_node->name);
+          node = nodes[j];
+
+          vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
+                           node->state_string);
+
+          vlib_cli_output 
+            (vm, "    clocks %lld calls %lld suspends"
+             " %lld vectors %lld",
+             node->stats_total.clocks,
+             node->stats_total.calls,
+             node->stats_total.suspends,
+             node->stats_total.vectors);
+
+          for (k = 0; k < vec_len (node->next_nodes); k++)
+            {
+              if (node->next_nodes[k] != ~0)
+                next_node = nodes[node->next_nodes[k]];
+              vlib_cli_output (vm, "  [%d] %s", k, next_node->name);
+            }
         }
   }
 
-  for (i = 0; i < vec_len(nodes); i++) 
+  for (j = 0; j < vec_len(nodes_by_thread); j++)
     {
-      vec_free (nodes[i]->name);
-      vec_free (nodes[i]->next_nodes);
-      vec_free (nodes[i]);
+      nodes = nodes_by_thread[j];
+
+      for (i = 0; i < vec_len(nodes); i++) 
+        {
+          vec_free (nodes[i]->name);
+          vec_free (nodes[i]->next_nodes);
+          vec_free (nodes[i]);
+        }
+      vec_free(nodes);
     }
-  vec_free(nodes);
+  vec_free (nodes_by_thread);
 
   return 0;
 }
 
 VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
     .path = "test node serialize",
-    .short_help = "test node serialize",
+    .short_help = "test node serialize [max-threads NN] nexts stats",
     .function = test_node_serialize_command_fn,
 };
 #endif