Line data Source code
1 : /*
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:
6 : *
7 : * http://www.apache.org/licenses/LICENSE-2.0
8 : *
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.
14 : */
15 : #define _GNU_SOURCE
16 :
17 : #include <vppinfra/format.h>
18 : #include <vlib/vlib.h>
19 :
20 : #include <vlib/threads.h>
21 : #include <vlib/unix/unix.h>
22 :
23 : static u8 *
24 0 : format_sched_policy_and_priority (u8 * s, va_list * args)
25 : {
26 0 : long i = va_arg (*args, long);
27 : struct sched_param sched_param;
28 0 : u8 *t = 0;
29 :
30 0 : switch (sched_getscheduler (i))
31 : {
32 : #define _(v,f,str) case SCHED_POLICY_##f: t = (u8 *) str; break;
33 0 : foreach_sched_policy
34 : #undef _
35 : }
36 0 : if (sched_getparam (i, &sched_param) == 0)
37 0 : return format (s, "%s (%d)", t, sched_param.sched_priority);
38 : else
39 0 : return format (s, "%s (n/a)", t);
40 : }
41 :
42 : static clib_error_t *
43 0 : show_threads_fn (vlib_main_t * vm,
44 : unformat_input_t * input, vlib_cli_command_t * cmd)
45 : {
46 0 : const vlib_thread_main_t *tm = vlib_get_thread_main ();
47 : vlib_worker_thread_t *w;
48 : int i;
49 :
50 0 : 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");
53 :
54 : #if !defined(__powerpc64__)
55 0 : for (i = 0; i < vec_len (vlib_worker_threads); i++)
56 : {
57 0 : w = vlib_worker_threads + i;
58 0 : u8 *line = NULL;
59 :
60 0 : line = format (line, "%-7d%-20s%-12s%-8d",
61 : i,
62 0 : w->name ? w->name : (u8 *) "",
63 0 : w->registration ? w->registration->name : "", w->lwp);
64 :
65 0 : line = format (line, "%-25U", format_sched_policy_and_priority, w->lwp);
66 :
67 0 : int cpu_id = w->cpu_id;
68 0 : if (cpu_id > -1 && tm->main_lcore != ~0)
69 0 : {
70 0 : int core_id = w->core_id;
71 0 : int numa_id = w->numa_id;
72 0 : line = format (line, "%-7u%-7u%-7u%", cpu_id, core_id, numa_id);
73 : }
74 : else
75 : {
76 0 : line = format (line, "%-7s%-7s%-7s%", "n/a", "n/a", "n/a");
77 : }
78 :
79 0 : vlib_cli_output (vm, "%v", line);
80 0 : vec_free (line);
81 : }
82 : #endif
83 :
84 0 : return 0;
85 : }
86 :
87 :
88 : /* *INDENT-OFF* */
89 285289 : VLIB_CLI_COMMAND (show_threads_command, static) = {
90 : .path = "show threads",
91 : .short_help = "Show threads",
92 : .function = show_threads_fn,
93 : };
94 : /* *INDENT-ON* */
95 :
96 : /*
97 : * Trigger threads to grab frame queue trace data
98 : */
99 : static clib_error_t *
100 0 : trace_frame_queue (vlib_main_t * vm, unformat_input_t * input,
101 : vlib_cli_command_t * cmd)
102 : {
103 0 : unformat_input_t _line_input, *line_input = &_line_input;
104 0 : clib_error_t *error = NULL;
105 : frame_queue_trace_t *fqt;
106 : frame_queue_nelt_counter_t *fqh;
107 0 : vlib_thread_main_t *tm = vlib_get_thread_main ();
108 : vlib_frame_queue_main_t *fqm;
109 : u32 num_fq;
110 : u32 fqix;
111 0 : u32 enable = 2;
112 0 : u32 index = ~(u32) 0;
113 :
114 0 : if (!unformat_user (input, unformat_line_input, line_input))
115 0 : return 0;
116 :
117 0 : while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
118 : {
119 0 : if (unformat (line_input, "on"))
120 0 : enable = 1;
121 0 : else if (unformat (line_input, "off"))
122 0 : enable = 0;
123 0 : else if (unformat (line_input, "index %u", &index))
124 : ;
125 : else
126 : {
127 0 : error = clib_error_return (0, "parse error: '%U'",
128 : format_unformat_error, line_input);
129 0 : goto done;
130 : }
131 : }
132 :
133 0 : if (enable > 1)
134 : {
135 0 : error = clib_error_return (0, "expecting on or off");
136 0 : goto done;
137 : }
138 :
139 0 : if (vec_len (tm->frame_queue_mains) == 0)
140 : {
141 0 : error = clib_error_return (0, "no worker handoffs exist");
142 0 : goto done;
143 : }
144 :
145 0 : if (index > vec_len (tm->frame_queue_mains) - 1)
146 : {
147 0 : error = clib_error_return (0,
148 : "expecting valid worker handoff queue index");
149 0 : goto done;
150 : }
151 :
152 0 : fqm = vec_elt_at_index (tm->frame_queue_mains, index);
153 :
154 0 : num_fq = vec_len (fqm->vlib_frame_queues);
155 0 : if (num_fq == 0)
156 : {
157 0 : vlib_cli_output (vm, "No frame queues exist\n");
158 0 : goto done;
159 : }
160 :
161 : // Allocate storage for trace if necessary
162 0 : vec_validate_aligned (fqm->frame_queue_traces, num_fq - 1,
163 : CLIB_CACHE_LINE_BYTES);
164 0 : vec_validate_aligned (fqm->frame_queue_histogram, num_fq - 1,
165 : CLIB_CACHE_LINE_BYTES);
166 :
167 0 : for (fqix = 0; fqix < num_fq; fqix++)
168 : {
169 0 : fqt = &fqm->frame_queue_traces[fqix];
170 0 : fqh = &fqm->frame_queue_histogram[fqix];
171 :
172 0 : clib_memset (fqt->n_vectors, 0xff, sizeof (fqt->n_vectors));
173 0 : fqt->written = 0;
174 0 : clib_memset (fqh, 0, sizeof (*fqh));
175 0 : fqm->vlib_frame_queues[fqix]->trace = enable;
176 : }
177 :
178 0 : done:
179 0 : unformat_free (line_input);
180 :
181 0 : return error;
182 : }
183 :
184 : /* *INDENT-OFF* */
185 285289 : 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,
189 : .is_mp_safe = 1,
190 : };
191 : /* *INDENT-ON* */
192 :
193 :
194 : /*
195 : * Adding two counters and compute percent of total
196 : * Round up, e.g. 0.000001 => 1%
197 : */
198 : static u32
199 0 : compute_percent (u64 * two_counters, u64 total)
200 : {
201 0 : if (total == 0)
202 : {
203 0 : return 0;
204 : }
205 : else
206 : {
207 0 : return (((two_counters[0] + two_counters[1]) * 100) +
208 0 : (total - 1)) / total;
209 : }
210 : }
211 :
212 : /*
213 : * Display frame queue trace data gathered by threads.
214 : */
215 : static clib_error_t *
216 0 : show_frame_queue_internal (vlib_main_t * vm,
217 : vlib_frame_queue_main_t * fqm, u32 histogram)
218 : {
219 0 : clib_error_t *error = NULL;
220 : frame_queue_trace_t *fqt;
221 : frame_queue_nelt_counter_t *fqh;
222 : u32 num_fq;
223 : u32 fqix;
224 :
225 0 : num_fq = vec_len (fqm->frame_queue_traces);
226 0 : if (num_fq == 0)
227 : {
228 0 : vlib_cli_output (vm, "No trace data for frame queues\n");
229 0 : return error;
230 : }
231 :
232 0 : if (histogram)
233 : {
234 0 : 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");
236 : }
237 :
238 0 : for (fqix = 0; fqix < num_fq; fqix++)
239 : {
240 0 : fqt = &(fqm->frame_queue_traces[fqix]);
241 :
242 0 : vlib_cli_output (vm, "Thread %d %v\n", fqix,
243 0 : vlib_worker_threads[fqix].name);
244 :
245 0 : if (fqt->written == 0)
246 : {
247 0 : vlib_cli_output (vm, " no trace data\n");
248 0 : continue;
249 : }
250 :
251 0 : if (histogram)
252 : {
253 0 : fqh = &(fqm->frame_queue_histogram[fqix]);
254 : u32 nelt;
255 0 : u64 total = 0;
256 :
257 0 : for (nelt = 0; nelt < FRAME_QUEUE_MAX_NELTS; nelt++)
258 : {
259 0 : total += fqh->count[nelt];
260 : }
261 :
262 : /*
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.
268 : */
269 0 : vlib_cli_output (vm,
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));
288 : }
289 : else
290 : {
291 0 : vlib_cli_output (vm,
292 : " vector-threshold %d ring size %d in use %d\n",
293 : fqt->threshold, fqt->nelts, fqt->n_in_use);
294 0 : vlib_cli_output (vm, " head %12d tail %12d\n", fqt->head,
295 : fqt->tail);
296 0 : vlib_cli_output (vm,
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]);
306 :
307 0 : if (fqt->nelts > 16)
308 : {
309 0 : vlib_cli_output (vm,
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]);
319 : }
320 : }
321 :
322 : }
323 0 : return error;
324 : }
325 :
326 : static clib_error_t *
327 0 : show_frame_queue_trace (vlib_main_t * vm, unformat_input_t * input,
328 : vlib_cli_command_t * cmd)
329 : {
330 0 : vlib_thread_main_t *tm = vlib_get_thread_main ();
331 : vlib_frame_queue_main_t *fqm;
332 : clib_error_t *error;
333 :
334 0 : vec_foreach (fqm, tm->frame_queue_mains)
335 : {
336 0 : vlib_cli_output (vm, "Worker handoff queue index %u (next node '%U'):",
337 0 : fqm - tm->frame_queue_mains,
338 : format_vlib_node_name, vm, fqm->node_index);
339 0 : error = show_frame_queue_internal (vm, fqm, 0);
340 0 : if (error)
341 0 : return error;
342 : }
343 0 : return 0;
344 : }
345 :
346 : static clib_error_t *
347 0 : show_frame_queue_histogram (vlib_main_t * vm, unformat_input_t * input,
348 : vlib_cli_command_t * cmd)
349 : {
350 0 : vlib_thread_main_t *tm = vlib_get_thread_main ();
351 : vlib_frame_queue_main_t *fqm;
352 : clib_error_t *error;
353 :
354 0 : vec_foreach (fqm, tm->frame_queue_mains)
355 : {
356 0 : vlib_cli_output (vm, "Worker handoff queue index %u (next node '%U'):",
357 0 : fqm - tm->frame_queue_mains,
358 : format_vlib_node_name, vm, fqm->node_index);
359 0 : error = show_frame_queue_internal (vm, fqm, 1);
360 0 : if (error)
361 0 : return error;
362 : }
363 0 : return 0;
364 : }
365 :
366 : /* *INDENT-OFF* */
367 285289 : 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,
371 : };
372 : /* *INDENT-ON* */
373 :
374 : /* *INDENT-OFF* */
375 285289 : 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,
379 : };
380 : /* *INDENT-ON* */
381 :
382 :
383 : /*
384 : * Modify the number of elements on the frame_queues
385 : */
386 : static clib_error_t *
387 0 : test_frame_queue_nelts (vlib_main_t * vm, unformat_input_t * input,
388 : vlib_cli_command_t * cmd)
389 : {
390 0 : unformat_input_t _line_input, *line_input = &_line_input;
391 0 : vlib_thread_main_t *tm = vlib_get_thread_main ();
392 : vlib_frame_queue_main_t *fqm;
393 0 : clib_error_t *error = NULL;
394 : u32 num_fq;
395 : u32 fqix;
396 0 : u32 nelts = 0;
397 0 : u32 index = ~(u32) 0;
398 :
399 0 : if (!unformat_user (input, unformat_line_input, line_input))
400 0 : return 0;
401 :
402 0 : while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
403 : {
404 0 : if (unformat (line_input, "nelts %u", &nelts))
405 : ;
406 0 : else if (unformat (line_input, "index %u", &index))
407 : ;
408 : else
409 : {
410 0 : error = clib_error_return (0, "parse error: '%U'",
411 : format_unformat_error, line_input);
412 0 : goto done;
413 : }
414 : }
415 :
416 0 : if (index > vec_len (tm->frame_queue_mains) - 1)
417 : {
418 0 : error = clib_error_return (0,
419 : "expecting valid worker handoff queue index");
420 0 : goto done;
421 : }
422 :
423 0 : fqm = vec_elt_at_index (tm->frame_queue_mains, index);
424 :
425 0 : if ((nelts != 4) && (nelts != 8) && (nelts != 16) && (nelts != 32))
426 : {
427 0 : error = clib_error_return (0, "expecting 4,8,16,32");
428 0 : goto done;
429 : }
430 :
431 0 : num_fq = vec_len (fqm->vlib_frame_queues);
432 0 : if (num_fq == 0)
433 : {
434 0 : vlib_cli_output (vm, "No frame queues exist\n");
435 0 : goto done;
436 : }
437 :
438 0 : for (fqix = 0; fqix < num_fq; fqix++)
439 : {
440 0 : fqm->vlib_frame_queues[fqix]->nelts = nelts;
441 : }
442 :
443 0 : done:
444 0 : unformat_free (line_input);
445 :
446 0 : return error;
447 : }
448 :
449 : /* *INDENT-OFF* */
450 285289 : 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,
454 : };
455 : /* *INDENT-ON* */
456 :
457 :
458 : /*
459 : * Modify the max number of packets pulled off the frame queues
460 : */
461 : static clib_error_t *
462 0 : test_frame_queue_threshold (vlib_main_t * vm, unformat_input_t * input,
463 : vlib_cli_command_t * cmd)
464 : {
465 0 : unformat_input_t _line_input, *line_input = &_line_input;
466 0 : vlib_thread_main_t *tm = vlib_get_thread_main ();
467 : vlib_frame_queue_main_t *fqm;
468 0 : clib_error_t *error = NULL;
469 : u32 num_fq;
470 : u32 fqix;
471 0 : u32 threshold = ~(u32) 0;
472 0 : u32 index = ~(u32) 0;
473 :
474 0 : if (!unformat_user (input, unformat_line_input, line_input))
475 0 : return 0;
476 :
477 0 : while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
478 : {
479 0 : if (unformat (line_input, "threshold %u", &threshold))
480 : ;
481 0 : else if (unformat (line_input, "index %u", &index))
482 : ;
483 : else
484 : {
485 0 : error = clib_error_return (0, "parse error: '%U'",
486 : format_unformat_error, line_input);
487 0 : goto done;
488 : }
489 : }
490 :
491 0 : if (index > vec_len (tm->frame_queue_mains) - 1)
492 : {
493 0 : error = clib_error_return (0,
494 : "expecting valid worker handoff queue index");
495 0 : goto done;
496 : }
497 :
498 0 : fqm = vec_elt_at_index (tm->frame_queue_mains, index);
499 :
500 :
501 0 : if (threshold == ~(u32) 0)
502 : {
503 0 : vlib_cli_output (vm, "expecting threshold value\n");
504 0 : goto done;
505 : }
506 :
507 0 : if (threshold == 0)
508 0 : threshold = ~0;
509 :
510 0 : num_fq = vec_len (fqm->vlib_frame_queues);
511 0 : if (num_fq == 0)
512 : {
513 0 : vlib_cli_output (vm, "No frame queues exist\n");
514 0 : goto done;
515 : }
516 :
517 0 : for (fqix = 0; fqix < num_fq; fqix++)
518 : {
519 0 : fqm->vlib_frame_queues[fqix]->vector_threshold = threshold;
520 : }
521 :
522 0 : done:
523 0 : unformat_free (line_input);
524 :
525 0 : return error;
526 : }
527 :
528 : /* *INDENT-OFF* */
529 285289 : 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,
533 : };
534 : /* *INDENT-ON* */
535 :
536 : /*
537 : * fd.io coding-style-patch-verification: ON
538 : *
539 : * Local Variables:
540 : * eval: (c-set-style "gnu")
541 : * End:
542 : */
|
