From 371e4e19d1db9ed0113d0db7b2f3651e4fce855f Mon Sep 17 00:00:00 2001 From: Dave Barach Date: Fri, 8 Jul 2016 09:38:52 -0400 Subject: fd-io-styleify pass Change-Id: I72d0dff064162d11321257c858f68da1ba79ea48 Signed-off-by: Dave Barach --- vlib-api/vlibapi/node_serialize.c | 469 +++++++++++++++++++------------------- 1 file changed, 239 insertions(+), 230 deletions(-) (limited to 'vlib-api/vlibapi/node_serialize.c') diff --git a/vlib-api/vlibapi/node_serialize.c b/vlib-api/vlibapi/node_serialize.c index 907ed4cd..5eb53026 100644 --- a/vlib-api/vlibapi/node_serialize.c +++ b/vlib-api/vlibapi/node_serialize.c @@ -16,8 +16,8 @@ #include -extern void vl_msg_api_barrier_sync(void); -extern void vl_msg_api_barrier_release(void); +extern void vl_msg_api_barrier_sync (void); +extern void vl_msg_api_barrier_release (void); /* serialized representation of state strings */ @@ -31,68 +31,68 @@ _(STATE_POLLING, "polling") \ _(STATE_INTERRUPT_WAIT, "interrupt wait") \ _(STATE_INTERNAL, "internal") -typedef enum { +typedef enum +{ #define _(a,b) a, foreach_state_string_code #undef _ } state_string_enum_t; -static char *state_strings[] = - { +static char *state_strings[] = { #define _(a,b) b, - foreach_state_string_code + 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) * to recycle a vector / avoid memory allocation, etc. * Switch heaps before/after to serialize into API client shared memory. */ -u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector, - u32 max_threads, int include_nexts, - int include_stats) +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_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; + serialize_main_t _sm, *sm = &_sm; + 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; + 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) + vec_reset_length (node_dups); + + if (vec_len (stat_vms) == 0) { - if (vec_len(vlib_mains) == 0) - vec_add1 (stat_vms, vm); + 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); - } - } + { + 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(); + vl_msg_api_barrier_sync (); for (j = 0; j < threads_to_serialize; j++) { @@ -100,134 +100,135 @@ u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector, 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); - } - } + { + 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); + + vec_add1 (node_dups, nodes); } - vl_msg_api_barrier_release(); - + 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 (stat_vms)); + for (j = 0; j < vec_len (stat_vms); j++) { stat_vm = stat_vms[j]; nodes = node_dups[j]; - serialize_likely_small_unsigned_integer (sm, vec_len(nodes)); + 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); - } + { + 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); } 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; + serialize_main_t _sm, *sm = &_sm; u32 nnodes, nnexts; u32 nstat_vms; - vlib_node_t * node; - vlib_node_t ** nodes; - vlib_node_t *** nodes_by_thread = 0; + vlib_node_t *node; + 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); - + nstat_vms = unserialize_likely_small_unsigned_integer (sm); vec_validate (nodes_by_thread, nstat_vms - 1); @@ -238,85 +239,84 @@ vlib_node_t *** vlib_node_unserialize (u8 * vector) nnodes = unserialize_likely_small_unsigned_integer (sm); nodes = 0; - vec_validate (nodes, nnodes-1); + 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; - } - } + { + 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_by_thread; + return nodes_by_thread; } #if CLIB_DEBUG > 0 static clib_error_t * test_node_serialize_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - 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; + 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, k; - u32 max_threads = (u32) ~0; + u32 max_threads = (u32) ~ 0; int include_nexts = 0; - int include_stats = 0; + int include_stats = 0; - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + 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; + include_stats = 1; else if (unformat (input, "nexts")) - include_nexts = 1; + include_nexts = 1; else - break; + break; } - /* + /* * Keep the number of memcpy ops to a minimum (e.g. 1). * The current size of the serialized vector is * slightly under 4K. @@ -324,65 +324,74 @@ test_node_serialize_command_fn (vlib_main_t * vm, vec_validate (vector, 16383); vec_reset_length (vector); - vector = vlib_node_serialize (nm, vector, max_threads, - include_nexts, include_stats); + vector = vlib_node_serialize (nm, vector, max_threads, + include_nexts, include_stats); - vlib_cli_output (vm, "result vector %d bytes", vec_len(vector)); + vlib_cli_output (vm, "result vector %d bytes", vec_len (vector)); nodes_by_thread = vlib_node_unserialize (vector); vec_free (vector); - - for (i = 0; i < vec_len(nodes_by_thread); i++) + + for (i = 0; i < vec_len (nodes_by_thread); i++) { nodes = nodes_by_thread[i]; vlib_cli_output (vm, "thread %d", i); - for (j = 0; j < vec_len(nodes); j++) - { - 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 (j = 0; j < vec_len(nodes_by_thread); j++) + for (j = 0; j < vec_len (nodes); j++) + { + 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 (j = 0; j < vec_len (nodes_by_thread); j++) { 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); + 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_by_thread); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (test_node_serialize_node, static) = { .path = "test node serialize", .short_help = "test node serialize [max-threads NN] nexts stats", .function = test_node_serialize_command_fn, }; +/* *INDENT-ON* */ #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ -- cgit 1.2.3-korg