diff options
Diffstat (limited to 'vlib-api/vlibapi')
| -rw-r--r-- | vlib-api/vlibapi/api.h | 4 | ||||
| -rw-r--r-- | vlib-api/vlibapi/node_serialize.c | 353 |
2 files changed, 303 insertions, 54 deletions
diff --git a/vlib-api/vlibapi/api.h b/vlib-api/vlibapi/api.h index 1f45a05738c..fc2c30cfa0a 100644 --- a/vlib-api/vlibapi/api.h +++ b/vlib-api/vlibapi/api.h @@ -216,7 +216,9 @@ void vl_msg_api_set_first_available_msg_id (u16 first_avail); u16 vl_msg_api_get_msg_ids (char * name, int n); /* node_serialize.c prototypes */ -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); vlib_node_t ** vlib_node_unserialize (u8 * vector); #define VLIB_API_INIT_FUNCTION(x) VLIB_DECLARE_INIT_FUNCTION(x,api_init) 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 |