src/vlib/threads_cli.c

   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 format_sched_policy_and_priority (u8 * s, va_list * args)
  25 {
  26   long i = va_arg (*args, long);
  27   struct sched_param sched_param;
  28   u8 *t = 0;
  29
  30   switch (sched_getscheduler (i))
  31     {
  32 #define _(v,f,str) case SCHED_POLICY_##f: t = (u8 *) str; break;
  33       foreach_sched_policy
  34 #undef _
  35     }
  36   if (sched_getparam (i, &sched_param) == 0)
  37     return format (s, "%s (%d)", t, sched_param.sched_priority);
  38   else
  39     return format (s, "%s (n/a)", t);
  40 }
  41
  42 static clib_error_t *
  43 show_threads_fn (vlib_main_t * vm,
  44                  unformat_input_t * input, vlib_cli_command_t * cmd)
  45 {
  46   const vlib_thread_main_t *tm = vlib_get_thread_main ();
  47   vlib_worker_thread_t *w;
  48   int i;
  49
  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");
  53
  54 #if !defined(__powerpc64__)
  55   for (i = 0; i < vec_len (vlib_worker_threads); i++)
  56     {
  57       w = vlib_worker_threads + i;
  58       u8 *line = NULL;
  59
  60       line = format (line, "%-7d%-20s%-12s%-8d",
  61                      i,
  62                      w->name ? w->name : (u8 *) "",
  63                      w->registration ? w->registration->name : "", w->lwp);
  64
  65       line = format (line, "%-25U", format_sched_policy_and_priority, w->lwp);
  66
  67       int cpu_id = w->cpu_id;
  68       if (cpu_id > -1 && tm->main_lcore != ~0)
  69         {
  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);
  73         }
  74       else
  75         {
  76           line = format (line, "%-7s%-7s%-7s%", "n/a", "n/a", "n/a");
  77         }
  78
  79       vlib_cli_output (vm, "%v", line);
  80       vec_free (line);
  81     }
  82 #endif
  83
  84   return 0;
  85 }
  86
  87
  88 /* *INDENT-OFF* */
  89 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 trace_frame_queue (vlib_main_t * vm, unformat_input_t * input,
 101                    vlib_cli_command_t * cmd)
 102 {
 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;
 109   u32 num_fq;
 110   u32 fqix;
 111   u32 enable = 2;
 112   u32 index = ~(u32) 0;
 113
 114   if (!unformat_user (input, unformat_line_input, line_input))
 115     return 0;
 116
 117   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 118     {
 119       if (unformat (line_input, "on"))
 120         enable = 1;
 121       else if (unformat (line_input, "off"))
 122         enable = 0;
 123       else if (unformat (line_input, "index %u", &index))
 124         ;
 125       else
 126         {
 127           error = clib_error_return (0, "parse error: '%U'",
 128                                      format_unformat_error, line_input);
 129           goto done;
 130         }
 131     }
 132
 133   if (enable > 1)
 134     {
 135       error = clib_error_return (0, "expecting on or off");
 136       goto done;
 137     }
 138
 139   if (vec_len (tm->frame_queue_mains) == 0)
 140     {
 141       error = clib_error_return (0, "no worker handoffs exist");
 142       goto done;
 143     }
 144
 145   if (index > vec_len (tm->frame_queue_mains) - 1)
 146     {
 147       error = clib_error_return (0,
 148                                  "expecting valid worker handoff queue index");
 149       goto done;
 150     }
 151
 152   fqm = vec_elt_at_index (tm->frame_queue_mains, index);
 153
 154   num_fq = vec_len (fqm->vlib_frame_queues);
 155   if (num_fq == 0)
 156     {
 157       vlib_cli_output (vm, "No frame queues exist\n");
 158       goto done;
 159     }
 160
 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);
 166
 167   for (fqix = 0; fqix < num_fq; fqix++)
 168     {
 169       fqt = &fqm->frame_queue_traces[fqix];
 170       fqh = &fqm->frame_queue_histogram[fqix];
 171
 172       clib_memset (fqt->n_vectors, 0xff, sizeof (fqt->n_vectors));
 173       fqt->written = 0;
 174       clib_memset (fqh, 0, sizeof (*fqh));
 175       fqm->vlib_frame_queues[fqix]->trace = enable;
 176     }
 177
 178 done:
 179   unformat_free (line_input);
 180
 181   return error;
 182 }
 183
 184 /* *INDENT-OFF* */
 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,
 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 compute_percent (u64 * two_counters, u64 total)
 200 {
 201   if (total == 0)
 202     {
 203       return 0;
 204     }
 205   else
 206     {
 207       return (((two_counters[0] + two_counters[1]) * 100) +
 208               (total - 1)) / total;
 209     }
 210 }
 211
 212 /*
 213  * Display frame queue trace data gathered by threads.
 214  */
 215 static clib_error_t *
 216 show_frame_queue_internal (vlib_main_t * vm,
 217                            vlib_frame_queue_main_t * fqm, u32 histogram)
 218 {
 219   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   num_fq = vec_len (fqm->frame_queue_traces);
 226   if (num_fq == 0)
 227     {
 228       vlib_cli_output (vm, "No trace data for frame queues\n");
 229       return error;
 230     }
 231
 232   if (histogram)
 233     {
 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");
 236     }
 237
 238   for (fqix = 0; fqix < num_fq; fqix++)
 239     {
 240       fqt = &(fqm->frame_queue_traces[fqix]);
 241
 242       vlib_cli_output (vm, "Thread %d %v\n", fqix,
 243                        vlib_worker_threads[fqix].name);
 244
 245       if (fqt->written == 0)
 246         {
 247           vlib_cli_output (vm, "  no trace data\n");
 248           continue;
 249         }
 250
 251       if (histogram)
 252         {
 253           fqh = &(fqm->frame_queue_histogram[fqix]);
 254           u32 nelt;
 255           u64 total = 0;
 256
 257           for (nelt = 0; nelt < FRAME_QUEUE_MAX_NELTS; nelt++)
 258             {
 259               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           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           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           vlib_cli_output (vm, "  head %12d  tail %12d\n", fqt->head,
 295                            fqt->tail);
 296           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           if (fqt->nelts > 16)
 308             {
 309               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   return error;
 324 }
 325
 326 static clib_error_t *
 327 show_frame_queue_trace (vlib_main_t * vm, unformat_input_t * input,
 328                         vlib_cli_command_t * cmd)
 329 {
 330   vlib_thread_main_t *tm = vlib_get_thread_main ();
 331   vlib_frame_queue_main_t *fqm;
 332   clib_error_t *error;
 333
 334   vec_foreach (fqm, tm->frame_queue_mains)
 335   {
 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);
 340     if (error)
 341       return error;
 342   }
 343   return 0;
 344 }
 345
 346 static clib_error_t *
 347 show_frame_queue_histogram (vlib_main_t * vm, unformat_input_t * input,
 348                             vlib_cli_command_t * cmd)
 349 {
 350   vlib_thread_main_t *tm = vlib_get_thread_main ();
 351   vlib_frame_queue_main_t *fqm;
 352   clib_error_t *error;
 353
 354   vec_foreach (fqm, tm->frame_queue_mains)
 355   {
 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);
 360     if (error)
 361       return error;
 362   }
 363   return 0;
 364 }
 365
 366 /* *INDENT-OFF* */
 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,
 371 };
 372 /* *INDENT-ON* */
 373
 374 /* *INDENT-OFF* */
 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,
 379 };
 380 /* *INDENT-ON* */
 381
 382
 383 /*
 384  * Modify the number of elements on the frame_queues
 385  */
 386 static clib_error_t *
 387 test_frame_queue_nelts (vlib_main_t * vm, unformat_input_t * input,
 388                         vlib_cli_command_t * cmd)
 389 {
 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;
 394   u32 num_fq;
 395   u32 fqix;
 396   u32 nelts = 0;
 397   u32 index = ~(u32) 0;
 398
 399   if (!unformat_user (input, unformat_line_input, line_input))
 400     return 0;
 401
 402   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 403     {
 404       if (unformat (line_input, "nelts %u", &nelts))
 405         ;
 406       else if (unformat (line_input, "index %u", &index))
 407         ;
 408       else
 409         {
 410           error = clib_error_return (0, "parse error: '%U'",
 411                                      format_unformat_error, line_input);
 412           goto done;
 413         }
 414     }
 415
 416   if (index > vec_len (tm->frame_queue_mains) - 1)
 417     {
 418       error = clib_error_return (0,
 419                                  "expecting valid worker handoff queue index");
 420       goto done;
 421     }
 422
 423   fqm = vec_elt_at_index (tm->frame_queue_mains, index);
 424
 425   if ((nelts != 4) && (nelts != 8) && (nelts != 16) && (nelts != 32))
 426     {
 427       error = clib_error_return (0, "expecting 4,8,16,32");
 428       goto done;
 429     }
 430
 431   num_fq = vec_len (fqm->vlib_frame_queues);
 432   if (num_fq == 0)
 433     {
 434       vlib_cli_output (vm, "No frame queues exist\n");
 435       goto done;
 436     }
 437
 438   for (fqix = 0; fqix < num_fq; fqix++)
 439     {
 440       fqm->vlib_frame_queues[fqix]->nelts = nelts;
 441     }
 442
 443 done:
 444   unformat_free (line_input);
 445
 446   return error;
 447 }
 448
 449 /* *INDENT-OFF* */
 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,
 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 test_frame_queue_threshold (vlib_main_t * vm, unformat_input_t * input,
 463                             vlib_cli_command_t * cmd)
 464 {
 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;
 469   u32 num_fq;
 470   u32 fqix;
 471   u32 threshold = ~(u32) 0;
 472   u32 index = ~(u32) 0;
 473
 474   if (!unformat_user (input, unformat_line_input, line_input))
 475     return 0;
 476
 477   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 478     {
 479       if (unformat (line_input, "threshold %u", &threshold))
 480         ;
 481       else if (unformat (line_input, "index %u", &index))
 482         ;
 483       else
 484         {
 485           error = clib_error_return (0, "parse error: '%U'",
 486                                      format_unformat_error, line_input);
 487           goto done;
 488         }
 489     }
 490
 491   if (index > vec_len (tm->frame_queue_mains) - 1)
 492     {
 493       error = clib_error_return (0,
 494                                  "expecting valid worker handoff queue index");
 495       goto done;
 496     }
 497
 498   fqm = vec_elt_at_index (tm->frame_queue_mains, index);
 499
 500
 501   if (threshold == ~(u32) 0)
 502     {
 503       vlib_cli_output (vm, "expecting threshold value\n");
 504       goto done;
 505     }
 506
 507   if (threshold == 0)
 508     threshold = ~0;
 509
 510   num_fq = vec_len (fqm->vlib_frame_queues);
 511   if (num_fq == 0)
 512     {
 513       vlib_cli_output (vm, "No frame queues exist\n");
 514       goto done;
 515     }
 516
 517   for (fqix = 0; fqix < num_fq; fqix++)
 518     {
 519       fqm->vlib_frame_queues[fqix]->vector_threshold = threshold;
 520     }
 521
 522 done:
 523   unformat_free (line_input);
 524
 525   return error;
 526 }
 527
 528 /* *INDENT-OFF* */
 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,
 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  */