2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
17 #include <vppinfra/format.h>
18 #include <vlib/vlib.h>
20 #include <vlib/threads.h>
21 #include <vlib/unix/unix.h>
24 format_sched_policy_and_priority (u8 * s, va_list * args)
26 long i = va_arg (*args, long);
27 struct sched_param sched_param;
30 switch (sched_getscheduler (i))
32 #define _(v,f,str) case SCHED_POLICY_##f: t = (u8 *) str; break;
36 if (sched_getparam (i, &sched_param) == 0)
37 return format (s, "%s (%d)", t, sched_param.sched_priority);
39 return format (s, "%s (n/a)", t);
43 show_threads_fn (vlib_main_t * vm,
44 unformat_input_t * input, vlib_cli_command_t * cmd)
46 const vlib_thread_main_t *tm = vlib_get_thread_main ();
47 vlib_worker_thread_t *w;
50 vlib_cli_output (vm, "%-7s%-20s%-12s%-8s%-25s%-7s%-7s%-7s%-10s",
51 "ID", "Name", "Type", "LWP", "Sched Policy (Priority)",
52 "lcore", "Core", "Socket", "State");
54 #if !defined(__powerpc64__)
55 for (i = 0; i < vec_len (vlib_worker_threads); i++)
57 w = vlib_worker_threads + i;
60 line = format (line, "%-7d%-20s%-12s%-8d",
62 w->name ? w->name : (u8 *) "",
63 w->registration ? w->registration->name : "", w->lwp);
65 line = format (line, "%-25U", format_sched_policy_and_priority, w->lwp);
67 int cpu_id = w->cpu_id;
68 if (cpu_id > -1 && tm->main_lcore != ~0)
70 int core_id = w->core_id;
71 int numa_id = w->numa_id;
72 line = format (line, "%-7u%-7u%-7u%", cpu_id, core_id, numa_id);
76 line = format (line, "%-7s%-7s%-7s%", "n/a", "n/a", "n/a");
79 vlib_cli_output (vm, "%v", line);
89 VLIB_CLI_COMMAND (show_threads_command, static) = {
90 .path = "show threads",
91 .short_help = "Show threads",
92 .function = show_threads_fn,
97 * Trigger threads to grab frame queue trace data
100 trace_frame_queue (vlib_main_t * vm, unformat_input_t * input,
101 vlib_cli_command_t * cmd)
103 unformat_input_t _line_input, *line_input = &_line_input;
104 clib_error_t *error = NULL;
105 frame_queue_trace_t *fqt;
106 frame_queue_nelt_counter_t *fqh;
107 vlib_thread_main_t *tm = vlib_get_thread_main ();
108 vlib_frame_queue_main_t *fqm;
112 u32 index = ~(u32) 0;
114 if (!unformat_user (input, unformat_line_input, line_input))
117 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
119 if (unformat (line_input, "on"))
121 else if (unformat (line_input, "off"))
123 else if (unformat (line_input, "index %u", &index))
127 error = clib_error_return (0, "parse error: '%U'",
128 format_unformat_error, line_input);
135 error = clib_error_return (0, "expecting on or off");
139 if (vec_len (tm->frame_queue_mains) == 0)
141 error = clib_error_return (0, "no worker handoffs exist");
145 if (index > vec_len (tm->frame_queue_mains) - 1)
147 error = clib_error_return (0,
148 "expecting valid worker handoff queue index");
152 fqm = vec_elt_at_index (tm->frame_queue_mains, index);
154 num_fq = vec_len (fqm->vlib_frame_queues);
157 vlib_cli_output (vm, "No frame queues exist\n");
161 // Allocate storage for trace if necessary
162 vec_validate_aligned (fqm->frame_queue_traces, num_fq - 1,
163 CLIB_CACHE_LINE_BYTES);
164 vec_validate_aligned (fqm->frame_queue_histogram, num_fq - 1,
165 CLIB_CACHE_LINE_BYTES);
167 for (fqix = 0; fqix < num_fq; fqix++)
169 fqt = &fqm->frame_queue_traces[fqix];
170 fqh = &fqm->frame_queue_histogram[fqix];
172 clib_memset (fqt->n_vectors, 0xff, sizeof (fqt->n_vectors));
174 clib_memset (fqh, 0, sizeof (*fqh));
175 fqm->vlib_frame_queues[fqix]->trace = enable;
179 unformat_free (line_input);
185 VLIB_CLI_COMMAND (cmd_trace_frame_queue,static) = {
186 .path = "trace frame-queue",
187 .short_help = "trace frame-queue (on|off)",
188 .function = trace_frame_queue,
195 * Adding two counters and compute percent of total
196 * Round up, e.g. 0.000001 => 1%
199 compute_percent (u64 * two_counters, u64 total)
207 return (((two_counters[0] + two_counters[1]) * 100) +
208 (total - 1)) / total;
213 * Display frame queue trace data gathered by threads.
215 static clib_error_t *
216 show_frame_queue_internal (vlib_main_t * vm,
217 vlib_frame_queue_main_t * fqm, u32 histogram)
219 clib_error_t *error = NULL;
220 frame_queue_trace_t *fqt;
221 frame_queue_nelt_counter_t *fqh;
225 num_fq = vec_len (fqm->frame_queue_traces);
228 vlib_cli_output (vm, "No trace data for frame queues\n");
234 vlib_cli_output (vm, "0-1 2-3 4-5 6-7 8-9 10-11 12-13 14-15 "
235 "16-17 18-19 20-21 22-23 24-25 26-27 28-29 30-31\n");
238 for (fqix = 0; fqix < num_fq; fqix++)
240 fqt = &(fqm->frame_queue_traces[fqix]);
242 vlib_cli_output (vm, "Thread %d %v\n", fqix,
243 vlib_worker_threads[fqix].name);
245 if (fqt->written == 0)
247 vlib_cli_output (vm, " no trace data\n");
253 fqh = &(fqm->frame_queue_histogram[fqix]);
257 for (nelt = 0; nelt < FRAME_QUEUE_MAX_NELTS; nelt++)
259 total += fqh->count[nelt];
263 * Print in pairs to condense the output.
264 * Allow entries with 0 counts to be clearly identified, by rounding up.
265 * Any non-zero value will be displayed as at least one percent. This
266 * also means the sum of percentages can be > 100, but that is fine. The
267 * histogram is counted from the last time "trace frame on" was issued.
270 "%3d%% %3d%% %3d%% %3d%% %3d%% %3d%% %3d%% %3d%% "
271 "%3d%% %3d%% %3d%% %3d%% %3d%% %3d%% %3d%% %3d%%\n",
272 compute_percent (&fqh->count[0], total),
273 compute_percent (&fqh->count[2], total),
274 compute_percent (&fqh->count[4], total),
275 compute_percent (&fqh->count[6], total),
276 compute_percent (&fqh->count[8], total),
277 compute_percent (&fqh->count[10], total),
278 compute_percent (&fqh->count[12], total),
279 compute_percent (&fqh->count[14], total),
280 compute_percent (&fqh->count[16], total),
281 compute_percent (&fqh->count[18], total),
282 compute_percent (&fqh->count[20], total),
283 compute_percent (&fqh->count[22], total),
284 compute_percent (&fqh->count[24], total),
285 compute_percent (&fqh->count[26], total),
286 compute_percent (&fqh->count[28], total),
287 compute_percent (&fqh->count[30], total));
292 " vector-threshold %d ring size %d in use %d\n",
293 fqt->threshold, fqt->nelts, fqt->n_in_use);
294 vlib_cli_output (vm, " head %12d tail %12d\n", fqt->head,
297 " %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d\n",
298 fqt->n_vectors[0], fqt->n_vectors[1],
299 fqt->n_vectors[2], fqt->n_vectors[3],
300 fqt->n_vectors[4], fqt->n_vectors[5],
301 fqt->n_vectors[6], fqt->n_vectors[7],
302 fqt->n_vectors[8], fqt->n_vectors[9],
303 fqt->n_vectors[10], fqt->n_vectors[11],
304 fqt->n_vectors[12], fqt->n_vectors[13],
305 fqt->n_vectors[14], fqt->n_vectors[15]);
310 " %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d\n",
311 fqt->n_vectors[16], fqt->n_vectors[17],
312 fqt->n_vectors[18], fqt->n_vectors[19],
313 fqt->n_vectors[20], fqt->n_vectors[21],
314 fqt->n_vectors[22], fqt->n_vectors[23],
315 fqt->n_vectors[24], fqt->n_vectors[25],
316 fqt->n_vectors[26], fqt->n_vectors[27],
317 fqt->n_vectors[28], fqt->n_vectors[29],
318 fqt->n_vectors[30], fqt->n_vectors[31]);
326 static clib_error_t *
327 show_frame_queue_trace (vlib_main_t * vm, unformat_input_t * input,
328 vlib_cli_command_t * cmd)
330 vlib_thread_main_t *tm = vlib_get_thread_main ();
331 vlib_frame_queue_main_t *fqm;
334 vec_foreach (fqm, tm->frame_queue_mains)
336 vlib_cli_output (vm, "Worker handoff queue index %u (next node '%U'):",
337 fqm - tm->frame_queue_mains,
338 format_vlib_node_name, vm, fqm->node_index);
339 error = show_frame_queue_internal (vm, fqm, 0);
346 static clib_error_t *
347 show_frame_queue_histogram (vlib_main_t * vm, unformat_input_t * input,
348 vlib_cli_command_t * cmd)
350 vlib_thread_main_t *tm = vlib_get_thread_main ();
351 vlib_frame_queue_main_t *fqm;
354 vec_foreach (fqm, tm->frame_queue_mains)
356 vlib_cli_output (vm, "Worker handoff queue index %u (next node '%U'):",
357 fqm - tm->frame_queue_mains,
358 format_vlib_node_name, vm, fqm->node_index);
359 error = show_frame_queue_internal (vm, fqm, 1);
367 VLIB_CLI_COMMAND (cmd_show_frame_queue_trace,static) = {
368 .path = "show frame-queue",
369 .short_help = "show frame-queue trace",
370 .function = show_frame_queue_trace,
375 VLIB_CLI_COMMAND (cmd_show_frame_queue_histogram,static) = {
376 .path = "show frame-queue histogram",
377 .short_help = "show frame-queue histogram",
378 .function = show_frame_queue_histogram,
384 * Modify the number of elements on the frame_queues
386 static clib_error_t *
387 test_frame_queue_nelts (vlib_main_t * vm, unformat_input_t * input,
388 vlib_cli_command_t * cmd)
390 unformat_input_t _line_input, *line_input = &_line_input;
391 vlib_thread_main_t *tm = vlib_get_thread_main ();
392 vlib_frame_queue_main_t *fqm;
393 clib_error_t *error = NULL;
397 u32 index = ~(u32) 0;
399 if (!unformat_user (input, unformat_line_input, line_input))
402 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
404 if (unformat (line_input, "nelts %u", &nelts))
406 else if (unformat (line_input, "index %u", &index))
410 error = clib_error_return (0, "parse error: '%U'",
411 format_unformat_error, line_input);
416 if (index > vec_len (tm->frame_queue_mains) - 1)
418 error = clib_error_return (0,
419 "expecting valid worker handoff queue index");
423 fqm = vec_elt_at_index (tm->frame_queue_mains, index);
425 if ((nelts != 4) && (nelts != 8) && (nelts != 16) && (nelts != 32))
427 error = clib_error_return (0, "expecting 4,8,16,32");
431 num_fq = vec_len (fqm->vlib_frame_queues);
434 vlib_cli_output (vm, "No frame queues exist\n");
438 for (fqix = 0; fqix < num_fq; fqix++)
440 fqm->vlib_frame_queues[fqix]->nelts = nelts;
444 unformat_free (line_input);
450 VLIB_CLI_COMMAND (cmd_test_frame_queue_nelts,static) = {
451 .path = "test frame-queue nelts",
452 .short_help = "test frame-queue nelts (4,8,16,32)",
453 .function = test_frame_queue_nelts,
459 * Modify the max number of packets pulled off the frame queues
461 static clib_error_t *
462 test_frame_queue_threshold (vlib_main_t * vm, unformat_input_t * input,
463 vlib_cli_command_t * cmd)
465 unformat_input_t _line_input, *line_input = &_line_input;
466 vlib_thread_main_t *tm = vlib_get_thread_main ();
467 vlib_frame_queue_main_t *fqm;
468 clib_error_t *error = NULL;
471 u32 threshold = ~(u32) 0;
472 u32 index = ~(u32) 0;
474 if (!unformat_user (input, unformat_line_input, line_input))
477 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
479 if (unformat (line_input, "threshold %u", &threshold))
481 else if (unformat (line_input, "index %u", &index))
485 error = clib_error_return (0, "parse error: '%U'",
486 format_unformat_error, line_input);
491 if (index > vec_len (tm->frame_queue_mains) - 1)
493 error = clib_error_return (0,
494 "expecting valid worker handoff queue index");
498 fqm = vec_elt_at_index (tm->frame_queue_mains, index);
501 if (threshold == ~(u32) 0)
503 vlib_cli_output (vm, "expecting threshold value\n");
510 num_fq = vec_len (fqm->vlib_frame_queues);
513 vlib_cli_output (vm, "No frame queues exist\n");
517 for (fqix = 0; fqix < num_fq; fqix++)
519 fqm->vlib_frame_queues[fqix]->vector_threshold = threshold;
523 unformat_free (line_input);
529 VLIB_CLI_COMMAND (cmd_test_frame_queue_threshold,static) = {
530 .path = "test frame-queue threshold",
531 .short_help = "test frame-queue threshold N (0=no limit)",
532 .function = test_frame_queue_threshold,
537 * fd.io coding-style-patch-verification: ON
540 * eval: (c-set-style "gnu")