xref: /openbmc/linux/tools/perf/util/values.c (revision 2a598d0b) 
1 // SPDX-License-Identifier: GPL-2.0
2 #include <inttypes.h>
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <errno.h>
7 #include <linux/zalloc.h>
8 
9 #include "values.h"
10 #include "debug.h"
11 
12 int perf_read_values_init(struct perf_read_values *values)
13 {
14 	values->threads_max = 16;
15 	values->pid = malloc(values->threads_max * sizeof(*values->pid));
16 	values->tid = malloc(values->threads_max * sizeof(*values->tid));
17 	values->value = zalloc(values->threads_max * sizeof(*values->value));
18 	if (!values->pid || !values->tid || !values->value) {
19 		pr_debug("failed to allocate read_values threads arrays");
20 		goto out_free_pid;
21 	}
22 	values->threads = 0;
23 
24 	values->counters_max = 16;
25 	values->counterrawid = malloc(values->counters_max
26 				      * sizeof(*values->counterrawid));
27 	values->countername = malloc(values->counters_max
28 				     * sizeof(*values->countername));
29 	if (!values->counterrawid || !values->countername) {
30 		pr_debug("failed to allocate read_values counters arrays");
31 		goto out_free_counter;
32 	}
33 	values->counters = 0;
34 
35 	return 0;
36 
37 out_free_counter:
38 	zfree(&values->counterrawid);
39 	zfree(&values->countername);
40 out_free_pid:
41 	zfree(&values->pid);
42 	zfree(&values->tid);
43 	zfree(&values->value);
44 	return -ENOMEM;
45 }
46 
47 void perf_read_values_destroy(struct perf_read_values *values)
48 {
49 	int i;
50 
51 	if (!values->threads_max || !values->counters_max)
52 		return;
53 
54 	for (i = 0; i < values->threads; i++)
55 		zfree(&values->value[i]);
56 	zfree(&values->value);
57 	zfree(&values->pid);
58 	zfree(&values->tid);
59 	zfree(&values->counterrawid);
60 	for (i = 0; i < values->counters; i++)
61 		zfree(&values->countername[i]);
62 	zfree(&values->countername);
63 }
64 
65 static int perf_read_values__enlarge_threads(struct perf_read_values *values)
66 {
67 	int nthreads_max = values->threads_max * 2;
68 	void *npid = realloc(values->pid, nthreads_max * sizeof(*values->pid)),
69 	     *ntid = realloc(values->tid, nthreads_max * sizeof(*values->tid)),
70 	     *nvalue = realloc(values->value, nthreads_max * sizeof(*values->value));
71 
72 	if (!npid || !ntid || !nvalue)
73 		goto out_err;
74 
75 	values->threads_max = nthreads_max;
76 	values->pid = npid;
77 	values->tid = ntid;
78 	values->value = nvalue;
79 	return 0;
80 out_err:
81 	free(npid);
82 	free(ntid);
83 	free(nvalue);
84 	pr_debug("failed to enlarge read_values threads arrays");
85 	return -ENOMEM;
86 }
87 
88 static int perf_read_values__findnew_thread(struct perf_read_values *values,
89 					    u32 pid, u32 tid)
90 {
91 	int i;
92 
93 	for (i = 0; i < values->threads; i++)
94 		if (values->pid[i] == pid && values->tid[i] == tid)
95 			return i;
96 
97 	if (values->threads == values->threads_max) {
98 		i = perf_read_values__enlarge_threads(values);
99 		if (i < 0)
100 			return i;
101 	}
102 
103 	i = values->threads;
104 
105 	values->value[i] = zalloc(values->counters_max * sizeof(**values->value));
106 	if (!values->value[i]) {
107 		pr_debug("failed to allocate read_values counters array");
108 		return -ENOMEM;
109 	}
110 	values->pid[i] = pid;
111 	values->tid[i] = tid;
112 	values->threads = i + 1;
113 
114 	return i;
115 }
116 
117 static int perf_read_values__enlarge_counters(struct perf_read_values *values)
118 {
119 	char **countername;
120 	int i, counters_max = values->counters_max * 2;
121 	u64 *counterrawid = realloc(values->counterrawid, counters_max * sizeof(*values->counterrawid));
122 
123 	if (!counterrawid) {
124 		pr_debug("failed to enlarge read_values rawid array");
125 		goto out_enomem;
126 	}
127 
128 	countername = realloc(values->countername, counters_max * sizeof(*values->countername));
129 	if (!countername) {
130 		pr_debug("failed to enlarge read_values rawid array");
131 		goto out_free_rawid;
132 	}
133 
134 	for (i = 0; i < values->threads; i++) {
135 		u64 *value = realloc(values->value[i], counters_max * sizeof(**values->value));
136 		int j;
137 
138 		if (!value) {
139 			pr_debug("failed to enlarge read_values ->values array");
140 			goto out_free_name;
141 		}
142 
143 		for (j = values->counters_max; j < counters_max; j++)
144 			value[j] = 0;
145 
146 		values->value[i] = value;
147 	}
148 
149 	values->counters_max = counters_max;
150 	values->counterrawid = counterrawid;
151 	values->countername  = countername;
152 
153 	return 0;
154 out_free_name:
155 	free(countername);
156 out_free_rawid:
157 	free(counterrawid);
158 out_enomem:
159 	return -ENOMEM;
160 }
161 
162 static int perf_read_values__findnew_counter(struct perf_read_values *values,
163 					     u64 rawid, const char *name)
164 {
165 	int i;
166 
167 	for (i = 0; i < values->counters; i++)
168 		if (values->counterrawid[i] == rawid)
169 			return i;
170 
171 	if (values->counters == values->counters_max) {
172 		i = perf_read_values__enlarge_counters(values);
173 		if (i)
174 			return i;
175 	}
176 
177 	i = values->counters++;
178 	values->counterrawid[i] = rawid;
179 	values->countername[i] = strdup(name);
180 
181 	return i;
182 }
183 
184 int perf_read_values_add_value(struct perf_read_values *values,
185 				u32 pid, u32 tid,
186 				u64 rawid, const char *name, u64 value)
187 {
188 	int tindex, cindex;
189 
190 	tindex = perf_read_values__findnew_thread(values, pid, tid);
191 	if (tindex < 0)
192 		return tindex;
193 	cindex = perf_read_values__findnew_counter(values, rawid, name);
194 	if (cindex < 0)
195 		return cindex;
196 
197 	values->value[tindex][cindex] += value;
198 	return 0;
199 }
200 
201 static void perf_read_values__display_pretty(FILE *fp,
202 					     struct perf_read_values *values)
203 {
204 	int i, j;
205 	int pidwidth, tidwidth;
206 	int *counterwidth;
207 
208 	counterwidth = malloc(values->counters * sizeof(*counterwidth));
209 	if (!counterwidth) {
210 		fprintf(fp, "INTERNAL ERROR: Failed to allocate counterwidth array\n");
211 		return;
212 	}
213 	tidwidth = 3;
214 	pidwidth = 3;
215 	for (j = 0; j < values->counters; j++)
216 		counterwidth[j] = strlen(values->countername[j]);
217 	for (i = 0; i < values->threads; i++) {
218 		int width;
219 
220 		width = snprintf(NULL, 0, "%d", values->pid[i]);
221 		if (width > pidwidth)
222 			pidwidth = width;
223 		width = snprintf(NULL, 0, "%d", values->tid[i]);
224 		if (width > tidwidth)
225 			tidwidth = width;
226 		for (j = 0; j < values->counters; j++) {
227 			width = snprintf(NULL, 0, "%" PRIu64, values->value[i][j]);
228 			if (width > counterwidth[j])
229 				counterwidth[j] = width;
230 		}
231 	}
232 
233 	fprintf(fp, "# %*s  %*s", pidwidth, "PID", tidwidth, "TID");
234 	for (j = 0; j < values->counters; j++)
235 		fprintf(fp, "  %*s", counterwidth[j], values->countername[j]);
236 	fprintf(fp, "\n");
237 
238 	for (i = 0; i < values->threads; i++) {
239 		fprintf(fp, "  %*d  %*d", pidwidth, values->pid[i],
240 			tidwidth, values->tid[i]);
241 		for (j = 0; j < values->counters; j++)
242 			fprintf(fp, "  %*" PRIu64,
243 				counterwidth[j], values->value[i][j]);
244 		fprintf(fp, "\n");
245 	}
246 	free(counterwidth);
247 }
248 
249 static void perf_read_values__display_raw(FILE *fp,
250 					  struct perf_read_values *values)
251 {
252 	int width, pidwidth, tidwidth, namewidth, rawwidth, countwidth;
253 	int i, j;
254 
255 	tidwidth = 3; /* TID */
256 	pidwidth = 3; /* PID */
257 	namewidth = 4; /* "Name" */
258 	rawwidth = 3; /* "Raw" */
259 	countwidth = 5; /* "Count" */
260 
261 	for (i = 0; i < values->threads; i++) {
262 		width = snprintf(NULL, 0, "%d", values->pid[i]);
263 		if (width > pidwidth)
264 			pidwidth = width;
265 		width = snprintf(NULL, 0, "%d", values->tid[i]);
266 		if (width > tidwidth)
267 			tidwidth = width;
268 	}
269 	for (j = 0; j < values->counters; j++) {
270 		width = strlen(values->countername[j]);
271 		if (width > namewidth)
272 			namewidth = width;
273 		width = snprintf(NULL, 0, "%" PRIx64, values->counterrawid[j]);
274 		if (width > rawwidth)
275 			rawwidth = width;
276 	}
277 	for (i = 0; i < values->threads; i++) {
278 		for (j = 0; j < values->counters; j++) {
279 			width = snprintf(NULL, 0, "%" PRIu64, values->value[i][j]);
280 			if (width > countwidth)
281 				countwidth = width;
282 		}
283 	}
284 
285 	fprintf(fp, "# %*s  %*s  %*s  %*s  %*s\n",
286 		pidwidth, "PID", tidwidth, "TID",
287 		namewidth, "Name", rawwidth, "Raw",
288 		countwidth, "Count");
289 	for (i = 0; i < values->threads; i++)
290 		for (j = 0; j < values->counters; j++)
291 			fprintf(fp, "  %*d  %*d  %*s  %*" PRIx64 "  %*" PRIu64,
292 				pidwidth, values->pid[i],
293 				tidwidth, values->tid[i],
294 				namewidth, values->countername[j],
295 				rawwidth, values->counterrawid[j],
296 				countwidth, values->value[i][j]);
297 }
298 
299 void perf_read_values_display(FILE *fp, struct perf_read_values *values, int raw)
300 {
301 	if (raw)
302 		perf_read_values__display_raw(fp, values);
303 	else
304 		perf_read_values__display_pretty(fp, values);
305 }
306