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 | |