~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/stat-display.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 #include <inttypes.h>
  4 #include <linux/string.h>
  5 #include <linux/time64.h>
  6 #include <math.h>
  7 #include "color.h"
  8 #include "counts.h"
  9 #include "evlist.h"
 10 #include "evsel.h"
 11 #include "stat.h"
 12 #include "top.h"
 13 #include "thread_map.h"
 14 #include "cpumap.h"
 15 #include "string2.h"
 16 #include <linux/ctype.h>
 17 #include "cgroup.h"
 18 #include <api/fs/fs.h>
 19 
 20 #define CNTR_NOT_SUPPORTED      "<not supported>"
 21 #define CNTR_NOT_COUNTED        "<not counted>"
 22 
 23 static void print_running(struct perf_stat_config *config,
 24                           u64 run, u64 ena)
 25 {
 26         if (config->csv_output) {
 27                 fprintf(config->output, "%s%" PRIu64 "%s%.2f",
 28                                         config->csv_sep,
 29                                         run,
 30                                         config->csv_sep,
 31                                         ena ? 100.0 * run / ena : 100.0);
 32         } else if (run != ena) {
 33                 fprintf(config->output, "  (%.2f%%)", 100.0 * run / ena);
 34         }
 35 }
 36 
 37 static void print_noise_pct(struct perf_stat_config *config,
 38                             double total, double avg)
 39 {
 40         double pct = rel_stddev_stats(total, avg);
 41 
 42         if (config->csv_output)
 43                 fprintf(config->output, "%s%.2f%%", config->csv_sep, pct);
 44         else if (pct)
 45                 fprintf(config->output, "  ( +-%6.2f%% )", pct);
 46 }
 47 
 48 static void print_noise(struct perf_stat_config *config,
 49                         struct evsel *evsel, double avg)
 50 {
 51         struct perf_stat_evsel *ps;
 52 
 53         if (config->run_count == 1)
 54                 return;
 55 
 56         ps = evsel->stats;
 57         print_noise_pct(config, stddev_stats(&ps->res_stats[0]), avg);
 58 }
 59 
 60 static void print_cgroup(struct perf_stat_config *config, struct evsel *evsel)
 61 {
 62         if (nr_cgroups) {
 63                 const char *cgrp_name = evsel->cgrp ? evsel->cgrp->name  : "";
 64                 fprintf(config->output, "%s%s", config->csv_sep, cgrp_name);
 65         }
 66 }
 67 
 68 
 69 static void aggr_printout(struct perf_stat_config *config,
 70                           struct evsel *evsel, int id, int nr)
 71 {
 72         switch (config->aggr_mode) {
 73         case AGGR_CORE:
 74                 fprintf(config->output, "S%d-D%d-C%*d%s%*d%s",
 75                         cpu_map__id_to_socket(id),
 76                         cpu_map__id_to_die(id),
 77                         config->csv_output ? 0 : -8,
 78                         cpu_map__id_to_cpu(id),
 79                         config->csv_sep,
 80                         config->csv_output ? 0 : 4,
 81                         nr,
 82                         config->csv_sep);
 83                 break;
 84         case AGGR_DIE:
 85                 fprintf(config->output, "S%d-D%*d%s%*d%s",
 86                         cpu_map__id_to_socket(id << 16),
 87                         config->csv_output ? 0 : -8,
 88                         cpu_map__id_to_die(id << 16),
 89                         config->csv_sep,
 90                         config->csv_output ? 0 : 4,
 91                         nr,
 92                         config->csv_sep);
 93                 break;
 94         case AGGR_SOCKET:
 95                 fprintf(config->output, "S%*d%s%*d%s",
 96                         config->csv_output ? 0 : -5,
 97                         id,
 98                         config->csv_sep,
 99                         config->csv_output ? 0 : 4,
100                         nr,
101                         config->csv_sep);
102                         break;
103         case AGGR_NODE:
104                 fprintf(config->output, "N%*d%s%*d%s",
105                         config->csv_output ? 0 : -5,
106                         id,
107                         config->csv_sep,
108                         config->csv_output ? 0 : 4,
109                         nr,
110                         config->csv_sep);
111                         break;
112         case AGGR_NONE:
113                 if (evsel->percore) {
114                         fprintf(config->output, "S%d-D%d-C%*d%s",
115                                 cpu_map__id_to_socket(id),
116                                 cpu_map__id_to_die(id),
117                                 config->csv_output ? 0 : -5,
118                                 cpu_map__id_to_cpu(id), config->csv_sep);
119                 } else {
120                         fprintf(config->output, "CPU%*d%s ",
121                                 config->csv_output ? 0 : -5,
122                                 evsel__cpus(evsel)->map[id],
123                                 config->csv_sep);
124                 }
125                 break;
126         case AGGR_THREAD:
127                 fprintf(config->output, "%*s-%*d%s",
128                         config->csv_output ? 0 : 16,
129                         perf_thread_map__comm(evsel->core.threads, id),
130                         config->csv_output ? 0 : -8,
131                         perf_thread_map__pid(evsel->core.threads, id),
132                         config->csv_sep);
133                 break;
134         case AGGR_GLOBAL:
135         case AGGR_UNSET:
136         default:
137                 break;
138         }
139 }
140 
141 struct outstate {
142         FILE *fh;
143         bool newline;
144         const char *prefix;
145         int  nfields;
146         int  id, nr;
147         struct evsel *evsel;
148 };
149 
150 #define METRIC_LEN  35
151 
152 static void new_line_std(struct perf_stat_config *config __maybe_unused,
153                          void *ctx)
154 {
155         struct outstate *os = ctx;
156 
157         os->newline = true;
158 }
159 
160 static void do_new_line_std(struct perf_stat_config *config,
161                             struct outstate *os)
162 {
163         fputc('\n', os->fh);
164         fputs(os->prefix, os->fh);
165         aggr_printout(config, os->evsel, os->id, os->nr);
166         if (config->aggr_mode == AGGR_NONE)
167                 fprintf(os->fh, "        ");
168         fprintf(os->fh, "                                                 ");
169 }
170 
171 static void print_metric_std(struct perf_stat_config *config,
172                              void *ctx, const char *color, const char *fmt,
173                              const char *unit, double val)
174 {
175         struct outstate *os = ctx;
176         FILE *out = os->fh;
177         int n;
178         bool newline = os->newline;
179 
180         os->newline = false;
181 
182         if (unit == NULL || fmt == NULL) {
183                 fprintf(out, "%-*s", METRIC_LEN, "");
184                 return;
185         }
186 
187         if (newline)
188                 do_new_line_std(config, os);
189 
190         n = fprintf(out, " # ");
191         if (color)
192                 n += color_fprintf(out, color, fmt, val);
193         else
194                 n += fprintf(out, fmt, val);
195         fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
196 }
197 
198 static void new_line_csv(struct perf_stat_config *config, void *ctx)
199 {
200         struct outstate *os = ctx;
201         int i;
202 
203         fputc('\n', os->fh);
204         if (os->prefix)
205                 fprintf(os->fh, "%s%s", os->prefix, config->csv_sep);
206         aggr_printout(config, os->evsel, os->id, os->nr);
207         for (i = 0; i < os->nfields; i++)
208                 fputs(config->csv_sep, os->fh);
209 }
210 
211 static void print_metric_csv(struct perf_stat_config *config __maybe_unused,
212                              void *ctx,
213                              const char *color __maybe_unused,
214                              const char *fmt, const char *unit, double val)
215 {
216         struct outstate *os = ctx;
217         FILE *out = os->fh;
218         char buf[64], *vals, *ends;
219 
220         if (unit == NULL || fmt == NULL) {
221                 fprintf(out, "%s%s", config->csv_sep, config->csv_sep);
222                 return;
223         }
224         snprintf(buf, sizeof(buf), fmt, val);
225         ends = vals = skip_spaces(buf);
226         while (isdigit(*ends) || *ends == '.')
227                 ends++;
228         *ends = 0;
229         fprintf(out, "%s%s%s%s", config->csv_sep, vals, config->csv_sep, skip_spaces(unit));
230 }
231 
232 /* Filter out some columns that don't work well in metrics only mode */
233 
234 static bool valid_only_metric(const char *unit)
235 {
236         if (!unit)
237                 return false;
238         if (strstr(unit, "/sec") ||
239             strstr(unit, "hz") ||
240             strstr(unit, "Hz") ||
241             strstr(unit, "CPUs utilized"))
242                 return false;
243         return true;
244 }
245 
246 static const char *fixunit(char *buf, struct evsel *evsel,
247                            const char *unit)
248 {
249         if (!strncmp(unit, "of all", 6)) {
250                 snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
251                          unit);
252                 return buf;
253         }
254         return unit;
255 }
256 
257 static void print_metric_only(struct perf_stat_config *config,
258                               void *ctx, const char *color, const char *fmt,
259                               const char *unit, double val)
260 {
261         struct outstate *os = ctx;
262         FILE *out = os->fh;
263         char buf[1024], str[1024];
264         unsigned mlen = config->metric_only_len;
265 
266         if (!valid_only_metric(unit))
267                 return;
268         unit = fixunit(buf, os->evsel, unit);
269         if (mlen < strlen(unit))
270                 mlen = strlen(unit) + 1;
271 
272         if (color)
273                 mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
274 
275         color_snprintf(str, sizeof(str), color ?: "", fmt, val);
276         fprintf(out, "%*s ", mlen, str);
277 }
278 
279 static void print_metric_only_csv(struct perf_stat_config *config __maybe_unused,
280                                   void *ctx, const char *color __maybe_unused,
281                                   const char *fmt,
282                                   const char *unit, double val)
283 {
284         struct outstate *os = ctx;
285         FILE *out = os->fh;
286         char buf[64], *vals, *ends;
287         char tbuf[1024];
288 
289         if (!valid_only_metric(unit))
290                 return;
291         unit = fixunit(tbuf, os->evsel, unit);
292         snprintf(buf, sizeof buf, fmt, val);
293         ends = vals = skip_spaces(buf);
294         while (isdigit(*ends) || *ends == '.')
295                 ends++;
296         *ends = 0;
297         fprintf(out, "%s%s", vals, config->csv_sep);
298 }
299 
300 static void new_line_metric(struct perf_stat_config *config __maybe_unused,
301                             void *ctx __maybe_unused)
302 {
303 }
304 
305 static void print_metric_header(struct perf_stat_config *config,
306                                 void *ctx, const char *color __maybe_unused,
307                                 const char *fmt __maybe_unused,
308                                 const char *unit, double val __maybe_unused)
309 {
310         struct outstate *os = ctx;
311         char tbuf[1024];
312 
313         if (!valid_only_metric(unit))
314                 return;
315         unit = fixunit(tbuf, os->evsel, unit);
316         if (config->csv_output)
317                 fprintf(os->fh, "%s%s", unit, config->csv_sep);
318         else
319                 fprintf(os->fh, "%*s ", config->metric_only_len, unit);
320 }
321 
322 static int first_shadow_cpu(struct perf_stat_config *config,
323                             struct evsel *evsel, int id)
324 {
325         struct evlist *evlist = evsel->evlist;
326         int i;
327 
328         if (!config->aggr_get_id)
329                 return 0;
330 
331         if (config->aggr_mode == AGGR_NONE)
332                 return id;
333 
334         if (config->aggr_mode == AGGR_GLOBAL)
335                 return 0;
336 
337         for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
338                 int cpu2 = evsel__cpus(evsel)->map[i];
339 
340                 if (config->aggr_get_id(config, evlist->core.cpus, cpu2) == id)
341                         return cpu2;
342         }
343         return 0;
344 }
345 
346 static void abs_printout(struct perf_stat_config *config,
347                          int id, int nr, struct evsel *evsel, double avg)
348 {
349         FILE *output = config->output;
350         double sc =  evsel->scale;
351         const char *fmt;
352 
353         if (config->csv_output) {
354                 fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
355         } else {
356                 if (config->big_num)
357                         fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
358                 else
359                         fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
360         }
361 
362         aggr_printout(config, evsel, id, nr);
363 
364         fprintf(output, fmt, avg, config->csv_sep);
365 
366         if (evsel->unit)
367                 fprintf(output, "%-*s%s",
368                         config->csv_output ? 0 : config->unit_width,
369                         evsel->unit, config->csv_sep);
370 
371         fprintf(output, "%-*s", config->csv_output ? 0 : 25, perf_evsel__name(evsel));
372 
373         print_cgroup(config, evsel);
374 }
375 
376 static bool is_mixed_hw_group(struct evsel *counter)
377 {
378         struct evlist *evlist = counter->evlist;
379         u32 pmu_type = counter->core.attr.type;
380         struct evsel *pos;
381 
382         if (counter->core.nr_members < 2)
383                 return false;
384 
385         evlist__for_each_entry(evlist, pos) {
386                 /* software events can be part of any hardware group */
387                 if (pos->core.attr.type == PERF_TYPE_SOFTWARE)
388                         continue;
389                 if (pmu_type == PERF_TYPE_SOFTWARE) {
390                         pmu_type = pos->core.attr.type;
391                         continue;
392                 }
393                 if (pmu_type != pos->core.attr.type)
394                         return true;
395         }
396 
397         return false;
398 }
399 
400 static void printout(struct perf_stat_config *config, int id, int nr,
401                      struct evsel *counter, double uval,
402                      char *prefix, u64 run, u64 ena, double noise,
403                      struct runtime_stat *st)
404 {
405         struct perf_stat_output_ctx out;
406         struct outstate os = {
407                 .fh = config->output,
408                 .prefix = prefix ? prefix : "",
409                 .id = id,
410                 .nr = nr,
411                 .evsel = counter,
412         };
413         print_metric_t pm = print_metric_std;
414         new_line_t nl;
415 
416         if (config->metric_only) {
417                 nl = new_line_metric;
418                 if (config->csv_output)
419                         pm = print_metric_only_csv;
420                 else
421                         pm = print_metric_only;
422         } else
423                 nl = new_line_std;
424 
425         if (config->csv_output && !config->metric_only) {
426                 static int aggr_fields[] = {
427                         [AGGR_GLOBAL] = 0,
428                         [AGGR_THREAD] = 1,
429                         [AGGR_NONE] = 1,
430                         [AGGR_SOCKET] = 2,
431                         [AGGR_DIE] = 2,
432                         [AGGR_CORE] = 2,
433                 };
434 
435                 pm = print_metric_csv;
436                 nl = new_line_csv;
437                 os.nfields = 3;
438                 os.nfields += aggr_fields[config->aggr_mode];
439                 if (counter->cgrp)
440                         os.nfields++;
441         }
442         if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
443                 if (config->metric_only) {
444                         pm(config, &os, NULL, "", "", 0);
445                         return;
446                 }
447                 aggr_printout(config, counter, id, nr);
448 
449                 fprintf(config->output, "%*s%s",
450                         config->csv_output ? 0 : 18,
451                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
452                         config->csv_sep);
453 
454                 if (counter->supported) {
455                         config->print_free_counters_hint = 1;
456                         if (is_mixed_hw_group(counter))
457                                 config->print_mixed_hw_group_error = 1;
458                 }
459 
460                 fprintf(config->output, "%-*s%s",
461                         config->csv_output ? 0 : config->unit_width,
462                         counter->unit, config->csv_sep);
463 
464                 fprintf(config->output, "%*s",
465                         config->csv_output ? 0 : -25,
466                         perf_evsel__name(counter));
467 
468                 print_cgroup(config, counter);
469 
470                 if (!config->csv_output)
471                         pm(config, &os, NULL, NULL, "", 0);
472                 print_noise(config, counter, noise);
473                 print_running(config, run, ena);
474                 if (config->csv_output)
475                         pm(config, &os, NULL, NULL, "", 0);
476                 return;
477         }
478 
479         if (!config->metric_only)
480                 abs_printout(config, id, nr, counter, uval);
481 
482         out.print_metric = pm;
483         out.new_line = nl;
484         out.ctx = &os;
485         out.force_header = false;
486 
487         if (config->csv_output && !config->metric_only) {
488                 print_noise(config, counter, noise);
489                 print_running(config, run, ena);
490         }
491 
492         perf_stat__print_shadow_stats(config, counter, uval,
493                                 first_shadow_cpu(config, counter, id),
494                                 &out, &config->metric_events, st);
495         if (!config->csv_output && !config->metric_only) {
496                 print_noise(config, counter, noise);
497                 print_running(config, run, ena);
498         }
499 }
500 
501 static void aggr_update_shadow(struct perf_stat_config *config,
502                                struct evlist *evlist)
503 {
504         int cpu, s2, id, s;
505         u64 val;
506         struct evsel *counter;
507 
508         for (s = 0; s < config->aggr_map->nr; s++) {
509                 id = config->aggr_map->map[s];
510                 evlist__for_each_entry(evlist, counter) {
511                         val = 0;
512                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
513                                 s2 = config->aggr_get_id(config, evlist->core.cpus, cpu);
514                                 if (s2 != id)
515                                         continue;
516                                 val += perf_counts(counter->counts, cpu, 0)->val;
517                         }
518                         perf_stat__update_shadow_stats(counter, val,
519                                         first_shadow_cpu(config, counter, id),
520                                         &rt_stat);
521                 }
522         }
523 }
524 
525 static void uniquify_event_name(struct evsel *counter)
526 {
527         char *new_name;
528         char *config;
529 
530         if (counter->uniquified_name ||
531             !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
532                                            strlen(counter->pmu_name)))
533                 return;
534 
535         config = strchr(counter->name, '/');
536         if (config) {
537                 if (asprintf(&new_name,
538                              "%s%s", counter->pmu_name, config) > 0) {
539                         free(counter->name);
540                         counter->name = new_name;
541                 }
542         } else {
543                 if (asprintf(&new_name,
544                              "%s [%s]", counter->name, counter->pmu_name) > 0) {
545                         free(counter->name);
546                         counter->name = new_name;
547                 }
548         }
549 
550         counter->uniquified_name = true;
551 }
552 
553 static void collect_all_aliases(struct perf_stat_config *config, struct evsel *counter,
554                             void (*cb)(struct perf_stat_config *config, struct evsel *counter, void *data,
555                                        bool first),
556                             void *data)
557 {
558         struct evlist *evlist = counter->evlist;
559         struct evsel *alias;
560 
561         alias = list_prepare_entry(counter, &(evlist->core.entries), core.node);
562         list_for_each_entry_continue (alias, &evlist->core.entries, core.node) {
563                 if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
564                     alias->scale != counter->scale ||
565                     alias->cgrp != counter->cgrp ||
566                     strcmp(alias->unit, counter->unit) ||
567                     perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter) ||
568                     !strcmp(alias->pmu_name, counter->pmu_name))
569                         break;
570                 alias->merged_stat = true;
571                 cb(config, alias, data, false);
572         }
573 }
574 
575 static bool collect_data(struct perf_stat_config *config, struct evsel *counter,
576                             void (*cb)(struct perf_stat_config *config, struct evsel *counter, void *data,
577                                        bool first),
578                             void *data)
579 {
580         if (counter->merged_stat)
581                 return false;
582         cb(config, counter, data, true);
583         if (config->no_merge)
584                 uniquify_event_name(counter);
585         else if (counter->auto_merge_stats)
586                 collect_all_aliases(config, counter, cb, data);
587         return true;
588 }
589 
590 struct aggr_data {
591         u64 ena, run, val;
592         int id;
593         int nr;
594         int cpu;
595 };
596 
597 static void aggr_cb(struct perf_stat_config *config,
598                     struct evsel *counter, void *data, bool first)
599 {
600         struct aggr_data *ad = data;
601         int cpu, s2;
602 
603         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
604                 struct perf_counts_values *counts;
605 
606                 s2 = config->aggr_get_id(config, evsel__cpus(counter), cpu);
607                 if (s2 != ad->id)
608                         continue;
609                 if (first)
610                         ad->nr++;
611                 counts = perf_counts(counter->counts, cpu, 0);
612                 /*
613                  * When any result is bad, make them all to give
614                  * consistent output in interval mode.
615                  */
616                 if (counts->ena == 0 || counts->run == 0 ||
617                     counter->counts->scaled == -1) {
618                         ad->ena = 0;
619                         ad->run = 0;
620                         break;
621                 }
622                 ad->val += counts->val;
623                 ad->ena += counts->ena;
624                 ad->run += counts->run;
625         }
626 }
627 
628 static void print_counter_aggrdata(struct perf_stat_config *config,
629                                    struct evsel *counter, int s,
630                                    char *prefix, bool metric_only,
631                                    bool *first)
632 {
633         struct aggr_data ad;
634         FILE *output = config->output;
635         u64 ena, run, val;
636         int id, nr;
637         double uval;
638 
639         ad.id = id = config->aggr_map->map[s];
640         ad.val = ad.ena = ad.run = 0;
641         ad.nr = 0;
642         if (!collect_data(config, counter, aggr_cb, &ad))
643                 return;
644 
645         nr = ad.nr;
646         ena = ad.ena;
647         run = ad.run;
648         val = ad.val;
649         if (*first && metric_only) {
650                 *first = false;
651                 aggr_printout(config, counter, id, nr);
652         }
653         if (prefix && !metric_only)
654                 fprintf(output, "%s", prefix);
655 
656         uval = val * counter->scale;
657         printout(config, id, nr, counter, uval, prefix,
658                  run, ena, 1.0, &rt_stat);
659         if (!metric_only)
660                 fputc('\n', output);
661 }
662 
663 static void print_aggr(struct perf_stat_config *config,
664                        struct evlist *evlist,
665                        char *prefix)
666 {
667         bool metric_only = config->metric_only;
668         FILE *output = config->output;
669         struct evsel *counter;
670         int s;
671         bool first;
672 
673         if (!(config->aggr_map || config->aggr_get_id))
674                 return;
675 
676         aggr_update_shadow(config, evlist);
677 
678         /*
679          * With metric_only everything is on a single line.
680          * Without each counter has its own line.
681          */
682         for (s = 0; s < config->aggr_map->nr; s++) {
683                 if (prefix && metric_only)
684                         fprintf(output, "%s", prefix);
685 
686                 first = true;
687                 evlist__for_each_entry(evlist, counter) {
688                         print_counter_aggrdata(config, counter, s,
689                                                prefix, metric_only,
690                                                &first);
691                 }
692                 if (metric_only)
693                         fputc('\n', output);
694         }
695 }
696 
697 static int cmp_val(const void *a, const void *b)
698 {
699         return ((struct perf_aggr_thread_value *)b)->val -
700                 ((struct perf_aggr_thread_value *)a)->val;
701 }
702 
703 static struct perf_aggr_thread_value *sort_aggr_thread(
704                                         struct evsel *counter,
705                                         int nthreads, int ncpus,
706                                         int *ret,
707                                         struct target *_target)
708 {
709         int cpu, thread, i = 0;
710         double uval;
711         struct perf_aggr_thread_value *buf;
712 
713         buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
714         if (!buf)
715                 return NULL;
716 
717         for (thread = 0; thread < nthreads; thread++) {
718                 u64 ena = 0, run = 0, val = 0;
719 
720                 for (cpu = 0; cpu < ncpus; cpu++) {
721                         val += perf_counts(counter->counts, cpu, thread)->val;
722                         ena += perf_counts(counter->counts, cpu, thread)->ena;
723                         run += perf_counts(counter->counts, cpu, thread)->run;
724                 }
725 
726                 uval = val * counter->scale;
727 
728                 /*
729                  * Skip value 0 when enabling --per-thread globally,
730                  * otherwise too many 0 output.
731                  */
732                 if (uval == 0.0 && target__has_per_thread(_target))
733                         continue;
734 
735                 buf[i].counter = counter;
736                 buf[i].id = thread;
737                 buf[i].uval = uval;
738                 buf[i].val = val;
739                 buf[i].run = run;
740                 buf[i].ena = ena;
741                 i++;
742         }
743 
744         qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
745 
746         if (ret)
747                 *ret = i;
748 
749         return buf;
750 }
751 
752 static void print_aggr_thread(struct perf_stat_config *config,
753                               struct target *_target,
754                               struct evsel *counter, char *prefix)
755 {
756         FILE *output = config->output;
757         int nthreads = perf_thread_map__nr(counter->core.threads);
758         int ncpus = perf_cpu_map__nr(counter->core.cpus);
759         int thread, sorted_threads, id;
760         struct perf_aggr_thread_value *buf;
761 
762         buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads, _target);
763         if (!buf) {
764                 perror("cannot sort aggr thread");
765                 return;
766         }
767 
768         for (thread = 0; thread < sorted_threads; thread++) {
769                 if (prefix)
770                         fprintf(output, "%s", prefix);
771 
772                 id = buf[thread].id;
773                 if (config->stats)
774                         printout(config, id, 0, buf[thread].counter, buf[thread].uval,
775                                  prefix, buf[thread].run, buf[thread].ena, 1.0,
776                                  &config->stats[id]);
777                 else
778                         printout(config, id, 0, buf[thread].counter, buf[thread].uval,
779                                  prefix, buf[thread].run, buf[thread].ena, 1.0,
780                                  &rt_stat);
781                 fputc('\n', output);
782         }
783 
784         free(buf);
785 }
786 
787 struct caggr_data {
788         double avg, avg_enabled, avg_running;
789 };
790 
791 static void counter_aggr_cb(struct perf_stat_config *config __maybe_unused,
792                             struct evsel *counter, void *data,
793                             bool first __maybe_unused)
794 {
795         struct caggr_data *cd = data;
796         struct perf_stat_evsel *ps = counter->stats;
797 
798         cd->avg += avg_stats(&ps->res_stats[0]);
799         cd->avg_enabled += avg_stats(&ps->res_stats[1]);
800         cd->avg_running += avg_stats(&ps->res_stats[2]);
801 }
802 
803 /*
804  * Print out the results of a single counter:
805  * aggregated counts in system-wide mode
806  */
807 static void print_counter_aggr(struct perf_stat_config *config,
808                                struct evsel *counter, char *prefix)
809 {
810         bool metric_only = config->metric_only;
811         FILE *output = config->output;
812         double uval;
813         struct caggr_data cd = { .avg = 0.0 };
814 
815         if (!collect_data(config, counter, counter_aggr_cb, &cd))
816                 return;
817 
818         if (prefix && !metric_only)
819                 fprintf(output, "%s", prefix);
820 
821         uval = cd.avg * counter->scale;
822         printout(config, -1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
823                  cd.avg, &rt_stat);
824         if (!metric_only)
825                 fprintf(output, "\n");
826 }
827 
828 static void counter_cb(struct perf_stat_config *config __maybe_unused,
829                        struct evsel *counter, void *data,
830                        bool first __maybe_unused)
831 {
832         struct aggr_data *ad = data;
833 
834         ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
835         ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
836         ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
837 }
838 
839 /*
840  * Print out the results of a single counter:
841  * does not use aggregated count in system-wide
842  */
843 static void print_counter(struct perf_stat_config *config,
844                           struct evsel *counter, char *prefix)
845 {
846         FILE *output = config->output;
847         u64 ena, run, val;
848         double uval;
849         int cpu;
850 
851         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
852                 struct aggr_data ad = { .cpu = cpu };
853 
854                 if (!collect_data(config, counter, counter_cb, &ad))
855                         return;
856                 val = ad.val;
857                 ena = ad.ena;
858                 run = ad.run;
859 
860                 if (prefix)
861                         fprintf(output, "%s", prefix);
862 
863                 uval = val * counter->scale;
864                 printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
865                          &rt_stat);
866 
867                 fputc('\n', output);
868         }
869 }
870 
871 static void print_no_aggr_metric(struct perf_stat_config *config,
872                                  struct evlist *evlist,
873                                  char *prefix)
874 {
875         int cpu;
876         int nrcpus = 0;
877         struct evsel *counter;
878         u64 ena, run, val;
879         double uval;
880 
881         nrcpus = evlist->core.cpus->nr;
882         for (cpu = 0; cpu < nrcpus; cpu++) {
883                 bool first = true;
884 
885                 if (prefix)
886                         fputs(prefix, config->output);
887                 evlist__for_each_entry(evlist, counter) {
888                         if (first) {
889                                 aggr_printout(config, counter, cpu, 0);
890                                 first = false;
891                         }
892                         val = perf_counts(counter->counts, cpu, 0)->val;
893                         ena = perf_counts(counter->counts, cpu, 0)->ena;
894                         run = perf_counts(counter->counts, cpu, 0)->run;
895 
896                         uval = val * counter->scale;
897                         printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
898                                  &rt_stat);
899                 }
900                 fputc('\n', config->output);
901         }
902 }
903 
904 static int aggr_header_lens[] = {
905         [AGGR_CORE] = 24,
906         [AGGR_DIE] = 18,
907         [AGGR_SOCKET] = 12,
908         [AGGR_NONE] = 6,
909         [AGGR_THREAD] = 24,
910         [AGGR_GLOBAL] = 0,
911 };
912 
913 static const char *aggr_header_csv[] = {
914         [AGGR_CORE]     =       "core,cpus,",
915         [AGGR_DIE]      =       "die,cpus",
916         [AGGR_SOCKET]   =       "socket,cpus",
917         [AGGR_NONE]     =       "cpu,",
918         [AGGR_THREAD]   =       "comm-pid,",
919         [AGGR_GLOBAL]   =       ""
920 };
921 
922 static void print_metric_headers(struct perf_stat_config *config,
923                                  struct evlist *evlist,
924                                  const char *prefix, bool no_indent)
925 {
926         struct perf_stat_output_ctx out;
927         struct evsel *counter;
928         struct outstate os = {
929                 .fh = config->output
930         };
931 
932         if (prefix)
933                 fprintf(config->output, "%s", prefix);
934 
935         if (!config->csv_output && !no_indent)
936                 fprintf(config->output, "%*s",
937                         aggr_header_lens[config->aggr_mode], "");
938         if (config->csv_output) {
939                 if (config->interval)
940                         fputs("time,", config->output);
941                 fputs(aggr_header_csv[config->aggr_mode], config->output);
942         }
943 
944         /* Print metrics headers only */
945         evlist__for_each_entry(evlist, counter) {
946                 os.evsel = counter;
947                 out.ctx = &os;
948                 out.print_metric = print_metric_header;
949                 out.new_line = new_line_metric;
950                 out.force_header = true;
951                 os.evsel = counter;
952                 perf_stat__print_shadow_stats(config, counter, 0,
953                                               0,
954                                               &out,
955                                               &config->metric_events,
956                                               &rt_stat);
957         }
958         fputc('\n', config->output);
959 }
960 
961 static void print_interval(struct perf_stat_config *config,
962                            struct evlist *evlist,
963                            char *prefix, struct timespec *ts)
964 {
965         bool metric_only = config->metric_only;
966         unsigned int unit_width = config->unit_width;
967         FILE *output = config->output;
968         static int num_print_interval;
969 
970         if (config->interval_clear)
971                 puts(CONSOLE_CLEAR);
972 
973         sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, config->csv_sep);
974 
975         if ((num_print_interval == 0 && !config->csv_output) || config->interval_clear) {
976                 switch (config->aggr_mode) {
977                 case AGGR_NODE:
978                         fprintf(output, "#           time node   cpus");
979                         if (!metric_only)
980                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
981                         break;
982                 case AGGR_SOCKET:
983                         fprintf(output, "#           time socket cpus");
984                         if (!metric_only)
985                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
986                         break;
987                 case AGGR_DIE:
988                         fprintf(output, "#           time die          cpus");
989                         if (!metric_only)
990                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
991                         break;
992                 case AGGR_CORE:
993                         fprintf(output, "#           time core            cpus");
994                         if (!metric_only)
995                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
996                         break;
997                 case AGGR_NONE:
998                         fprintf(output, "#           time CPU    ");
999                         if (!metric_only)
1000                                 fprintf(output, "                counts %*s events\n", unit_width, "unit");
1001                         break;
1002                 case AGGR_THREAD:
1003                         fprintf(output, "#           time             comm-pid");
1004                         if (!metric_only)
1005                                 fprintf(output, "                  counts %*s events\n", unit_width, "unit");
1006                         break;
1007                 case AGGR_GLOBAL:
1008                 default:
1009                         fprintf(output, "#           time");
1010                         if (!metric_only)
1011                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
1012                 case AGGR_UNSET:
1013                         break;
1014                 }
1015         }
1016 
1017         if ((num_print_interval == 0 || config->interval_clear) && metric_only)
1018                 print_metric_headers(config, evlist, " ", true);
1019         if (++num_print_interval == 25)
1020                 num_print_interval = 0;
1021 }
1022 
1023 static void print_header(struct perf_stat_config *config,
1024                          struct target *_target,
1025                          int argc, const char **argv)
1026 {
1027         FILE *output = config->output;
1028         int i;
1029 
1030         fflush(stdout);
1031 
1032         if (!config->csv_output) {
1033                 fprintf(output, "\n");
1034                 fprintf(output, " Performance counter stats for ");
1035                 if (_target->system_wide)
1036                         fprintf(output, "\'system wide");
1037                 else if (_target->cpu_list)
1038                         fprintf(output, "\'CPU(s) %s", _target->cpu_list);
1039                 else if (!target__has_task(_target)) {
1040                         fprintf(output, "\'%s", argv ? argv[0] : "pipe");
1041                         for (i = 1; argv && (i < argc); i++)
1042                                 fprintf(output, " %s", argv[i]);
1043                 } else if (_target->pid)
1044                         fprintf(output, "process id \'%s", _target->pid);
1045                 else
1046                         fprintf(output, "thread id \'%s", _target->tid);
1047 
1048                 fprintf(output, "\'");
1049                 if (config->run_count > 1)
1050                         fprintf(output, " (%d runs)", config->run_count);
1051                 fprintf(output, ":\n\n");
1052         }
1053 }
1054 
1055 static int get_precision(double num)
1056 {
1057         if (num > 1)
1058                 return 0;
1059 
1060         return lround(ceil(-log10(num)));
1061 }
1062 
1063 static void print_table(struct perf_stat_config *config,
1064                         FILE *output, int precision, double avg)
1065 {
1066         char tmp[64];
1067         int idx, indent = 0;
1068 
1069         scnprintf(tmp, 64, " %17.*f", precision, avg);
1070         while (tmp[indent] == ' ')
1071                 indent++;
1072 
1073         fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
1074 
1075         for (idx = 0; idx < config->run_count; idx++) {
1076                 double run = (double) config->walltime_run[idx] / NSEC_PER_SEC;
1077                 int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
1078 
1079                 fprintf(output, " %17.*f (%+.*f) ",
1080                         precision, run, precision, run - avg);
1081 
1082                 for (h = 0; h < n; h++)
1083                         fprintf(output, "#");
1084 
1085                 fprintf(output, "\n");
1086         }
1087 
1088         fprintf(output, "\n%*s# Final result:\n", indent, "");
1089 }
1090 
1091 static double timeval2double(struct timeval *t)
1092 {
1093         return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
1094 }
1095 
1096 static void print_footer(struct perf_stat_config *config)
1097 {
1098         double avg = avg_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
1099         FILE *output = config->output;
1100         int n;
1101 
1102         if (!config->null_run)
1103                 fprintf(output, "\n");
1104 
1105         if (config->run_count == 1) {
1106                 fprintf(output, " %17.9f seconds time elapsed", avg);
1107 
1108                 if (config->ru_display) {
1109                         double ru_utime = timeval2double(&config->ru_data.ru_utime);
1110                         double ru_stime = timeval2double(&config->ru_data.ru_stime);
1111 
1112                         fprintf(output, "\n\n");
1113                         fprintf(output, " %17.9f seconds user\n", ru_utime);
1114                         fprintf(output, " %17.9f seconds sys\n", ru_stime);
1115                 }
1116         } else {
1117                 double sd = stddev_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
1118                 /*
1119                  * Display at most 2 more significant
1120                  * digits than the stddev inaccuracy.
1121                  */
1122                 int precision = get_precision(sd) + 2;
1123 
1124                 if (config->walltime_run_table)
1125                         print_table(config, output, precision, avg);
1126 
1127                 fprintf(output, " %17.*f +- %.*f seconds time elapsed",
1128                         precision, avg, precision, sd);
1129 
1130                 print_noise_pct(config, sd, avg);
1131         }
1132         fprintf(output, "\n\n");
1133 
1134         if (config->print_free_counters_hint &&
1135             sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
1136             n > 0)
1137                 fprintf(output,
1138 "Some events weren't counted. Try disabling the NMI watchdog:\n"
1139 "       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
1140 "       perf stat ...\n"
1141 "       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
1142 
1143         if (config->print_mixed_hw_group_error)
1144                 fprintf(output,
1145                         "The events in group usually have to be from "
1146                         "the same PMU. Try reorganizing the group.\n");
1147 }
1148 
1149 static void print_percore(struct perf_stat_config *config,
1150                           struct evsel *counter, char *prefix)
1151 {
1152         bool metric_only = config->metric_only;
1153         FILE *output = config->output;
1154         int s;
1155         bool first = true;
1156 
1157         if (!(config->aggr_map || config->aggr_get_id))
1158                 return;
1159 
1160         for (s = 0; s < config->aggr_map->nr; s++) {
1161                 if (prefix && metric_only)
1162                         fprintf(output, "%s", prefix);
1163 
1164                 print_counter_aggrdata(config, counter, s,
1165                                        prefix, metric_only,
1166                                        &first);
1167         }
1168 
1169         if (metric_only)
1170                 fputc('\n', output);
1171 }
1172 
1173 void
1174 perf_evlist__print_counters(struct evlist *evlist,
1175                             struct perf_stat_config *config,
1176                             struct target *_target,
1177                             struct timespec *ts,
1178                             int argc, const char **argv)
1179 {
1180         bool metric_only = config->metric_only;
1181         int interval = config->interval;
1182         struct evsel *counter;
1183         char buf[64], *prefix = NULL;
1184 
1185         if (interval)
1186                 print_interval(config, evlist, prefix = buf, ts);
1187         else
1188                 print_header(config, _target, argc, argv);
1189 
1190         if (metric_only) {
1191                 static int num_print_iv;
1192 
1193                 if (num_print_iv == 0 && !interval)
1194                         print_metric_headers(config, evlist, prefix, false);
1195                 if (num_print_iv++ == 25)
1196                         num_print_iv = 0;
1197                 if (config->aggr_mode == AGGR_GLOBAL && prefix)
1198                         fprintf(config->output, "%s", prefix);
1199         }
1200 
1201         switch (config->aggr_mode) {
1202         case AGGR_CORE:
1203         case AGGR_DIE:
1204         case AGGR_SOCKET:
1205         case AGGR_NODE:
1206                 print_aggr(config, evlist, prefix);
1207                 break;
1208         case AGGR_THREAD:
1209                 evlist__for_each_entry(evlist, counter) {
1210                         print_aggr_thread(config, _target, counter, prefix);
1211                 }
1212                 break;
1213         case AGGR_GLOBAL:
1214                 evlist__for_each_entry(evlist, counter) {
1215                         print_counter_aggr(config, counter, prefix);
1216                 }
1217                 if (metric_only)
1218                         fputc('\n', config->output);
1219                 break;
1220         case AGGR_NONE:
1221                 if (metric_only)
1222                         print_no_aggr_metric(config, evlist, prefix);
1223                 else {
1224                         evlist__for_each_entry(evlist, counter) {
1225                                 if (counter->percore)
1226                                         print_percore(config, counter, prefix);
1227                                 else
1228                                         print_counter(config, counter, prefix);
1229                         }
1230                 }
1231                 break;
1232         case AGGR_UNSET:
1233         default:
1234                 break;
1235         }
1236 
1237         if (!interval && !config->csv_output)
1238                 print_footer(config);
1239 
1240         fflush(config->output);
1241 }
1242 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp