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