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