summaryrefslogtreecommitdiffstats
path: root/vlib-api/vlibapi/node_serialize.c
diff options
context:
space:
mode:
authorDave Barach <dave@barachs.net>2016-05-13 12:55:01 -0400
committerDave Barach <dave@barachs.net>2016-05-21 10:04:06 -0400
commit6931f59e54c9643196c0edda20840e49e9eb1da1 (patch)
treeedc1d340cedcc6aca6b4149fbf96f41e65d61661 /vlib-api/vlibapi/node_serialize.c
parent6f7b992f56955b9eee2f9bd6357e2119645e80f7 (diff)
Add per-thread, per-node runtime stats serialization
Change-Id: Ic4009cdbac67b7cd53c88079439496b9d9dfaa35 Signed-off-by: Dave Barach <dave@barachs.net>
Diffstat (limited to 'vlib-api/vlibapi/node_serialize.c')
-rw-r--r--vlib-api/vlibapi/node_serialize.c353
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