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